From f4745b9ac5f8c7157b1374994e80aa6f0aeb9c9a Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Tue, 26 Jul 2022 07:27:45 +0000 Subject: [PATCH 001/101] Add FFT ops from core TensorFlow --- tensorflow_mri/cc/kernels/fft_kernels.cc | 634 +++++++++++++++++++++++ tensorflow_mri/cc/ops/fft_ops.cc | 191 +++++++ 2 files changed, 825 insertions(+) create mode 100644 tensorflow_mri/cc/kernels/fft_kernels.cc create mode 100644 tensorflow_mri/cc/ops/fft_ops.cc diff --git a/tensorflow_mri/cc/kernels/fft_kernels.cc b/tensorflow_mri/cc/kernels/fft_kernels.cc new file mode 100644 index 00000000..31868638 --- /dev/null +++ b/tensorflow_mri/cc/kernels/fft_kernels.cc @@ -0,0 +1,634 @@ +/* Copyright 2015 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/platform/errors.h" +#define EIGEN_USE_THREADS + +// See docs in ../ops/fft_ops.cc. + +#include "third_party/eigen3/unsupported/Eigen/CXX11/Tensor" +#include "tensorflow/core/framework/op.h" +#include "tensorflow/core/framework/op_kernel.h" +#include "tensorflow/core/framework/tensor.h" +#include "tensorflow/core/framework/tensor_shape.h" +#include "tensorflow/core/framework/types.h" +#include "tensorflow/core/lib/core/errors.h" +#include "tensorflow/core/platform/logging.h" +#include "tensorflow/core/platform/types.h" +#include "tensorflow/core/util/env_var.h" +#include "tensorflow/core/util/work_sharder.h" + +#if (defined(GOOGLE_CUDA) && GOOGLE_CUDA) || \ + (defined(TENSORFLOW_USE_ROCM) && TENSORFLOW_USE_ROCM) +#include "tensorflow/core/platform/stream_executor.h" +#endif // GOOGLE_CUDA || TENSORFLOW_USE_ROCM + +namespace tensorflow { + +class FFTBase : public OpKernel { + public: + explicit FFTBase(OpKernelConstruction* ctx) : OpKernel(ctx) {} + + void Compute(OpKernelContext* ctx) override { + const Tensor& in = ctx->input(0); + const TensorShape& input_shape = in.shape(); + const int fft_rank = Rank(); + OP_REQUIRES( + ctx, input_shape.dims() >= fft_rank, + errors::InvalidArgument("Input must have rank of at least ", fft_rank, + " but got: ", input_shape.DebugString())); + + Tensor* out; + TensorShape output_shape = input_shape; + uint64 fft_shape[3] = {0, 0, 0}; + + // In R2C or C2R mode, we use a second input to specify the FFT length + // instead of inferring it from the input shape. + if (IsReal()) { + const Tensor& fft_length = ctx->input(1); + OP_REQUIRES(ctx, + fft_length.shape().dims() == 1 && + fft_length.shape().dim_size(0) == fft_rank, + errors::InvalidArgument("fft_length must have shape [", + fft_rank, "]")); + + auto fft_length_as_vec = fft_length.vec(); + for (int i = 0; i < fft_rank; ++i) { + OP_REQUIRES(ctx, fft_length_as_vec(i) >= 0, + errors::InvalidArgument( + "fft_length[", i, + "] must >= 0, but got: ", fft_length_as_vec(i))); + fft_shape[i] = fft_length_as_vec(i); + // Each input dimension must have length of at least fft_shape[i]. For + // IRFFTs, the inner-most input dimension must have length of at least + // fft_shape[i] / 2 + 1. + bool inner_most = (i == fft_rank - 1); + uint64 min_input_dim_length = + !IsForward() && inner_most ? fft_shape[i] / 2 + 1 : fft_shape[i]; + auto input_index = input_shape.dims() - fft_rank + i; + OP_REQUIRES( + ctx, + // We pass through empty tensors, so special case them here. + input_shape.dim_size(input_index) == 0 || + input_shape.dim_size(input_index) >= min_input_dim_length, + errors::InvalidArgument( + "Input dimension ", input_index, + " must have length of at least ", min_input_dim_length, + " but got: ", input_shape.dim_size(input_index))); + uint64 dim = IsForward() && inner_most && fft_shape[i] != 0 + ? fft_shape[i] / 2 + 1 + : fft_shape[i]; + output_shape.set_dim(output_shape.dims() - fft_rank + i, dim); + } + } else { + for (int i = 0; i < fft_rank; ++i) { + fft_shape[i] = + output_shape.dim_size(output_shape.dims() - fft_rank + i); + } + } + + OP_REQUIRES_OK(ctx, ctx->allocate_output(0, output_shape, &out)); + + if (IsReal()) { + if (IsForward()) { + OP_REQUIRES( + ctx, + (in.dtype() == DT_FLOAT && out->dtype() == DT_COMPLEX64) || + (in.dtype() == DT_DOUBLE && out->dtype() == DT_COMPLEX128), + errors::InvalidArgument("Wrong types for forward real FFT: in=", + in.dtype(), " out=", out->dtype())); + } else { + OP_REQUIRES( + ctx, + (in.dtype() == DT_COMPLEX64 && out->dtype() == DT_FLOAT) || + (in.dtype() == DT_COMPLEX128 && out->dtype() == DT_DOUBLE), + errors::InvalidArgument("Wrong types for backward real FFT: in=", + in.dtype(), " out=", out->dtype())); + } + } else { + OP_REQUIRES( + ctx, + (in.dtype() == DT_COMPLEX64 && out->dtype() == DT_COMPLEX64) || + (in.dtype() == DT_COMPLEX128 && out->dtype() == DT_COMPLEX128), + errors::InvalidArgument("Wrong types for FFT: in=", in.dtype(), + " out=", out->dtype())); + } + + if (input_shape.num_elements() == 0) { + DCHECK_EQ(0, output_shape.num_elements()); + return; + } + + DoFFT(ctx, in, fft_shape, out); + } + + protected: + virtual int Rank() const = 0; + virtual bool IsForward() const = 0; + virtual bool IsReal() const = 0; + + // The function that actually computes the FFT. + virtual void DoFFT(OpKernelContext* ctx, const Tensor& in, uint64* fft_shape, + Tensor* out) = 0; +}; + +typedef Eigen::ThreadPoolDevice CPUDevice; + +template +class FFTCPU : public FFTBase { + public: + using FFTBase::FFTBase; + + protected: + int Rank() const override { return FFTRank; } + bool IsForward() const override { return Forward; } + bool IsReal() const override { return _Real; } + + void DoFFT(OpKernelContext* ctx, const Tensor& in, uint64* fft_shape, + Tensor* out) override { + // Create the axes (which are always trailing). + const auto axes = Eigen::ArrayXi::LinSpaced(FFTRank, 1, FFTRank); + auto device = ctx->eigen_device(); + + const bool is_complex128 = + in.dtype() == DT_COMPLEX128 || out->dtype() == DT_COMPLEX128; + + if (!IsReal()) { + // Compute the FFT using Eigen. + constexpr auto direction = + Forward ? Eigen::FFT_FORWARD : Eigen::FFT_REVERSE; + if (is_complex128) { + DCHECK_EQ(in.dtype(), DT_COMPLEX128); + DCHECK_EQ(out->dtype(), DT_COMPLEX128); + auto input = Tensor(in).flat_inner_dims(); + auto output = out->flat_inner_dims(); + output.device(device) = + input.template fft(axes); + } else { + DCHECK_EQ(in.dtype(), DT_COMPLEX64); + DCHECK_EQ(out->dtype(), DT_COMPLEX64); + auto input = Tensor(in).flat_inner_dims(); + auto output = out->flat_inner_dims(); + output.device(device) = + input.template fft(axes); + } + } else { + if (IsForward()) { + if (is_complex128) { + DCHECK_EQ(in.dtype(), DT_DOUBLE); + DCHECK_EQ(out->dtype(), DT_COMPLEX128); + DoRealForwardFFT(ctx, fft_shape, in, out); + } else { + DCHECK_EQ(in.dtype(), DT_FLOAT); + DCHECK_EQ(out->dtype(), DT_COMPLEX64); + DoRealForwardFFT(ctx, fft_shape, in, out); + } + } else { + if (is_complex128) { + DCHECK_EQ(in.dtype(), DT_COMPLEX128); + DCHECK_EQ(out->dtype(), DT_DOUBLE); + DoRealBackwardFFT(ctx, fft_shape, in, out); + } else { + DCHECK_EQ(in.dtype(), DT_COMPLEX64); + DCHECK_EQ(out->dtype(), DT_FLOAT); + DoRealBackwardFFT(ctx, fft_shape, in, out); + } + } + } + } + + template + void DoRealForwardFFT(OpKernelContext* ctx, uint64* fft_shape, + const Tensor& in, Tensor* out) { + // Create the axes (which are always trailing). + const auto axes = Eigen::ArrayXi::LinSpaced(FFTRank, 1, FFTRank); + auto device = ctx->eigen_device(); + auto input = Tensor(in).flat_inner_dims(); + const auto input_dims = input.dimensions(); + + // Slice input to fft_shape on its inner-most dimensions. + Eigen::DSizes input_slice_sizes; + input_slice_sizes[0] = input_dims[0]; + TensorShape temp_shape{input_dims[0]}; + for (int i = 1; i <= FFTRank; ++i) { + input_slice_sizes[i] = fft_shape[i - 1]; + temp_shape.AddDim(fft_shape[i - 1]); + } + OP_REQUIRES(ctx, temp_shape.num_elements() > 0, + errors::InvalidArgument("Obtained a FFT shape of 0 elements: ", + temp_shape.DebugString())); + + auto output = out->flat_inner_dims(); + const Eigen::DSizes zero_start_indices; + + // Compute the full FFT using a temporary tensor. + Tensor temp; + OP_REQUIRES_OK(ctx, ctx->allocate_temp(DataTypeToEnum::v(), + temp_shape, &temp)); + auto full_fft = temp.flat_inner_dims(); + full_fft.device(device) = + input.slice(zero_start_indices, input_slice_sizes) + .template fft(axes); + + // Slice away the negative frequency components. + output.device(device) = + full_fft.slice(zero_start_indices, output.dimensions()); + } + + template + void DoRealBackwardFFT(OpKernelContext* ctx, uint64* fft_shape, + const Tensor& in, Tensor* out) { + auto device = ctx->eigen_device(); + // Reconstruct the full FFT and take the inverse. + auto input = Tensor(in).flat_inner_dims(); + auto output = out->flat_inner_dims(); + const auto input_dims = input.dimensions(); + + // Calculate the shape of the temporary tensor for the full FFT and the + // region we will slice from input given fft_shape. We slice input to + // fft_shape on its inner-most dimensions, except the last (which we + // slice to fft_shape[-1] / 2 + 1). + Eigen::DSizes input_slice_sizes; + input_slice_sizes[0] = input_dims[0]; + TensorShape full_fft_shape; + full_fft_shape.AddDim(input_dims[0]); + for (auto i = 1; i <= FFTRank; i++) { + input_slice_sizes[i] = + i == FFTRank ? fft_shape[i - 1] / 2 + 1 : fft_shape[i - 1]; + full_fft_shape.AddDim(fft_shape[i - 1]); + } + OP_REQUIRES(ctx, full_fft_shape.num_elements() > 0, + errors::InvalidArgument("Obtained a FFT shape of 0 elements: ", + full_fft_shape.DebugString())); + + Tensor temp; + OP_REQUIRES_OK(ctx, ctx->allocate_temp(DataTypeToEnum::v(), + full_fft_shape, &temp)); + auto full_fft = temp.flat_inner_dims(); + + // Calculate the starting point and range of the source of + // negative frequency part. + auto neg_sizes = input_slice_sizes; + neg_sizes[FFTRank] = fft_shape[FFTRank - 1] - input_slice_sizes[FFTRank]; + Eigen::DSizes neg_target_indices; + neg_target_indices[FFTRank] = input_slice_sizes[FFTRank]; + + const Eigen::DSizes start_indices; + Eigen::DSizes neg_start_indices; + neg_start_indices[FFTRank] = 1; + + full_fft.slice(start_indices, input_slice_sizes).device(device) = + input.slice(start_indices, input_slice_sizes); + + // First, conduct IFFTs on outer dimensions. We save computation (and + // avoid touching uninitialized memory) by slicing full_fft to the + // subregion we wrote input to. + if (FFTRank > 1) { + const auto outer_axes = + Eigen::ArrayXi::LinSpaced(FFTRank - 1, 1, FFTRank - 1); + full_fft.slice(start_indices, input_slice_sizes).device(device) = + full_fft.slice(start_indices, input_slice_sizes) + .template fft(outer_axes); + } + + // Reconstruct the full FFT by appending reversed and conjugated + // spectrum as the negative frequency part. + Eigen::array reverse_last_axis; + for (auto i = 0; i <= FFTRank; i++) { + reverse_last_axis[i] = i == FFTRank; + } + + if (neg_sizes[FFTRank] != 0) { + full_fft.slice(neg_target_indices, neg_sizes).device(device) = + full_fft.slice(neg_start_indices, neg_sizes) + .reverse(reverse_last_axis) + .conjugate(); + } + + auto inner_axis = Eigen::array{FFTRank}; + output.device(device) = + full_fft.template fft(inner_axis); + } +}; + +REGISTER_KERNEL_BUILDER(Name("FFT").Device(DEVICE_CPU), FFTCPU); +REGISTER_KERNEL_BUILDER(Name("IFFT").Device(DEVICE_CPU), + FFTCPU); +REGISTER_KERNEL_BUILDER(Name("FFT2D").Device(DEVICE_CPU), + FFTCPU); +REGISTER_KERNEL_BUILDER(Name("IFFT2D").Device(DEVICE_CPU), + FFTCPU); +REGISTER_KERNEL_BUILDER(Name("FFT3D").Device(DEVICE_CPU), + FFTCPU); +REGISTER_KERNEL_BUILDER(Name("IFFT3D").Device(DEVICE_CPU), + FFTCPU); + +REGISTER_KERNEL_BUILDER(Name("RFFT").Device(DEVICE_CPU), FFTCPU); +REGISTER_KERNEL_BUILDER(Name("IRFFT").Device(DEVICE_CPU), + FFTCPU); +REGISTER_KERNEL_BUILDER(Name("RFFT2D").Device(DEVICE_CPU), + FFTCPU); +REGISTER_KERNEL_BUILDER(Name("IRFFT2D").Device(DEVICE_CPU), + FFTCPU); +REGISTER_KERNEL_BUILDER(Name("RFFT3D").Device(DEVICE_CPU), + FFTCPU); +REGISTER_KERNEL_BUILDER(Name("IRFFT3D").Device(DEVICE_CPU), + FFTCPU); + +#if (defined(GOOGLE_CUDA) && GOOGLE_CUDA) || \ + (defined(TENSORFLOW_USE_ROCM) && TENSORFLOW_USE_ROCM) + +namespace { +template +se::DeviceMemory AsDeviceMemory(const T* cuda_memory) { + se::DeviceMemoryBase wrapped(const_cast(cuda_memory)); + se::DeviceMemory typed(wrapped); + return typed; +} + +template +se::DeviceMemory AsDeviceMemory(const T* cuda_memory, uint64 size) { + se::DeviceMemoryBase wrapped(const_cast(cuda_memory), size * sizeof(T)); + se::DeviceMemory typed(wrapped); + return typed; +} + +// A class to provide scratch-space allocator for Stream-Executor Cufft +// callback. Tensorflow is responsible for releasing the temporary buffers after +// the kernel finishes. +// TODO(yangzihao): Refactor redundant code in subclasses of ScratchAllocator +// into base class. +class CufftScratchAllocator : public se::ScratchAllocator { + public: + ~CufftScratchAllocator() override {} + CufftScratchAllocator(int64_t memory_limit, OpKernelContext* context) + : memory_limit_(memory_limit), total_byte_size_(0), context_(context) {} + int64_t GetMemoryLimitInBytes() override { return memory_limit_; } + se::port::StatusOr> AllocateBytes( + int64_t byte_size) override { + Tensor temporary_memory; + if (byte_size > memory_limit_) { + return se::port::StatusOr>(); + } + AllocationAttributes allocation_attr; + allocation_attr.retry_on_failure = false; + Status allocation_status(context_->allocate_temp( + DT_UINT8, TensorShape({byte_size}), &temporary_memory, + AllocatorAttributes(), allocation_attr)); + if (!allocation_status.ok()) { + return se::port::StatusOr>(); + } + // Hold the reference of the allocated tensors until the end of the + // allocator. + allocated_tensors_.push_back(temporary_memory); + total_byte_size_ += byte_size; + return se::port::StatusOr>( + AsDeviceMemory(temporary_memory.flat().data(), + temporary_memory.flat().size())); + } + int64_t TotalByteSize() { return total_byte_size_; } + + private: + int64_t memory_limit_; + int64_t total_byte_size_; + OpKernelContext* context_; + std::vector allocated_tensors_; +}; + +} // end namespace + +int64_t GetCufftWorkspaceLimit(const string& envvar_in_mb, + int64_t default_value_in_bytes) { + const char* workspace_limit_in_mb_str = getenv(envvar_in_mb.c_str()); + if (workspace_limit_in_mb_str != nullptr && + strcmp(workspace_limit_in_mb_str, "") != 0) { + int64_t scratch_limit_in_mb = -1; + Status status = ReadInt64FromEnvVar(envvar_in_mb, default_value_in_bytes, + &scratch_limit_in_mb); + if (!status.ok()) { + LOG(WARNING) << "Invalid value for env-var " << envvar_in_mb << ": " + << workspace_limit_in_mb_str; + } else { + return scratch_limit_in_mb * (1 << 20); + } + } + return default_value_in_bytes; +} + +class FFTGPUBase : public FFTBase { + public: + using FFTBase::FFTBase; + + protected: + static int64_t CufftScratchSize; + void DoFFT(OpKernelContext* ctx, const Tensor& in, uint64* fft_shape, + Tensor* out) override { + auto* stream = ctx->op_device_context()->stream(); + OP_REQUIRES(ctx, stream, errors::Internal("No GPU stream available.")); + + const TensorShape& input_shape = in.shape(); + const TensorShape& output_shape = out->shape(); + + const int fft_rank = Rank(); + int batch_size = 1; + for (int i = 0; i < input_shape.dims() - fft_rank; ++i) { + batch_size *= input_shape.dim_size(i); + } + uint64 input_embed[3]; + const uint64 input_stride = 1; + uint64 input_distance = 1; + uint64 output_embed[3]; + const uint64 output_stride = 1; + uint64 output_distance = 1; + + for (int i = 0; i < fft_rank; ++i) { + auto dim_offset = input_shape.dims() - fft_rank + i; + input_embed[i] = input_shape.dim_size(dim_offset); + input_distance *= input_shape.dim_size(dim_offset); + output_embed[i] = output_shape.dim_size(dim_offset); + output_distance *= output_shape.dim_size(dim_offset); + } + + constexpr bool kInPlaceFft = false; + const bool is_complex128 = + in.dtype() == DT_COMPLEX128 || out->dtype() == DT_COMPLEX128; + + const auto kFftType = + IsReal() + ? (IsForward() + ? (is_complex128 ? se::fft::Type::kD2Z : se::fft::Type::kR2C) + : (is_complex128 ? se::fft::Type::kZ2D + : se::fft::Type::kC2R)) + : (IsForward() ? (is_complex128 ? se::fft::Type::kZ2ZForward + : se::fft::Type::kC2CForward) + : (is_complex128 ? se::fft::Type::kZ2ZInverse + : se::fft::Type::kC2CInverse)); + + CufftScratchAllocator scratch_allocator(CufftScratchSize, ctx); + auto plan = + stream->parent()->AsFft()->CreateBatchedPlanWithScratchAllocator( + stream, fft_rank, fft_shape, input_embed, input_stride, + input_distance, output_embed, output_stride, output_distance, + kFftType, kInPlaceFft, batch_size, &scratch_allocator); + + if (IsReal()) { + if (IsForward()) { + if (is_complex128) { + DCHECK_EQ(in.dtype(), DT_DOUBLE); + DCHECK_EQ(out->dtype(), DT_COMPLEX128); + DoFFTInternal(ctx, stream, plan.get(), kFftType, + output_distance, in, out); + } else { + DCHECK_EQ(in.dtype(), DT_FLOAT); + DCHECK_EQ(out->dtype(), DT_COMPLEX64); + DoFFTInternal(ctx, stream, plan.get(), kFftType, + output_distance, in, out); + } + } else { + if (is_complex128) { + DCHECK_EQ(in.dtype(), DT_COMPLEX128); + DCHECK_EQ(out->dtype(), DT_DOUBLE); + DoFFTInternal(ctx, stream, plan.get(), kFftType, + output_distance, in, out); + } else { + DCHECK_EQ(in.dtype(), DT_COMPLEX64); + DCHECK_EQ(out->dtype(), DT_FLOAT); + DoFFTInternal(ctx, stream, plan.get(), kFftType, + output_distance, in, out); + } + } + } else { + if (is_complex128) { + DCHECK_EQ(in.dtype(), DT_COMPLEX128); + DCHECK_EQ(out->dtype(), DT_COMPLEX128); + DoFFTInternal(ctx, stream, plan.get(), kFftType, + output_distance, in, out); + } else { + DCHECK_EQ(in.dtype(), DT_COMPLEX64); + DCHECK_EQ(out->dtype(), DT_COMPLEX64); + DoFFTInternal(ctx, stream, plan.get(), kFftType, + output_distance, in, out); + } + } + } + + private: + template + struct RealTypeFromComplexType { + typedef T RealT; + }; + + template + struct RealTypeFromComplexType> { + typedef T RealT; + }; + + template + void DoFFTInternal(OpKernelContext* ctx, se::Stream* stream, + se::fft::Plan* plan, const se::fft::Type fft_type, + const uint64 output_distance, const Tensor& in, + Tensor* out) { + const TensorShape& input_shape = in.shape(); + const TensorShape& output_shape = out->shape(); + auto src = + AsDeviceMemory(in.flat().data(), input_shape.num_elements()); + auto dst = AsDeviceMemory(out->flat().data(), + output_shape.num_elements()); + OP_REQUIRES( + ctx, stream->ThenFft(plan, src, &dst).ok(), + errors::Internal("fft failed : type=", static_cast(fft_type), + " in.shape=", input_shape.DebugString())); + if (!IsForward()) { + typedef typename RealTypeFromComplexType::RealT RealT; + RealT alpha = 1.0 / output_distance; + OP_REQUIRES( + ctx, + stream->ThenBlasScal(output_shape.num_elements(), alpha, &dst, 1) + .ok(), + errors::Internal("BlasScal failed : in.shape=", + input_shape.DebugString())); + } + } +}; + +int64_t FFTGPUBase::CufftScratchSize = GetCufftWorkspaceLimit( + // default value is in bytes despite the name of the environment variable + "TF_CUFFT_WORKSPACE_LIMIT_IN_MB", 1LL << 32 // 4GB +); + +template +class FFTGPU : public FFTGPUBase { + public: + static_assert(FFTRank >= 1 && FFTRank <= 3, + "Only 1D, 2D and 3D FFTs supported."); + explicit FFTGPU(OpKernelConstruction* ctx) : FFTGPUBase(ctx) {} + + protected: + int Rank() const override { return FFTRank; } + bool IsForward() const override { return Forward; } + bool IsReal() const override { return _Real; } +}; + +// Register GPU kernels with priority 1 so that if a custom FFT CPU kernel is +// registered with priority 1 (to override the default Eigen CPU kernel), the +// CPU kernel does not outrank the GPU kernel. +REGISTER_KERNEL_BUILDER(Name("FFT").Device(DEVICE_GPU).Priority(1), + FFTGPU); +REGISTER_KERNEL_BUILDER(Name("IFFT").Device(DEVICE_GPU).Priority(1), + FFTGPU); +REGISTER_KERNEL_BUILDER(Name("FFT2D").Device(DEVICE_GPU).Priority(1), + FFTGPU); +REGISTER_KERNEL_BUILDER(Name("IFFT2D").Device(DEVICE_GPU).Priority(1), + FFTGPU); +REGISTER_KERNEL_BUILDER(Name("FFT3D").Device(DEVICE_GPU).Priority(1), + FFTGPU); +REGISTER_KERNEL_BUILDER(Name("IFFT3D").Device(DEVICE_GPU).Priority(1), + FFTGPU); + +REGISTER_KERNEL_BUILDER( + Name("RFFT").Device(DEVICE_GPU).HostMemory("fft_length").Priority(1), + FFTGPU); +REGISTER_KERNEL_BUILDER( + Name("IRFFT").Device(DEVICE_GPU).HostMemory("fft_length").Priority(1), + FFTGPU); +REGISTER_KERNEL_BUILDER( + Name("RFFT2D").Device(DEVICE_GPU).HostMemory("fft_length").Priority(1), + FFTGPU); +REGISTER_KERNEL_BUILDER( + Name("IRFFT2D").Device(DEVICE_GPU).HostMemory("fft_length").Priority(1), + FFTGPU); +REGISTER_KERNEL_BUILDER( + Name("RFFT3D").Device(DEVICE_GPU).HostMemory("fft_length").Priority(1), + FFTGPU); +REGISTER_KERNEL_BUILDER( + Name("IRFFT3D").Device(DEVICE_GPU).HostMemory("fft_length").Priority(1), + FFTGPU); + +// Deprecated kernels. +REGISTER_KERNEL_BUILDER(Name("BatchFFT").Device(DEVICE_GPU).Priority(1), + FFTGPU); +REGISTER_KERNEL_BUILDER(Name("BatchIFFT").Device(DEVICE_GPU).Priority(1), + FFTGPU); +REGISTER_KERNEL_BUILDER(Name("BatchFFT2D").Device(DEVICE_GPU).Priority(1), + FFTGPU); +REGISTER_KERNEL_BUILDER(Name("BatchIFFT2D").Device(DEVICE_GPU).Priority(1), + FFTGPU); +REGISTER_KERNEL_BUILDER(Name("BatchFFT3D").Device(DEVICE_GPU).Priority(1), + FFTGPU); +REGISTER_KERNEL_BUILDER(Name("BatchIFFT3D").Device(DEVICE_GPU).Priority(1), + FFTGPU); +#endif // GOOGLE_CUDA || TENSORFLOW_USE_ROCM + +} // end namespace tensorflow diff --git a/tensorflow_mri/cc/ops/fft_ops.cc b/tensorflow_mri/cc/ops/fft_ops.cc new file mode 100644 index 00000000..175a090d --- /dev/null +++ b/tensorflow_mri/cc/ops/fft_ops.cc @@ -0,0 +1,191 @@ +/* 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/framework/common_shape_fns.h" +#include "tensorflow/core/framework/numeric_op.h" +#include "tensorflow/core/framework/op.h" +#include "tensorflow/core/framework/shape_inference.h" + +namespace tensorflow { + +using shape_inference::DimensionHandle; +using shape_inference::InferenceContext; +using shape_inference::ShapeHandle; + +REGISTER_OP("FFT") + .Input("input: Tcomplex") + .Output("output: Tcomplex") + .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") + .SetShapeFn([](InferenceContext* c) { + return shape_inference::UnchangedShapeWithRankAtLeast(c, 1); + }); + +REGISTER_OP("IFFT") + .Input("input: Tcomplex") + .Output("output: Tcomplex") + .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") + .SetShapeFn([](InferenceContext* c) { + return shape_inference::UnchangedShapeWithRankAtLeast(c, 1); + }); + +REGISTER_OP("FFT2D") + .Input("input: Tcomplex") + .Output("output: Tcomplex") + .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") + .SetShapeFn([](InferenceContext* c) { + return shape_inference::UnchangedShapeWithRankAtLeast(c, 2); + }); + +REGISTER_OP("IFFT2D") + .Input("input: Tcomplex") + .Output("output: Tcomplex") + .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") + .SetShapeFn([](InferenceContext* c) { + return shape_inference::UnchangedShapeWithRankAtLeast(c, 2); + }); + +REGISTER_OP("FFT3D") + .Input("input: Tcomplex") + .Output("output: Tcomplex") + .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") + .SetShapeFn([](InferenceContext* c) { + return shape_inference::UnchangedShapeWithRankAtLeast(c, 3); + }); + +REGISTER_OP("IFFT3D") + .Input("input: Tcomplex") + .Output("output: Tcomplex") + .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") + .SetShapeFn([](InferenceContext* c) { + return shape_inference::UnchangedShapeWithRankAtLeast(c, 3); + }); + +Status RFFTShape(InferenceContext* c, const bool forward, const int rank) { + ShapeHandle out; + TF_RETURN_IF_ERROR(c->WithRankAtLeast(c->input(0), rank, &out)); + + // Check that fft_length has shape [rank]. + ShapeHandle unused_shape; + DimensionHandle unused_dim; + ShapeHandle fft_length_input = c->input(1); + TF_RETURN_IF_ERROR(c->WithRank(fft_length_input, 1, &unused_shape)); + TF_RETURN_IF_ERROR( + c->WithValue(c->Dim(fft_length_input, 0), rank, &unused_dim)); + const Tensor* fft_length_tensor = c->input_tensor(1); + + // If fft_length is unknown at graph creation time, we can't predict the + // output size. + if (fft_length_tensor == nullptr) { + // We can't know the dimension of any of the rank inner dimensions of the + // output without knowing fft_length. + for (int i = 0; i < rank; ++i) { + TF_RETURN_IF_ERROR(c->ReplaceDim(out, -rank + i, c->UnknownDim(), &out)); + } + } else { + auto fft_length_as_vec = fft_length_tensor->vec(); + for (int i = 0; i < rank; ++i) { + // For RFFT, replace the last dimension with fft_length/2 + 1. + auto dim = forward && i == rank - 1 && fft_length_as_vec(i) != 0 + ? fft_length_as_vec(i) / 2 + 1 + : fft_length_as_vec(i); + TF_RETURN_IF_ERROR(c->ReplaceDim(out, -rank + i, c->MakeDim(dim), &out)); + } + } + + c->set_output(0, out); + return OkStatus(); +} + +REGISTER_OP("RFFT") + .Input("input: Treal") + .Input("fft_length: int32") + .Output("output: Tcomplex") + .Attr("Treal: {float32, float64} = DT_FLOAT") + .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") + .SetShapeFn([](InferenceContext* c) { return RFFTShape(c, true, 1); }); + +REGISTER_OP("IRFFT") + .Input("input: Tcomplex") + .Input("fft_length: int32") + .Output("output: Treal") + .Attr("Treal: {float32, float64} = DT_FLOAT") + .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") + .SetShapeFn([](InferenceContext* c) { return RFFTShape(c, false, 1); }); + +REGISTER_OP("RFFT2D") + .Input("input: Treal") + .Input("fft_length: int32") + .Output("output: Tcomplex") + .Attr("Treal: {float32, float64} = DT_FLOAT") + .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") + .SetShapeFn([](InferenceContext* c) { return RFFTShape(c, true, 2); }); + +REGISTER_OP("IRFFT2D") + .Input("input: Tcomplex") + .Input("fft_length: int32") + .Output("output: Treal") + .Attr("Treal: {float32, float64} = DT_FLOAT") + .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") + .SetShapeFn([](InferenceContext* c) { return RFFTShape(c, false, 2); }); + +REGISTER_OP("RFFT3D") + .Input("input: Treal") + .Input("fft_length: int32") + .Output("output: Tcomplex") + .Attr("Treal: {float32, float64} = DT_FLOAT") + .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") + .SetShapeFn([](InferenceContext* c) { return RFFTShape(c, true, 3); }); + +REGISTER_OP("IRFFT3D") + .Input("input: Tcomplex") + .Input("fft_length: int32") + .Output("output: Treal") + .Attr("Treal: {float32, float64} = DT_FLOAT") + .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") + .SetShapeFn([](InferenceContext* c) { return RFFTShape(c, false, 3); }); + +// Deprecated ops: +REGISTER_OP("BatchFFT") + .Input("input: complex64") + .Output("output: complex64") + .SetShapeFn(shape_inference::UnknownShape) + .Deprecated(15, "Use FFT"); +REGISTER_OP("BatchIFFT") + .Input("input: complex64") + .Output("output: complex64") + .SetShapeFn(shape_inference::UnknownShape) + .Deprecated(15, "Use IFFT"); +REGISTER_OP("BatchFFT2D") + .Input("input: complex64") + .Output("output: complex64") + .SetShapeFn(shape_inference::UnknownShape) + .Deprecated(15, "Use FFT2D"); +REGISTER_OP("BatchIFFT2D") + .Input("input: complex64") + .Output("output: complex64") + .SetShapeFn(shape_inference::UnknownShape) + .Deprecated(15, "Use IFFT2D"); +REGISTER_OP("BatchFFT3D") + .Input("input: complex64") + .Output("output: complex64") + .SetShapeFn(shape_inference::UnknownShape) + .Deprecated(15, "Use FFT3D"); +REGISTER_OP("BatchIFFT3D") + .Input("input: complex64") + .Output("output: complex64") + .SetShapeFn(shape_inference::UnknownShape) + .Deprecated(15, "Use IFFT3D"); + +} // namespace tensorflow From d24e41bc3d03b616ab8114d300f51f88d76ef5db Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Tue, 26 Jul 2022 12:38:36 +0000 Subject: [PATCH 002/101] Add FFT --- Makefile | 1 + tensorflow_mri/cc/kernels/fft_kernels.cc | 301 +++-------- tensorflow_mri/cc/ops/fft_ops.cc | 191 ------- tensorflow_mri/cc/third_party/fftw/fftw.h | 212 ++++++++ tensorflow_mri/python/ops/fft_ops.py | 7 + tensorflow_mri/python/ops/fft_ops_test.py | 618 +++++++++++++++++++++- 6 files changed, 903 insertions(+), 427 deletions(-) delete mode 100644 tensorflow_mri/cc/ops/fft_ops.cc create mode 100644 tensorflow_mri/cc/third_party/fftw/fftw.h diff --git a/Makefile b/Makefile index 5b3ff150..6df8d7bf 100644 --- a/Makefile +++ b/Makefile @@ -18,6 +18,7 @@ CXXFLAGS += $(TF_CFLAGS) -fPIC -std=c++14 CXXFLAGS += -I$(ROOT_DIR) LDFLAGS := $(TF_LDFLAGS) +LDFLAGS += -lfftw3 -lfftw3f LDFLAGS += -l:libspiral_waveform.a all: lib wheel diff --git a/tensorflow_mri/cc/kernels/fft_kernels.cc b/tensorflow_mri/cc/kernels/fft_kernels.cc index 31868638..21d0a8b2 100644 --- a/tensorflow_mri/cc/kernels/fft_kernels.cc +++ b/tensorflow_mri/cc/kernels/fft_kernels.cc @@ -35,7 +35,10 @@ limitations under the License. #include "tensorflow/core/platform/stream_executor.h" #endif // GOOGLE_CUDA || TENSORFLOW_USE_ROCM +#include "tensorflow_mri/cc/third_party/fftw/fftw.h" + namespace tensorflow { +namespace mri { class FFTBase : public OpKernel { public: @@ -166,23 +169,10 @@ class FFTCPU : public FFTBase { in.dtype() == DT_COMPLEX128 || out->dtype() == DT_COMPLEX128; if (!IsReal()) { - // Compute the FFT using Eigen. - constexpr auto direction = - Forward ? Eigen::FFT_FORWARD : Eigen::FFT_REVERSE; if (is_complex128) { - DCHECK_EQ(in.dtype(), DT_COMPLEX128); - DCHECK_EQ(out->dtype(), DT_COMPLEX128); - auto input = Tensor(in).flat_inner_dims(); - auto output = out->flat_inner_dims(); - output.device(device) = - input.template fft(axes); + DoComplexFFT(ctx, fft_shape, in, out); } else { - DCHECK_EQ(in.dtype(), DT_COMPLEX64); - DCHECK_EQ(out->dtype(), DT_COMPLEX64); - auto input = Tensor(in).flat_inner_dims(); - auto output = out->flat_inner_dims(); - output.device(device) = - input.template fft(axes); + DoComplexFFT(ctx, fft_shape, in, out); } } else { if (IsForward()) { @@ -209,6 +199,58 @@ class FFTCPU : public FFTBase { } } + template + void DoComplexFFT(OpKernelContext* ctx, uint64* fft_shape, + const Tensor& in, Tensor* out) { + auto device = ctx->eigen_device(); + std::cout << "Using FFTW" << std::endl; + std::cout << "numThreads: " << device.numThreads() << std::endl; + + const bool is_complex128 = + in.dtype() == DT_COMPLEX128 || out->dtype() == DT_COMPLEX128; + + if (is_complex128) { + DCHECK_EQ(in.dtype(), DT_COMPLEX128); + DCHECK_EQ(out->dtype(), DT_COMPLEX128); + } else { + DCHECK_EQ(in.dtype(), DT_COMPLEX64); + DCHECK_EQ(out->dtype(), DT_COMPLEX64); + } + + auto input = Tensor(in).flat_inner_dims, FFTRank + 1>(); + auto output = out->flat_inner_dims, FFTRank + 1>(); + + int dim_sizes[FFTRank]; + int input_distance = 1; + int output_distance = 1; + int num_points = 1; + for (int i = 0; i < FFTRank; ++i) { + dim_sizes[i] = fft_shape[i]; + num_points *= fft_shape[i]; + input_distance *= input.dimension(i + 1); + output_distance *= output.dimension(i + 1); + } + int batch_size = input.dimension(0); + + constexpr auto fft_sign = Forward ? FFTW_FORWARD : FFTW_BACKWARD; + constexpr auto fft_flags = FFTW_ESTIMATE; + + auto fft_plan = fftw::plan_many_dft( + FFTRank, dim_sizes, batch_size, + reinterpret_cast*>(input.data()), + nullptr, 1, input_distance, + reinterpret_cast*>(output.data()), + nullptr, 1, output_distance, + fft_sign, fft_flags); + fftw::execute(fft_plan); + fftw::destroy_plan(fft_plan); + + // FFT normalization. + if (fft_sign == FFTW_BACKWARD) { + output.device(device) = output / output.constant(num_points); + } + } + template void DoRealForwardFFT(OpKernelContext* ctx, uint64* fft_shape, const Tensor& in, Tensor* out) { @@ -323,30 +365,19 @@ class FFTCPU : public FFTBase { } }; -REGISTER_KERNEL_BUILDER(Name("FFT").Device(DEVICE_CPU), FFTCPU); -REGISTER_KERNEL_BUILDER(Name("IFFT").Device(DEVICE_CPU), +REGISTER_KERNEL_BUILDER(Name("FFT").Device(DEVICE_CPU).Priority(1), + FFTCPU); +REGISTER_KERNEL_BUILDER(Name("IFFT").Device(DEVICE_CPU).Priority(1), FFTCPU); -REGISTER_KERNEL_BUILDER(Name("FFT2D").Device(DEVICE_CPU), +REGISTER_KERNEL_BUILDER(Name("FFT2D").Device(DEVICE_CPU).Priority(1), FFTCPU); -REGISTER_KERNEL_BUILDER(Name("IFFT2D").Device(DEVICE_CPU), +REGISTER_KERNEL_BUILDER(Name("IFFT2D").Device(DEVICE_CPU).Priority(1), FFTCPU); -REGISTER_KERNEL_BUILDER(Name("FFT3D").Device(DEVICE_CPU), +REGISTER_KERNEL_BUILDER(Name("FFT3D").Device(DEVICE_CPU).Priority(1), FFTCPU); -REGISTER_KERNEL_BUILDER(Name("IFFT3D").Device(DEVICE_CPU), +REGISTER_KERNEL_BUILDER(Name("IFFT3D").Device(DEVICE_CPU).Priority(1), FFTCPU); -REGISTER_KERNEL_BUILDER(Name("RFFT").Device(DEVICE_CPU), FFTCPU); -REGISTER_KERNEL_BUILDER(Name("IRFFT").Device(DEVICE_CPU), - FFTCPU); -REGISTER_KERNEL_BUILDER(Name("RFFT2D").Device(DEVICE_CPU), - FFTCPU); -REGISTER_KERNEL_BUILDER(Name("IRFFT2D").Device(DEVICE_CPU), - FFTCPU); -REGISTER_KERNEL_BUILDER(Name("RFFT3D").Device(DEVICE_CPU), - FFTCPU); -REGISTER_KERNEL_BUILDER(Name("IRFFT3D").Device(DEVICE_CPU), - FFTCPU); - #if (defined(GOOGLE_CUDA) && GOOGLE_CUDA) || \ (defined(TENSORFLOW_USE_ROCM) && TENSORFLOW_USE_ROCM) @@ -427,208 +458,8 @@ int64_t GetCufftWorkspaceLimit(const string& envvar_in_mb, return default_value_in_bytes; } -class FFTGPUBase : public FFTBase { - public: - using FFTBase::FFTBase; - - protected: - static int64_t CufftScratchSize; - void DoFFT(OpKernelContext* ctx, const Tensor& in, uint64* fft_shape, - Tensor* out) override { - auto* stream = ctx->op_device_context()->stream(); - OP_REQUIRES(ctx, stream, errors::Internal("No GPU stream available.")); - - const TensorShape& input_shape = in.shape(); - const TensorShape& output_shape = out->shape(); - - const int fft_rank = Rank(); - int batch_size = 1; - for (int i = 0; i < input_shape.dims() - fft_rank; ++i) { - batch_size *= input_shape.dim_size(i); - } - uint64 input_embed[3]; - const uint64 input_stride = 1; - uint64 input_distance = 1; - uint64 output_embed[3]; - const uint64 output_stride = 1; - uint64 output_distance = 1; - - for (int i = 0; i < fft_rank; ++i) { - auto dim_offset = input_shape.dims() - fft_rank + i; - input_embed[i] = input_shape.dim_size(dim_offset); - input_distance *= input_shape.dim_size(dim_offset); - output_embed[i] = output_shape.dim_size(dim_offset); - output_distance *= output_shape.dim_size(dim_offset); - } - - constexpr bool kInPlaceFft = false; - const bool is_complex128 = - in.dtype() == DT_COMPLEX128 || out->dtype() == DT_COMPLEX128; - - const auto kFftType = - IsReal() - ? (IsForward() - ? (is_complex128 ? se::fft::Type::kD2Z : se::fft::Type::kR2C) - : (is_complex128 ? se::fft::Type::kZ2D - : se::fft::Type::kC2R)) - : (IsForward() ? (is_complex128 ? se::fft::Type::kZ2ZForward - : se::fft::Type::kC2CForward) - : (is_complex128 ? se::fft::Type::kZ2ZInverse - : se::fft::Type::kC2CInverse)); - - CufftScratchAllocator scratch_allocator(CufftScratchSize, ctx); - auto plan = - stream->parent()->AsFft()->CreateBatchedPlanWithScratchAllocator( - stream, fft_rank, fft_shape, input_embed, input_stride, - input_distance, output_embed, output_stride, output_distance, - kFftType, kInPlaceFft, batch_size, &scratch_allocator); - - if (IsReal()) { - if (IsForward()) { - if (is_complex128) { - DCHECK_EQ(in.dtype(), DT_DOUBLE); - DCHECK_EQ(out->dtype(), DT_COMPLEX128); - DoFFTInternal(ctx, stream, plan.get(), kFftType, - output_distance, in, out); - } else { - DCHECK_EQ(in.dtype(), DT_FLOAT); - DCHECK_EQ(out->dtype(), DT_COMPLEX64); - DoFFTInternal(ctx, stream, plan.get(), kFftType, - output_distance, in, out); - } - } else { - if (is_complex128) { - DCHECK_EQ(in.dtype(), DT_COMPLEX128); - DCHECK_EQ(out->dtype(), DT_DOUBLE); - DoFFTInternal(ctx, stream, plan.get(), kFftType, - output_distance, in, out); - } else { - DCHECK_EQ(in.dtype(), DT_COMPLEX64); - DCHECK_EQ(out->dtype(), DT_FLOAT); - DoFFTInternal(ctx, stream, plan.get(), kFftType, - output_distance, in, out); - } - } - } else { - if (is_complex128) { - DCHECK_EQ(in.dtype(), DT_COMPLEX128); - DCHECK_EQ(out->dtype(), DT_COMPLEX128); - DoFFTInternal(ctx, stream, plan.get(), kFftType, - output_distance, in, out); - } else { - DCHECK_EQ(in.dtype(), DT_COMPLEX64); - DCHECK_EQ(out->dtype(), DT_COMPLEX64); - DoFFTInternal(ctx, stream, plan.get(), kFftType, - output_distance, in, out); - } - } - } - - private: - template - struct RealTypeFromComplexType { - typedef T RealT; - }; - - template - struct RealTypeFromComplexType> { - typedef T RealT; - }; - - template - void DoFFTInternal(OpKernelContext* ctx, se::Stream* stream, - se::fft::Plan* plan, const se::fft::Type fft_type, - const uint64 output_distance, const Tensor& in, - Tensor* out) { - const TensorShape& input_shape = in.shape(); - const TensorShape& output_shape = out->shape(); - auto src = - AsDeviceMemory(in.flat().data(), input_shape.num_elements()); - auto dst = AsDeviceMemory(out->flat().data(), - output_shape.num_elements()); - OP_REQUIRES( - ctx, stream->ThenFft(plan, src, &dst).ok(), - errors::Internal("fft failed : type=", static_cast(fft_type), - " in.shape=", input_shape.DebugString())); - if (!IsForward()) { - typedef typename RealTypeFromComplexType::RealT RealT; - RealT alpha = 1.0 / output_distance; - OP_REQUIRES( - ctx, - stream->ThenBlasScal(output_shape.num_elements(), alpha, &dst, 1) - .ok(), - errors::Internal("BlasScal failed : in.shape=", - input_shape.DebugString())); - } - } -}; - -int64_t FFTGPUBase::CufftScratchSize = GetCufftWorkspaceLimit( - // default value is in bytes despite the name of the environment variable - "TF_CUFFT_WORKSPACE_LIMIT_IN_MB", 1LL << 32 // 4GB -); - -template -class FFTGPU : public FFTGPUBase { - public: - static_assert(FFTRank >= 1 && FFTRank <= 3, - "Only 1D, 2D and 3D FFTs supported."); - explicit FFTGPU(OpKernelConstruction* ctx) : FFTGPUBase(ctx) {} - - protected: - int Rank() const override { return FFTRank; } - bool IsForward() const override { return Forward; } - bool IsReal() const override { return _Real; } -}; -// Register GPU kernels with priority 1 so that if a custom FFT CPU kernel is -// registered with priority 1 (to override the default Eigen CPU kernel), the -// CPU kernel does not outrank the GPU kernel. -REGISTER_KERNEL_BUILDER(Name("FFT").Device(DEVICE_GPU).Priority(1), - FFTGPU); -REGISTER_KERNEL_BUILDER(Name("IFFT").Device(DEVICE_GPU).Priority(1), - FFTGPU); -REGISTER_KERNEL_BUILDER(Name("FFT2D").Device(DEVICE_GPU).Priority(1), - FFTGPU); -REGISTER_KERNEL_BUILDER(Name("IFFT2D").Device(DEVICE_GPU).Priority(1), - FFTGPU); -REGISTER_KERNEL_BUILDER(Name("FFT3D").Device(DEVICE_GPU).Priority(1), - FFTGPU); -REGISTER_KERNEL_BUILDER(Name("IFFT3D").Device(DEVICE_GPU).Priority(1), - FFTGPU); - -REGISTER_KERNEL_BUILDER( - Name("RFFT").Device(DEVICE_GPU).HostMemory("fft_length").Priority(1), - FFTGPU); -REGISTER_KERNEL_BUILDER( - Name("IRFFT").Device(DEVICE_GPU).HostMemory("fft_length").Priority(1), - FFTGPU); -REGISTER_KERNEL_BUILDER( - Name("RFFT2D").Device(DEVICE_GPU).HostMemory("fft_length").Priority(1), - FFTGPU); -REGISTER_KERNEL_BUILDER( - Name("IRFFT2D").Device(DEVICE_GPU).HostMemory("fft_length").Priority(1), - FFTGPU); -REGISTER_KERNEL_BUILDER( - Name("RFFT3D").Device(DEVICE_GPU).HostMemory("fft_length").Priority(1), - FFTGPU); -REGISTER_KERNEL_BUILDER( - Name("IRFFT3D").Device(DEVICE_GPU).HostMemory("fft_length").Priority(1), - FFTGPU); - -// Deprecated kernels. -REGISTER_KERNEL_BUILDER(Name("BatchFFT").Device(DEVICE_GPU).Priority(1), - FFTGPU); -REGISTER_KERNEL_BUILDER(Name("BatchIFFT").Device(DEVICE_GPU).Priority(1), - FFTGPU); -REGISTER_KERNEL_BUILDER(Name("BatchFFT2D").Device(DEVICE_GPU).Priority(1), - FFTGPU); -REGISTER_KERNEL_BUILDER(Name("BatchIFFT2D").Device(DEVICE_GPU).Priority(1), - FFTGPU); -REGISTER_KERNEL_BUILDER(Name("BatchFFT3D").Device(DEVICE_GPU).Priority(1), - FFTGPU); -REGISTER_KERNEL_BUILDER(Name("BatchIFFT3D").Device(DEVICE_GPU).Priority(1), - FFTGPU); #endif // GOOGLE_CUDA || TENSORFLOW_USE_ROCM -} // end namespace tensorflow +} // namespace mri +} // namespace tensorflow diff --git a/tensorflow_mri/cc/ops/fft_ops.cc b/tensorflow_mri/cc/ops/fft_ops.cc deleted file mode 100644 index 175a090d..00000000 --- a/tensorflow_mri/cc/ops/fft_ops.cc +++ /dev/null @@ -1,191 +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/framework/common_shape_fns.h" -#include "tensorflow/core/framework/numeric_op.h" -#include "tensorflow/core/framework/op.h" -#include "tensorflow/core/framework/shape_inference.h" - -namespace tensorflow { - -using shape_inference::DimensionHandle; -using shape_inference::InferenceContext; -using shape_inference::ShapeHandle; - -REGISTER_OP("FFT") - .Input("input: Tcomplex") - .Output("output: Tcomplex") - .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") - .SetShapeFn([](InferenceContext* c) { - return shape_inference::UnchangedShapeWithRankAtLeast(c, 1); - }); - -REGISTER_OP("IFFT") - .Input("input: Tcomplex") - .Output("output: Tcomplex") - .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") - .SetShapeFn([](InferenceContext* c) { - return shape_inference::UnchangedShapeWithRankAtLeast(c, 1); - }); - -REGISTER_OP("FFT2D") - .Input("input: Tcomplex") - .Output("output: Tcomplex") - .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") - .SetShapeFn([](InferenceContext* c) { - return shape_inference::UnchangedShapeWithRankAtLeast(c, 2); - }); - -REGISTER_OP("IFFT2D") - .Input("input: Tcomplex") - .Output("output: Tcomplex") - .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") - .SetShapeFn([](InferenceContext* c) { - return shape_inference::UnchangedShapeWithRankAtLeast(c, 2); - }); - -REGISTER_OP("FFT3D") - .Input("input: Tcomplex") - .Output("output: Tcomplex") - .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") - .SetShapeFn([](InferenceContext* c) { - return shape_inference::UnchangedShapeWithRankAtLeast(c, 3); - }); - -REGISTER_OP("IFFT3D") - .Input("input: Tcomplex") - .Output("output: Tcomplex") - .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") - .SetShapeFn([](InferenceContext* c) { - return shape_inference::UnchangedShapeWithRankAtLeast(c, 3); - }); - -Status RFFTShape(InferenceContext* c, const bool forward, const int rank) { - ShapeHandle out; - TF_RETURN_IF_ERROR(c->WithRankAtLeast(c->input(0), rank, &out)); - - // Check that fft_length has shape [rank]. - ShapeHandle unused_shape; - DimensionHandle unused_dim; - ShapeHandle fft_length_input = c->input(1); - TF_RETURN_IF_ERROR(c->WithRank(fft_length_input, 1, &unused_shape)); - TF_RETURN_IF_ERROR( - c->WithValue(c->Dim(fft_length_input, 0), rank, &unused_dim)); - const Tensor* fft_length_tensor = c->input_tensor(1); - - // If fft_length is unknown at graph creation time, we can't predict the - // output size. - if (fft_length_tensor == nullptr) { - // We can't know the dimension of any of the rank inner dimensions of the - // output without knowing fft_length. - for (int i = 0; i < rank; ++i) { - TF_RETURN_IF_ERROR(c->ReplaceDim(out, -rank + i, c->UnknownDim(), &out)); - } - } else { - auto fft_length_as_vec = fft_length_tensor->vec(); - for (int i = 0; i < rank; ++i) { - // For RFFT, replace the last dimension with fft_length/2 + 1. - auto dim = forward && i == rank - 1 && fft_length_as_vec(i) != 0 - ? fft_length_as_vec(i) / 2 + 1 - : fft_length_as_vec(i); - TF_RETURN_IF_ERROR(c->ReplaceDim(out, -rank + i, c->MakeDim(dim), &out)); - } - } - - c->set_output(0, out); - return OkStatus(); -} - -REGISTER_OP("RFFT") - .Input("input: Treal") - .Input("fft_length: int32") - .Output("output: Tcomplex") - .Attr("Treal: {float32, float64} = DT_FLOAT") - .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") - .SetShapeFn([](InferenceContext* c) { return RFFTShape(c, true, 1); }); - -REGISTER_OP("IRFFT") - .Input("input: Tcomplex") - .Input("fft_length: int32") - .Output("output: Treal") - .Attr("Treal: {float32, float64} = DT_FLOAT") - .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") - .SetShapeFn([](InferenceContext* c) { return RFFTShape(c, false, 1); }); - -REGISTER_OP("RFFT2D") - .Input("input: Treal") - .Input("fft_length: int32") - .Output("output: Tcomplex") - .Attr("Treal: {float32, float64} = DT_FLOAT") - .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") - .SetShapeFn([](InferenceContext* c) { return RFFTShape(c, true, 2); }); - -REGISTER_OP("IRFFT2D") - .Input("input: Tcomplex") - .Input("fft_length: int32") - .Output("output: Treal") - .Attr("Treal: {float32, float64} = DT_FLOAT") - .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") - .SetShapeFn([](InferenceContext* c) { return RFFTShape(c, false, 2); }); - -REGISTER_OP("RFFT3D") - .Input("input: Treal") - .Input("fft_length: int32") - .Output("output: Tcomplex") - .Attr("Treal: {float32, float64} = DT_FLOAT") - .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") - .SetShapeFn([](InferenceContext* c) { return RFFTShape(c, true, 3); }); - -REGISTER_OP("IRFFT3D") - .Input("input: Tcomplex") - .Input("fft_length: int32") - .Output("output: Treal") - .Attr("Treal: {float32, float64} = DT_FLOAT") - .Attr("Tcomplex: {complex64, complex128} = DT_COMPLEX64") - .SetShapeFn([](InferenceContext* c) { return RFFTShape(c, false, 3); }); - -// Deprecated ops: -REGISTER_OP("BatchFFT") - .Input("input: complex64") - .Output("output: complex64") - .SetShapeFn(shape_inference::UnknownShape) - .Deprecated(15, "Use FFT"); -REGISTER_OP("BatchIFFT") - .Input("input: complex64") - .Output("output: complex64") - .SetShapeFn(shape_inference::UnknownShape) - .Deprecated(15, "Use IFFT"); -REGISTER_OP("BatchFFT2D") - .Input("input: complex64") - .Output("output: complex64") - .SetShapeFn(shape_inference::UnknownShape) - .Deprecated(15, "Use FFT2D"); -REGISTER_OP("BatchIFFT2D") - .Input("input: complex64") - .Output("output: complex64") - .SetShapeFn(shape_inference::UnknownShape) - .Deprecated(15, "Use IFFT2D"); -REGISTER_OP("BatchFFT3D") - .Input("input: complex64") - .Output("output: complex64") - .SetShapeFn(shape_inference::UnknownShape) - .Deprecated(15, "Use FFT3D"); -REGISTER_OP("BatchIFFT3D") - .Input("input: complex64") - .Output("output: complex64") - .SetShapeFn(shape_inference::UnknownShape) - .Deprecated(15, "Use IFFT3D"); - -} // namespace tensorflow diff --git a/tensorflow_mri/cc/third_party/fftw/fftw.h b/tensorflow_mri/cc/third_party/fftw/fftw.h new file mode 100644 index 00000000..cc6ea92c --- /dev/null +++ b/tensorflow_mri/cc/third_party/fftw/fftw.h @@ -0,0 +1,212 @@ +/* Copyright 2022 University College London. 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 TENSORFLOW_MRI_CC_THIRD_PARTY_FFTW_H_ +#define TENSORFLOW_MRI_CC_THIRD_PARTY_FFTW_H_ + +#include + + +namespace tensorflow { +namespace mri { +namespace fftw { + +template +inline int init_threads(); + +template<> +inline int init_threads() { + return fftwf_init_threads(); +} + +template<> +inline int init_threads() { + return fftw_init_threads(); +} + +template +inline void cleanup_threads(); + +template<> +inline void cleanup_threads() { + return fftwf_cleanup_threads(); +} + +template<> +inline void cleanup_threads() { + return fftw_cleanup_threads(); +} + +template +inline void plan_with_nthreads(int nthreads); + +template<> +inline void plan_with_nthreads(int nthreads) { + fftwf_plan_with_nthreads(nthreads); +} + +template<> +inline void plan_with_nthreads(int nthreads) { + fftw_plan_with_nthreads(nthreads); +} + +template +inline void make_planner_thread_safe(); + +template<> +inline void make_planner_thread_safe() { + fftwf_make_planner_thread_safe(); +} + +template<> +inline void make_planner_thread_safe() { + fftw_make_planner_thread_safe(); +} + +template +struct ComplexType; + +template<> +struct ComplexType { + using Type = fftwf_complex; +}; + +template<> +struct ComplexType { + using Type = fftw_complex; +}; + +template +using complex = typename ComplexType::Type; + +template +inline FloatType* alloc_real(size_t n); + +template<> +inline float* alloc_real(size_t n) { + return fftwf_alloc_real(n); +} + +template<> +inline double* alloc_real(size_t n) { + return fftw_alloc_real(n); +} + +template +inline typename ComplexType::Type* alloc_complex(size_t n); + +template<> +inline typename ComplexType::Type* alloc_complex(size_t n) { + return fftwf_alloc_complex(n); +} + +template<> +inline typename ComplexType::Type* alloc_complex(size_t n) { + return fftw_alloc_complex(n); +} + +template +inline void free(void* p); + +template<> +inline void free(void* p) { + fftwf_free(p); +} + +template<> +inline void free(void* p) { + fftw_free(p); +} + +template +struct PlanType; + +template<> +struct PlanType { + using Type = fftwf_plan; +}; + +template<> +struct PlanType { + using Type = fftw_plan; +}; + +template +inline typename PlanType::Type plan_many_dft( + int rank, const int *n, int howmany, + typename ComplexType::Type *in, const int *inembed, + int istride, int idist, + typename ComplexType::Type *out, const int *onembed, + int ostride, int odist, + int sign, unsigned flags); + +template<> +inline typename PlanType::Type plan_many_dft( + int rank, const int *n, int howmany, + ComplexType::Type *in, const int *inembed, + int istride, int idist, + ComplexType::Type *out, const int *onembed, + int ostride, int odist, + int sign, unsigned flags) { + return fftwf_plan_many_dft( + rank, n, howmany, + in, inembed, istride, idist, + out, onembed, ostride, odist, + sign, flags); +} + +template<> +inline typename PlanType::Type plan_many_dft( + int rank, const int *n, int howmany, + typename ComplexType::Type *in, const int *inembed, + int istride, int idist, + typename ComplexType::Type *out, const int *onembed, + int ostride, int odist, + int sign, unsigned flags) { + return fftw_plan_many_dft( + rank, n, howmany, + in, inembed, istride, idist, + out, onembed, ostride, odist, + sign, flags); +} + +template +inline void execute(typename PlanType::Type& plan); // NOLINT + +template<> +inline void execute(typename PlanType::Type& plan) { // NOLINT + fftwf_execute(plan); +} + +template<> +inline void execute(typename PlanType::Type& plan) { // NOLINT + fftw_execute(plan); +} + +template +inline void destroy_plan(typename PlanType::Type& plan); // NOLINT + +template<> +inline void destroy_plan(typename PlanType::Type& plan) { // NOLINT + fftwf_destroy_plan(plan); +} + +template<> +inline void destroy_plan(typename PlanType::Type& plan) { // NOLINT + fftw_destroy_plan(plan); +} + +} // namespace fftw +} // namespace mri +} // namespace tensorflow + +#endif // TENSORFLOW_MRI_CC_THIRD_PARTY_FFTW_H_ diff --git a/tensorflow_mri/python/ops/fft_ops.py b/tensorflow_mri/python/ops/fft_ops.py index a1ce9371..61bec979 100644 --- a/tensorflow_mri/python/ops/fft_ops.py +++ b/tensorflow_mri/python/ops/fft_ops.py @@ -20,6 +20,13 @@ from tensorflow_mri.python.ops import array_ops from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util +from tensorflow_mri.python.util import sys_util + + +if sys_util.is_op_library_enabled(): + # Load library in order to register the FFT kernels. + _mri_ops = tf.load_op_library( + tf.compat.v1.resource_loader.get_path_to_datafile('_mri_ops.so')) @api_util.export("signal.fft") diff --git a/tensorflow_mri/python/ops/fft_ops_test.py b/tensorflow_mri/python/ops/fft_ops_test.py index 5e4e7ea2..45e7b020 100644 --- a/tensorflow_mri/python/ops/fft_ops_test.py +++ b/tensorflow_mri/python/ops/fft_ops_test.py @@ -12,10 +12,26 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== + +# Copyright 2015 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. +# ============================================================================== """Tests for module `fft_ops`.""" import distutils import itertools +import unittest import numpy as np import tensorflow as tf @@ -24,7 +40,607 @@ from tensorflow_mri.python.util import test_util -class FFTOpsTest(test_util.TestCase): +from absl.testing import parameterized + +from tensorflow.core.protobuf import config_pb2 +from tensorflow.python.eager import context +from tensorflow.python.framework import dtypes +from tensorflow.python.framework import errors +# from tensorflow.python.framework import test_util +from tensorflow.python.ops import array_ops +from tensorflow.python.ops import gen_spectral_ops +from tensorflow.python.ops import gradient_checker_v2 +from tensorflow.python.ops import math_ops +from tensorflow.python.platform import test + +VALID_FFT_RANKS = (1, 2, 3) + + +class BaseFFTOpsTest(test.TestCase): + + def _compare(self, x, rank, fft_length=None, use_placeholder=False, + rtol=1e-4, atol=1e-4): + self._compare_forward(x, rank, fft_length, use_placeholder, rtol, atol) + self._compare_backward(x, rank, fft_length, use_placeholder, rtol, atol) + + def _compare_forward(self, x, rank, fft_length=None, use_placeholder=False, + rtol=1e-4, atol=1e-4): + x_np = self._np_fft(x, rank, fft_length) + if use_placeholder: + x_ph = array_ops.placeholder(dtype=dtypes.as_dtype(x.dtype)) + x_tf = self._tf_fft(x_ph, rank, fft_length, feed_dict={x_ph: x}) + else: + x_tf = self._tf_fft(x, rank, fft_length) + + self.assertAllClose(x_np, x_tf, rtol=rtol, atol=atol) + + def _compare_backward(self, x, rank, fft_length=None, use_placeholder=False, + rtol=1e-4, atol=1e-4): + x_np = self._np_ifft(x, rank, fft_length) + if use_placeholder: + x_ph = array_ops.placeholder(dtype=dtypes.as_dtype(x.dtype)) + x_tf = self._tf_ifft(x_ph, rank, fft_length, feed_dict={x_ph: x}) + else: + x_tf = self._tf_ifft(x, rank, fft_length) + + self.assertAllClose(x_np, x_tf, rtol=rtol, atol=atol) + + def _check_memory_fail(self, x, rank): + config = config_pb2.ConfigProto() + config.gpu_options.per_process_gpu_memory_fraction = 1e-2 + with self.cached_session(config=config, force_gpu=True): + self._tf_fft(x, rank, fft_length=None) + + def _check_grad_complex(self, func, x, y, result_is_complex=True, + rtol=1e-2, atol=1e-2): + with self.cached_session(): + + def f(inx, iny): + inx.set_shape(x.shape) + iny.set_shape(y.shape) + # func is a forward or inverse, real or complex, batched or unbatched + # FFT function with a complex input. + z = func(math_ops.complex(inx, iny)) + # loss = sum(|z|^2) + loss = math_ops.reduce_sum(math_ops.real(z * math_ops.conj(z))) + return loss + + ((x_jacob_t, y_jacob_t), (x_jacob_n, y_jacob_n)) = ( + gradient_checker_v2.compute_gradient(f, [x, y], delta=1e-2)) + + self.assertAllClose(x_jacob_t, x_jacob_n, rtol=rtol, atol=atol) + self.assertAllClose(y_jacob_t, y_jacob_n, rtol=rtol, atol=atol) + + def _check_grad_real(self, func, x, rtol=1e-2, atol=1e-2): + def f(inx): + inx.set_shape(x.shape) + # func is a forward RFFT function (batched or unbatched). + z = func(inx) + # loss = sum(|z|^2) + loss = math_ops.reduce_sum(math_ops.real(z * math_ops.conj(z))) + return loss + + (x_jacob_t,), (x_jacob_n,) = gradient_checker_v2.compute_gradient( + f, [x], delta=1e-2) + self.assertAllClose(x_jacob_t, x_jacob_n, rtol=rtol, atol=atol) + + +@test_util.run_all_in_graph_and_eager_modes +class FFTNTest(BaseFFTOpsTest, parameterized.TestCase): + + def _tf_fft(self, x, rank, fft_length=None, feed_dict=None): + # fft_length unused for complex FFTs. + with self.cached_session() as sess: + return sess.run(self._tf_fft_for_rank(rank)(x), feed_dict=feed_dict) + + def _tf_ifft(self, x, rank, fft_length=None, feed_dict=None): + # fft_length unused for complex FFTs. + with self.cached_session() as sess: + return sess.run(self._tf_ifft_for_rank(rank)(x), feed_dict=feed_dict) + + def _np_fft(self, x, rank, fft_length=None): + if rank == 1: + return np.fft.fft2(x, s=fft_length, axes=(-1,)) + elif rank == 2: + return np.fft.fft2(x, s=fft_length, axes=(-2, -1)) + elif rank == 3: + return np.fft.fft2(x, s=fft_length, axes=(-3, -2, -1)) + else: + raise ValueError("invalid rank") + + def _np_ifft(self, x, rank, fft_length=None): + if rank == 1: + return np.fft.ifft2(x, s=fft_length, axes=(-1,)) + elif rank == 2: + return np.fft.ifft2(x, s=fft_length, axes=(-2, -1)) + elif rank == 3: + return np.fft.ifft2(x, s=fft_length, axes=(-3, -2, -1)) + else: + raise ValueError("invalid rank") + + def _tf_fft_for_rank(self, rank): + if rank == 1: + return tf.signal.fft + elif rank == 2: + return tf.signal.fft2d + elif rank == 3: + return tf.signal.fft3d + else: + raise ValueError("invalid rank") + + def _tf_ifft_for_rank(self, rank): + if rank == 1: + return tf.signal.ifft + elif rank == 2: + return tf.signal.ifft2d + elif rank == 3: + return tf.signal.ifft3d + else: + raise ValueError("invalid rank") + + @parameterized.parameters(itertools.product( + VALID_FFT_RANKS, range(3), (np.complex64, np.complex128))) + def test_empty(self, rank, extra_dims, np_type): + dims = rank + extra_dims + x = np.zeros((0,) * dims).astype(np_type) + self.assertEqual(x.shape, self._tf_fft(x, rank).shape) + self.assertEqual(x.shape, self._tf_ifft(x, rank).shape) + + @parameterized.parameters( + itertools.product(VALID_FFT_RANKS, range(3), + (np.complex64, np.complex128))) + def test_basic(self, rank, extra_dims, np_type): + dims = rank + extra_dims + tol = 1e-4 if np_type == np.complex64 else 1e-8 + self._compare( + np.mod(np.arange(np.power(4, dims)), 10).reshape( + (4,) * dims).astype(np_type), rank, rtol=tol, atol=tol) + + @parameterized.parameters(itertools.product( + (1,), range(3), (np.complex64, np.complex128))) + def test_large_batch(self, rank, extra_dims, np_type): + dims = rank + extra_dims + tol = 1e-4 if np_type == np.complex64 else 5e-5 + self._compare( + np.mod(np.arange(np.power(128, dims)), 10).reshape( + (128,) * dims).astype(np_type), rank, rtol=tol, atol=tol) + + # TODO(yangzihao): Disable before we can figure out a way to + # properly test memory fail for large batch fft. + # def test_large_batch_memory_fail(self): + # if test.is_gpu_available(cuda_only=True): + # rank = 1 + # for dims in range(rank, rank + 3): + # self._check_memory_fail( + # np.mod(np.arange(np.power(128, dims)), 64).reshape( + # (128,) * dims).astype(np.complex64), rank) + + @parameterized.parameters(itertools.product( + VALID_FFT_RANKS, range(3), (np.complex64, np.complex128))) + def test_placeholder(self, rank, extra_dims, np_type): + if context.executing_eagerly(): + return + tol = 1e-4 if np_type == np.complex64 else 1e-8 + dims = rank + extra_dims + self._compare( + np.mod(np.arange(np.power(4, dims)), 10).reshape( + (4,) * dims).astype(np_type), + rank, use_placeholder=True, rtol=tol, atol=tol) + + @parameterized.parameters(itertools.product( + VALID_FFT_RANKS, range(3), (np.complex64, np.complex128))) + def test_random(self, rank, extra_dims, np_type): + tol = 1e-4 if np_type == np.complex64 else 5e-6 + dims = rank + extra_dims + def gen(shape): + n = np.prod(shape) + re = np.random.uniform(size=n) + im = np.random.uniform(size=n) + return (re + im * 1j).reshape(shape) + + self._compare(gen((4,) * dims).astype(np_type), rank, + rtol=tol, atol=tol) + + @parameterized.parameters(itertools.product( + VALID_FFT_RANKS, + # Check a variety of sizes (power-of-2, odd, etc.) + [128, 256, 512, 1024, 127, 255, 511, 1023], + (np.complex64, np.complex128))) + def test_random_1d(self, rank, dim, np_type): + has_gpu = test.is_gpu_available(cuda_only=True) + tol = {(np.complex64, True): 1e-4, + (np.complex64, False): 1e-2, + (np.complex128, True): 1e-4, + (np.complex128, False): 1e-2}[(np_type, has_gpu)] + def gen(shape): + n = np.prod(shape) + re = np.random.uniform(size=n) + im = np.random.uniform(size=n) + return (re + im * 1j).reshape(shape) + + self._compare(gen((dim,)).astype(np_type), 1, rtol=tol, atol=tol) + + def test_error(self): + # TODO(rjryan): Fix this test under Eager. + if context.executing_eagerly(): + return + for rank in VALID_FFT_RANKS: + for dims in range(0, rank): + x = np.zeros((1,) * dims).astype(np.complex64) + with self.assertRaisesWithPredicateMatch( + ValueError, "Shape must be .*rank {}.*".format(rank)): + self._tf_fft(x, rank) + with self.assertRaisesWithPredicateMatch( + ValueError, "Shape must be .*rank {}.*".format(rank)): + self._tf_ifft(x, rank) + + @parameterized.parameters(itertools.product( + VALID_FFT_RANKS, range(2), (np.float32, np.float64))) + def test_grad_simple(self, rank, extra_dims, np_type): + tol = 1e-4 if np_type == np.float32 else 1e-10 + dims = rank + extra_dims + re = np.ones(shape=(4,) * dims, dtype=np_type) / 10.0 + im = np.zeros(shape=(4,) * dims, dtype=np_type) + self._check_grad_complex(self._tf_fft_for_rank(rank), re, im, + rtol=tol, atol=tol) + self._check_grad_complex(self._tf_ifft_for_rank(rank), re, im, + rtol=tol, atol=tol) + + @unittest.skip("16.86% flaky") + @parameterized.parameters(itertools.product( + VALID_FFT_RANKS, range(2), (np.float32, np.float64))) + def test_grad_random(self, rank, extra_dims, np_type): + dims = rank + extra_dims + tol = 1e-2 if np_type == np.float32 else 1e-10 + re = np.random.rand(*((3,) * dims)).astype(np_type) * 2 - 1 + im = np.random.rand(*((3,) * dims)).astype(np_type) * 2 - 1 + self._check_grad_complex(self._tf_fft_for_rank(rank), re, im, + rtol=tol, atol=tol) + self._check_grad_complex(self._tf_ifft_for_rank(rank), re, im, + rtol=tol, atol=tol) + + +@test_util.run_all_in_graph_and_eager_modes +# @test_util.disable_xla("b/155276727") +class RFFTOpsTest(BaseFFTOpsTest, parameterized.TestCase): + + def _tf_fft(self, x, rank, fft_length=None, feed_dict=None): + with self.cached_session() as sess: + return sess.run( + self._tf_fft_for_rank(rank)(x, fft_length), feed_dict=feed_dict) + + def _tf_ifft(self, x, rank, fft_length=None, feed_dict=None): + with self.cached_session() as sess: + return sess.run( + self._tf_ifft_for_rank(rank)(x, fft_length), feed_dict=feed_dict) + + def _np_fft(self, x, rank, fft_length=None): + if rank == 1: + return np.fft.rfft2(x, s=fft_length, axes=(-1,)) + elif rank == 2: + return np.fft.rfft2(x, s=fft_length, axes=(-2, -1)) + elif rank == 3: + return np.fft.rfft2(x, s=fft_length, axes=(-3, -2, -1)) + else: + raise ValueError("invalid rank") + + def _np_ifft(self, x, rank, fft_length=None): + if rank == 1: + return np.fft.irfft2(x, s=fft_length, axes=(-1,)) + elif rank == 2: + return np.fft.irfft2(x, s=fft_length, axes=(-2, -1)) + elif rank == 3: + return np.fft.irfft2(x, s=fft_length, axes=(-3, -2, -1)) + else: + raise ValueError("invalid rank") + + def _tf_fft_for_rank(self, rank): + if rank == 1: + return tf.signal.rfft + elif rank == 2: + return tf.signal.rfft2d + elif rank == 3: + return tf.signal.rfft3d + else: + raise ValueError("invalid rank") + + def _tf_ifft_for_rank(self, rank): + if rank == 1: + return tf.signal.irfft + elif rank == 2: + return tf.signal.irfft2d + elif rank == 3: + return tf.signal.irfft3d + else: + raise ValueError("invalid rank") + + # rocFFT requires/assumes that the input to the irfft transform + # is of the form that is a valid output from the rfft transform + # (i.e. it cannot be a set of random numbers) + # So for ROCm, call rfft and use its output as the input for testing irfft + def _generate_valid_irfft_input(self, c2r, np_ctype, r2c, np_rtype, rank, + fft_length): + if test.is_built_with_rocm(): + return self._np_fft(r2c.astype(np_rtype), rank, fft_length) + else: + return c2r.astype(np_ctype) + + @parameterized.parameters(itertools.product( + VALID_FFT_RANKS, range(3), (np.float32, np.float64))) + + def test_empty(self, rank, extra_dims, np_rtype): + np_ctype = np.complex64 if np_rtype == np.float32 else np.complex128 + dims = rank + extra_dims + x = np.zeros((0,) * dims).astype(np_rtype) + self.assertEqual(x.shape, self._tf_fft(x, rank).shape) + x = np.zeros((0,) * dims).astype(np_ctype) + self.assertEqual(x.shape, self._tf_ifft(x, rank).shape) + + @parameterized.parameters(itertools.product( + VALID_FFT_RANKS, range(3), (5, 6), (np.float32, np.float64))) + def test_basic(self, rank, extra_dims, size, np_rtype): + np_ctype = np.complex64 if np_rtype == np.float32 else np.complex128 + tol = 1e-4 if np_rtype == np.float32 else 5e-5 + dims = rank + extra_dims + inner_dim = size // 2 + 1 + r2c = np.mod(np.arange(np.power(size, dims)), 10).reshape( + (size,) * dims) + fft_length = (size,) * rank + self._compare_forward( + r2c.astype(np_rtype), rank, fft_length, rtol=tol, atol=tol) + c2r = np.mod(np.arange(np.power(size, dims - 1) * inner_dim), + 10).reshape((size,) * (dims - 1) + (inner_dim,)) + c2r = self._generate_valid_irfft_input(c2r, np_ctype, r2c, np_rtype, rank, + fft_length) + self._compare_backward(c2r, rank, fft_length, rtol=tol, atol=tol) + + @parameterized.parameters(itertools.product( + (1,), range(3), (64, 128), (np.float32, np.float64))) + def test_large_batch(self, rank, extra_dims, size, np_rtype): + np_ctype = np.complex64 if np_rtype == np.float32 else np.complex128 + tol = 1e-4 if np_rtype == np.float32 else 1e-5 + dims = rank + extra_dims + inner_dim = size // 2 + 1 + r2c = np.mod(np.arange(np.power(size, dims)), 10).reshape( + (size,) * dims) + fft_length = (size,) * rank + self._compare_forward( + r2c.astype(np_rtype), rank, fft_length, rtol=tol, atol=tol) + c2r = np.mod(np.arange(np.power(size, dims - 1) * inner_dim), + 10).reshape((size,) * (dims - 1) + (inner_dim,)) + c2r = self._generate_valid_irfft_input(c2r, np_ctype, r2c, np_rtype, rank, + fft_length) + self._compare_backward(c2r, rank, fft_length, rtol=tol, atol=tol) + + @parameterized.parameters(itertools.product( + VALID_FFT_RANKS, range(3), (5, 6), (np.float32, np.float64))) + def test_placeholder(self, rank, extra_dims, size, np_rtype): + if context.executing_eagerly(): + return + np_ctype = np.complex64 if np_rtype == np.float32 else np.complex128 + tol = 1e-4 if np_rtype == np.float32 else 1e-8 + dims = rank + extra_dims + inner_dim = size // 2 + 1 + r2c = np.mod(np.arange(np.power(size, dims)), 10).reshape( + (size,) * dims) + fft_length = (size,) * rank + self._compare_forward( + r2c.astype(np_rtype), + rank, + fft_length, + use_placeholder=True, + rtol=tol, + atol=tol) + c2r = np.mod(np.arange(np.power(size, dims - 1) * inner_dim), + 10).reshape((size,) * (dims - 1) + (inner_dim,)) + c2r = self._generate_valid_irfft_input(c2r, np_ctype, r2c, np_rtype, rank, + fft_length) + self._compare_backward( + c2r, rank, fft_length, use_placeholder=True, rtol=tol, atol=tol) + + @parameterized.parameters(itertools.product( + VALID_FFT_RANKS, range(3), (5, 6), (np.float32, np.float64))) + def test_fft_lenth_truncate(self, rank, extra_dims, size, np_rtype): + """Test truncation (FFT size < dimensions).""" + if test.is_built_with_rocm() and (rank == 3): + # TODO(rocm): fix me + # rfft fails for rank == 3 on ROCm + self.skipTest("Test fails on ROCm...fix me") + np_ctype = np.complex64 if np_rtype == np.float32 else np.complex128 + tol = 1e-4 if np_rtype == np.float32 else 8e-5 + dims = rank + extra_dims + inner_dim = size // 2 + 1 + r2c = np.mod(np.arange(np.power(size, dims)), 10).reshape( + (size,) * dims) + c2r = np.mod(np.arange(np.power(size, dims - 1) * inner_dim), + 10).reshape((size,) * (dims - 1) + (inner_dim,)) + fft_length = (size - 2,) * rank + self._compare_forward(r2c.astype(np_rtype), rank, fft_length, + rtol=tol, atol=tol) + c2r = self._generate_valid_irfft_input(c2r, np_ctype, r2c, np_rtype, rank, + fft_length) + self._compare_backward(c2r, rank, fft_length, rtol=tol, atol=tol) + # Confirm it works with unknown shapes as well. + if not context.executing_eagerly(): + self._compare_forward( + r2c.astype(np_rtype), + rank, + fft_length, + use_placeholder=True, + rtol=tol, atol=tol) + self._compare_backward( + c2r, rank, fft_length, use_placeholder=True, rtol=tol, atol=tol) + + @parameterized.parameters(itertools.product( + VALID_FFT_RANKS, range(3), (5, 6), (np.float32, np.float64))) + def test_fft_lenth_pad(self, rank, extra_dims, size, np_rtype): + """Test padding (FFT size > dimensions).""" + np_ctype = np.complex64 if np_rtype == np.float32 else np.complex128 + tol = 1e-4 if np_rtype == np.float32 else 8e-5 + dims = rank + extra_dims + inner_dim = size // 2 + 1 + r2c = np.mod(np.arange(np.power(size, dims)), 10).reshape( + (size,) * dims) + c2r = np.mod(np.arange(np.power(size, dims - 1) * inner_dim), + 10).reshape((size,) * (dims - 1) + (inner_dim,)) + fft_length = (size + 2,) * rank + self._compare_forward(r2c.astype(np_rtype), rank, fft_length, + rtol=tol, atol=tol) + c2r = self._generate_valid_irfft_input(c2r, np_ctype, r2c, np_rtype, rank, + fft_length) + self._compare_backward(c2r.astype(np_ctype), rank, fft_length, + rtol=tol, atol=tol) + # Confirm it works with unknown shapes as well. + if not context.executing_eagerly(): + self._compare_forward( + r2c.astype(np_rtype), + rank, + fft_length, + use_placeholder=True, + rtol=tol, atol=tol) + self._compare_backward( + c2r.astype(np_ctype), + rank, + fft_length, + use_placeholder=True, + rtol=tol, atol=tol) + + @parameterized.parameters(itertools.product( + VALID_FFT_RANKS, range(3), (5, 6), (np.float32, np.float64))) + def test_random(self, rank, extra_dims, size, np_rtype): + def gen_real(shape): + n = np.prod(shape) + re = np.random.uniform(size=n) + ret = re.reshape(shape) + return ret + + def gen_complex(shape): + n = np.prod(shape) + re = np.random.uniform(size=n) + im = np.random.uniform(size=n) + ret = (re + im * 1j).reshape(shape) + return ret + np_ctype = np.complex64 if np_rtype == np.float32 else np.complex128 + tol = 1e-4 if np_rtype == np.float32 else 1e-5 + dims = rank + extra_dims + r2c = gen_real((size,) * dims) + inner_dim = size // 2 + 1 + fft_length = (size,) * rank + self._compare_forward( + r2c.astype(np_rtype), rank, fft_length, rtol=tol, atol=tol) + complex_dims = (size,) * (dims - 1) + (inner_dim,) + c2r = gen_complex(complex_dims) + c2r = self._generate_valid_irfft_input(c2r, np_ctype, r2c, np_rtype, rank, + fft_length) + self._compare_backward(c2r, rank, fft_length, rtol=tol, atol=tol) + + def test_error(self): + # TODO(rjryan): Fix this test under Eager. + if context.executing_eagerly(): + return + for rank in VALID_FFT_RANKS: + for dims in range(0, rank): + x = np.zeros((1,) * dims).astype(np.complex64) + with self.assertRaisesWithPredicateMatch( + ValueError, "Shape .* must have rank at least {}".format(rank)): + self._tf_fft(x, rank) + with self.assertRaisesWithPredicateMatch( + ValueError, "Shape .* must have rank at least {}".format(rank)): + self._tf_ifft(x, rank) + for dims in range(rank, rank + 2): + x = np.zeros((1,) * rank) + + # Test non-rank-1 fft_length produces an error. + fft_length = np.zeros((1, 1)).astype(np.int32) + with self.assertRaisesWithPredicateMatch(ValueError, + "Shape .* must have rank 1"): + self._tf_fft(x, rank, fft_length) + with self.assertRaisesWithPredicateMatch(ValueError, + "Shape .* must have rank 1"): + self._tf_ifft(x, rank, fft_length) + + # Test wrong fft_length length. + fft_length = np.zeros((rank + 1,)).astype(np.int32) + with self.assertRaisesWithPredicateMatch( + ValueError, "Dimension must be .*but is {}.*".format(rank + 1)): + self._tf_fft(x, rank, fft_length) + with self.assertRaisesWithPredicateMatch( + ValueError, "Dimension must be .*but is {}.*".format(rank + 1)): + self._tf_ifft(x, rank, fft_length) + + # Test that calling the kernel directly without padding to fft_length + # produces an error. + rffts_for_rank = { + 1: [gen_spectral_ops.rfft, gen_spectral_ops.irfft], + 2: [gen_spectral_ops.rfft2d, gen_spectral_ops.irfft2d], + 3: [gen_spectral_ops.rfft3d, gen_spectral_ops.irfft3d] + } + rfft_fn, irfft_fn = rffts_for_rank[rank] + with self.assertRaisesWithPredicateMatch( + errors.InvalidArgumentError, + "Input dimension .* must have length of at least 6 but got: 5"): + x = np.zeros((5,) * rank).astype(np.float32) + fft_length = [6] * rank + with self.cached_session(): + self.evaluate(rfft_fn(x, fft_length)) + + with self.assertRaisesWithPredicateMatch( + errors.InvalidArgumentError, + "Input dimension .* must have length of at least .* but got: 3"): + x = np.zeros((3,) * rank).astype(np.complex64) + fft_length = [6] * rank + with self.cached_session(): + self.evaluate(irfft_fn(x, fft_length)) + + @parameterized.parameters(itertools.product( + VALID_FFT_RANKS, range(2), (5, 6), (np.float32, np.float64))) + def test_grad_simple(self, rank, extra_dims, size, np_rtype): + # rfft3d/irfft3d do not have gradients yet. + if rank == 3: + return + dims = rank + extra_dims + tol = 1e-3 if np_rtype == np.float32 else 1e-10 + re = np.ones(shape=(size,) * dims, dtype=np_rtype) + im = -np.ones(shape=(size,) * dims, dtype=np_rtype) + self._check_grad_real(self._tf_fft_for_rank(rank), re, + rtol=tol, atol=tol) + if test.is_built_with_rocm(): + # Fails on ROCm because of irfft peculairity + return + self._check_grad_complex( + self._tf_ifft_for_rank(rank), re, im, result_is_complex=False, + rtol=tol, atol=tol) + + @parameterized.parameters(itertools.product( + VALID_FFT_RANKS, range(2), (5, 6), (np.float32, np.float64))) + def test_grad_random(self, rank, extra_dims, size, np_rtype): + # rfft3d/irfft3d do not have gradients yet. + if rank == 3: + return + dims = rank + extra_dims + tol = 1e-2 if np_rtype == np.float32 else 1e-10 + re = np.random.rand(*((size,) * dims)).astype(np_rtype) * 2 - 1 + im = np.random.rand(*((size,) * dims)).astype(np_rtype) * 2 - 1 + self._check_grad_real(self._tf_fft_for_rank(rank), re, + rtol=tol, atol=tol) + if test.is_built_with_rocm(): + # Fails on ROCm because of irfft peculairity + return + self._check_grad_complex( + self._tf_ifft_for_rank(rank), re, im, result_is_complex=False, + rtol=tol, atol=tol) + + def test_invalid_args(self): + # Test case for GitHub issue 55263 + a = np.empty([6, 0]) + b = np.array([1, -1]) + with self.assertRaisesRegex(errors.InvalidArgumentError, "must >= 0"): + with self.session(): + v = tf.signal.rfft2d(input_tensor=a, fft_length=b) + self.evaluate(v) + + +class FFTNTest(test_util.TestCase): """Tests for FFT ops.""" # pylint: disable=missing-function-docstring From de8f1fb582e51a4b34430761a33bd570f63c404c Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 28 Jul 2022 11:58:00 +0000 Subject: [PATCH 003/101] Add multi-threading and env var to control use of FFTW --- Makefile | 4 +- tensorflow_mri/cc/kernels/fft_kernels.cc | 294 +++++----------------- tensorflow_mri/cc/third_party/fftw/fftw.h | 3 + 3 files changed, 67 insertions(+), 234 deletions(-) diff --git a/Makefile b/Makefile index 6df8d7bf..2b6db006 100644 --- a/Makefile +++ b/Makefile @@ -14,11 +14,11 @@ TF_LDFLAGS := $(shell $(PYTHON) -c 'import tensorflow as tf; print(" ".join(tf.s CFLAGS := -O3 -march=x86-64 -mtune=generic CXXFLAGS := $(CFLAGS) -CXXFLAGS += $(TF_CFLAGS) -fPIC -std=c++14 +CXXFLAGS += $(TF_CFLAGS) -fPIC -std=c++14 -fopenmp CXXFLAGS += -I$(ROOT_DIR) LDFLAGS := $(TF_LDFLAGS) -LDFLAGS += -lfftw3 -lfftw3f +LDFLAGS += -lfftw3_omp -lfftw3f_omp -lfftw3 -lfftw3f -lm LDFLAGS += -l:libspiral_waveform.a all: lib wheel diff --git a/tensorflow_mri/cc/kernels/fft_kernels.cc b/tensorflow_mri/cc/kernels/fft_kernels.cc index 21d0a8b2..94da5455 100644 --- a/tensorflow_mri/cc/kernels/fft_kernels.cc +++ b/tensorflow_mri/cc/kernels/fft_kernels.cc @@ -175,27 +175,8 @@ class FFTCPU : public FFTBase { DoComplexFFT(ctx, fft_shape, in, out); } } else { - if (IsForward()) { - if (is_complex128) { - DCHECK_EQ(in.dtype(), DT_DOUBLE); - DCHECK_EQ(out->dtype(), DT_COMPLEX128); - DoRealForwardFFT(ctx, fft_shape, in, out); - } else { - DCHECK_EQ(in.dtype(), DT_FLOAT); - DCHECK_EQ(out->dtype(), DT_COMPLEX64); - DoRealForwardFFT(ctx, fft_shape, in, out); - } - } else { - if (is_complex128) { - DCHECK_EQ(in.dtype(), DT_COMPLEX128); - DCHECK_EQ(out->dtype(), DT_DOUBLE); - DoRealBackwardFFT(ctx, fft_shape, in, out); - } else { - DCHECK_EQ(in.dtype(), DT_COMPLEX64); - DCHECK_EQ(out->dtype(), DT_FLOAT); - DoRealBackwardFFT(ctx, fft_shape, in, out); - } - } + OP_REQUIRES(ctx, false, + errors::Unimplemented("Real FFT is not implemented")); } } @@ -203,8 +184,8 @@ class FFTCPU : public FFTBase { void DoComplexFFT(OpKernelContext* ctx, uint64* fft_shape, const Tensor& in, Tensor* out) { auto device = ctx->eigen_device(); - std::cout << "Using FFTW" << std::endl; - std::cout << "numThreads: " << device.numThreads() << std::endl; + auto worker_threads = ctx->device()->tensorflow_cpu_worker_threads(); + auto num_threads = worker_threads->num_threads; const bool is_complex128 = in.dtype() == DT_COMPLEX128 || out->dtype() == DT_COMPLEX128; @@ -235,15 +216,25 @@ class FFTCPU : public FFTBase { constexpr auto fft_sign = Forward ? FFTW_FORWARD : FFTW_BACKWARD; constexpr auto fft_flags = FFTW_ESTIMATE; - auto fft_plan = fftw::plan_many_dft( - FFTRank, dim_sizes, batch_size, - reinterpret_cast*>(input.data()), - nullptr, 1, input_distance, - reinterpret_cast*>(output.data()), - nullptr, 1, output_distance, - fft_sign, fft_flags); + fftw::plan fft_plan; + { + mutex_lock l(mu_); + fftw::init_threads(); + fftw::plan_with_nthreads(num_threads); + fft_plan = fftw::plan_many_dft( + FFTRank, dim_sizes, batch_size, + reinterpret_cast*>(input.data()), + nullptr, 1, input_distance, + reinterpret_cast*>(output.data()), + nullptr, 1, output_distance, + fft_sign, fft_flags); + } fftw::execute(fft_plan); - fftw::destroy_plan(fft_plan); + { + mutex_lock l(mu_); + fftw::destroy_plan(fft_plan); + fftw::cleanup_threads(); + } // FFT normalization. if (fft_sign == FFTW_BACKWARD) { @@ -251,215 +242,54 @@ class FFTCPU : public FFTBase { } } - template - void DoRealForwardFFT(OpKernelContext* ctx, uint64* fft_shape, - const Tensor& in, Tensor* out) { - // Create the axes (which are always trailing). - const auto axes = Eigen::ArrayXi::LinSpaced(FFTRank, 1, FFTRank); - auto device = ctx->eigen_device(); - auto input = Tensor(in).flat_inner_dims(); - const auto input_dims = input.dimensions(); - - // Slice input to fft_shape on its inner-most dimensions. - Eigen::DSizes input_slice_sizes; - input_slice_sizes[0] = input_dims[0]; - TensorShape temp_shape{input_dims[0]}; - for (int i = 1; i <= FFTRank; ++i) { - input_slice_sizes[i] = fft_shape[i - 1]; - temp_shape.AddDim(fft_shape[i - 1]); - } - OP_REQUIRES(ctx, temp_shape.num_elements() > 0, - errors::InvalidArgument("Obtained a FFT shape of 0 elements: ", - temp_shape.DebugString())); - - auto output = out->flat_inner_dims(); - const Eigen::DSizes zero_start_indices; - - // Compute the full FFT using a temporary tensor. - Tensor temp; - OP_REQUIRES_OK(ctx, ctx->allocate_temp(DataTypeToEnum::v(), - temp_shape, &temp)); - auto full_fft = temp.flat_inner_dims(); - full_fft.device(device) = - input.slice(zero_start_indices, input_slice_sizes) - .template fft(axes); - - // Slice away the negative frequency components. - output.device(device) = - full_fft.slice(zero_start_indices, output.dimensions()); - } - - template - void DoRealBackwardFFT(OpKernelContext* ctx, uint64* fft_shape, - const Tensor& in, Tensor* out) { - auto device = ctx->eigen_device(); - // Reconstruct the full FFT and take the inverse. - auto input = Tensor(in).flat_inner_dims(); - auto output = out->flat_inner_dims(); - const auto input_dims = input.dimensions(); - - // Calculate the shape of the temporary tensor for the full FFT and the - // region we will slice from input given fft_shape. We slice input to - // fft_shape on its inner-most dimensions, except the last (which we - // slice to fft_shape[-1] / 2 + 1). - Eigen::DSizes input_slice_sizes; - input_slice_sizes[0] = input_dims[0]; - TensorShape full_fft_shape; - full_fft_shape.AddDim(input_dims[0]); - for (auto i = 1; i <= FFTRank; i++) { - input_slice_sizes[i] = - i == FFTRank ? fft_shape[i - 1] / 2 + 1 : fft_shape[i - 1]; - full_fft_shape.AddDim(fft_shape[i - 1]); - } - OP_REQUIRES(ctx, full_fft_shape.num_elements() > 0, - errors::InvalidArgument("Obtained a FFT shape of 0 elements: ", - full_fft_shape.DebugString())); - - Tensor temp; - OP_REQUIRES_OK(ctx, ctx->allocate_temp(DataTypeToEnum::v(), - full_fft_shape, &temp)); - auto full_fft = temp.flat_inner_dims(); - - // Calculate the starting point and range of the source of - // negative frequency part. - auto neg_sizes = input_slice_sizes; - neg_sizes[FFTRank] = fft_shape[FFTRank - 1] - input_slice_sizes[FFTRank]; - Eigen::DSizes neg_target_indices; - neg_target_indices[FFTRank] = input_slice_sizes[FFTRank]; - - const Eigen::DSizes start_indices; - Eigen::DSizes neg_start_indices; - neg_start_indices[FFTRank] = 1; - - full_fft.slice(start_indices, input_slice_sizes).device(device) = - input.slice(start_indices, input_slice_sizes); - - // First, conduct IFFTs on outer dimensions. We save computation (and - // avoid touching uninitialized memory) by slicing full_fft to the - // subregion we wrote input to. - if (FFTRank > 1) { - const auto outer_axes = - Eigen::ArrayXi::LinSpaced(FFTRank - 1, 1, FFTRank - 1); - full_fft.slice(start_indices, input_slice_sizes).device(device) = - full_fft.slice(start_indices, input_slice_sizes) - .template fft(outer_axes); - } - - // Reconstruct the full FFT by appending reversed and conjugated - // spectrum as the negative frequency part. - Eigen::array reverse_last_axis; - for (auto i = 0; i <= FFTRank; i++) { - reverse_last_axis[i] = i == FFTRank; - } - - if (neg_sizes[FFTRank] != 0) { - full_fft.slice(neg_target_indices, neg_sizes).device(device) = - full_fft.slice(neg_start_indices, neg_sizes) - .reverse(reverse_last_axis) - .conjugate(); - } - - auto inner_axis = Eigen::array{FFTRank}; - output.device(device) = - full_fft.template fft(inner_axis); - } -}; - -REGISTER_KERNEL_BUILDER(Name("FFT").Device(DEVICE_CPU).Priority(1), - FFTCPU); -REGISTER_KERNEL_BUILDER(Name("IFFT").Device(DEVICE_CPU).Priority(1), - FFTCPU); -REGISTER_KERNEL_BUILDER(Name("FFT2D").Device(DEVICE_CPU).Priority(1), - FFTCPU); -REGISTER_KERNEL_BUILDER(Name("IFFT2D").Device(DEVICE_CPU).Priority(1), - FFTCPU); -REGISTER_KERNEL_BUILDER(Name("FFT3D").Device(DEVICE_CPU).Priority(1), - FFTCPU); -REGISTER_KERNEL_BUILDER(Name("IFFT3D").Device(DEVICE_CPU).Priority(1), - FFTCPU); - -#if (defined(GOOGLE_CUDA) && GOOGLE_CUDA) || \ - (defined(TENSORFLOW_USE_ROCM) && TENSORFLOW_USE_ROCM) - -namespace { -template -se::DeviceMemory AsDeviceMemory(const T* cuda_memory) { - se::DeviceMemoryBase wrapped(const_cast(cuda_memory)); - se::DeviceMemory typed(wrapped); - return typed; -} - -template -se::DeviceMemory AsDeviceMemory(const T* cuda_memory, uint64 size) { - se::DeviceMemoryBase wrapped(const_cast(cuda_memory), size * sizeof(T)); - se::DeviceMemory typed(wrapped); - return typed; -} - -// A class to provide scratch-space allocator for Stream-Executor Cufft -// callback. Tensorflow is responsible for releasing the temporary buffers after -// the kernel finishes. -// TODO(yangzihao): Refactor redundant code in subclasses of ScratchAllocator -// into base class. -class CufftScratchAllocator : public se::ScratchAllocator { - public: - ~CufftScratchAllocator() override {} - CufftScratchAllocator(int64_t memory_limit, OpKernelContext* context) - : memory_limit_(memory_limit), total_byte_size_(0), context_(context) {} - int64_t GetMemoryLimitInBytes() override { return memory_limit_; } - se::port::StatusOr> AllocateBytes( - int64_t byte_size) override { - Tensor temporary_memory; - if (byte_size > memory_limit_) { - return se::port::StatusOr>(); - } - AllocationAttributes allocation_attr; - allocation_attr.retry_on_failure = false; - Status allocation_status(context_->allocate_temp( - DT_UINT8, TensorShape({byte_size}), &temporary_memory, - AllocatorAttributes(), allocation_attr)); - if (!allocation_status.ok()) { - return se::port::StatusOr>(); - } - // Hold the reference of the allocated tensors until the end of the - // allocator. - allocated_tensors_.push_back(temporary_memory); - total_byte_size_ += byte_size; - return se::port::StatusOr>( - AsDeviceMemory(temporary_memory.flat().data(), - temporary_memory.flat().size())); - } - int64_t TotalByteSize() { return total_byte_size_; } - private: - int64_t memory_limit_; - int64_t total_byte_size_; - OpKernelContext* context_; - std::vector allocated_tensors_; + // Used to control access to FFTW planner. + mutex mu_; }; -} // end namespace - -int64_t GetCufftWorkspaceLimit(const string& envvar_in_mb, - int64_t default_value_in_bytes) { - const char* workspace_limit_in_mb_str = getenv(envvar_in_mb.c_str()); - if (workspace_limit_in_mb_str != nullptr && - strcmp(workspace_limit_in_mb_str, "") != 0) { - int64_t scratch_limit_in_mb = -1; - Status status = ReadInt64FromEnvVar(envvar_in_mb, default_value_in_bytes, - &scratch_limit_in_mb); - if (!status.ok()) { - LOG(WARNING) << "Invalid value for env-var " << envvar_in_mb << ": " - << workspace_limit_in_mb_str; +// Environment variable `TFMRI_USE_FFTW` can be used to specify whether to use +// the FFTW library for the FFT. +static bool InitModule() { + const char* use_fftw_string = std::getenv("TFMRI_USE_FFTW"); + bool use_fftw; + if (use_fftw_string == nullptr) { + // Default to using FFTW if environment variable is not set. + use_fftw = true; + } else { + // Parse the value of the environment variable. + std::string str(use_fftw_string); + // To lower-case. + std::transform(str.begin(), str.end(), str.begin(), + [](unsigned char c){ return std::tolower(c); }); + if (str == "y" || str == "yes" || str == "t" || str == "true" || + str == "on" || str == "1") { + use_fftw = true; + } else if (str == "n" || str == "no" || str == "f" || str == "false" || + str == "off" || str == "0") { + use_fftw = false; } else { - return scratch_limit_in_mb * (1 << 20); + LOG(FATAL) << "Invalid value for environment variable " + << "TFMRI_USE_FFTW: " << str; } } - return default_value_in_bytes; + if (use_fftw) { + REGISTER_KERNEL_BUILDER(Name("FFT").Device(DEVICE_CPU).Priority(1), + FFTCPU); + REGISTER_KERNEL_BUILDER(Name("IFFT").Device(DEVICE_CPU).Priority(1), + FFTCPU); + REGISTER_KERNEL_BUILDER(Name("FFT2D").Device(DEVICE_CPU).Priority(1), + FFTCPU); + REGISTER_KERNEL_BUILDER(Name("IFFT2D").Device(DEVICE_CPU).Priority(1), + FFTCPU); + REGISTER_KERNEL_BUILDER(Name("FFT3D").Device(DEVICE_CPU).Priority(1), + FFTCPU); + REGISTER_KERNEL_BUILDER(Name("IFFT3D").Device(DEVICE_CPU).Priority(1), + FFTCPU); + } + return true; } - -#endif // GOOGLE_CUDA || TENSORFLOW_USE_ROCM +static bool module_initialized = InitModule(); } // namespace mri } // namespace tensorflow diff --git a/tensorflow_mri/cc/third_party/fftw/fftw.h b/tensorflow_mri/cc/third_party/fftw/fftw.h index cc6ea92c..77332191 100644 --- a/tensorflow_mri/cc/third_party/fftw/fftw.h +++ b/tensorflow_mri/cc/third_party/fftw/fftw.h @@ -140,6 +140,9 @@ struct PlanType { using Type = fftw_plan; }; +template +using plan = typename PlanType::Type; + template inline typename PlanType::Type plan_many_dft( int rank, const int *n, int howmany, From 887241079d526f1053b8daa3c297ec5234eba0a9 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 28 Jul 2022 15:26:49 +0000 Subject: [PATCH 004/101] Add docs for custom FFT kernels --- tensorflow_mri/cc/kernels/fft_kernels.cc | 11 +++-- tools/docs/guide/fft.ipynb | 58 ++++++++++++++++++++++++ tools/docs/templates/index.rst | 1 + 3 files changed, 66 insertions(+), 4 deletions(-) create mode 100644 tools/docs/guide/fft.ipynb diff --git a/tensorflow_mri/cc/kernels/fft_kernels.cc b/tensorflow_mri/cc/kernels/fft_kernels.cc index 94da5455..373835e3 100644 --- a/tensorflow_mri/cc/kernels/fft_kernels.cc +++ b/tensorflow_mri/cc/kernels/fft_kernels.cc @@ -247,10 +247,10 @@ class FFTCPU : public FFTBase { mutex mu_; }; -// Environment variable `TFMRI_USE_FFTW` can be used to specify whether to use -// the FFTW library for the FFT. +// Environment variable `TFMRI_USE_CUSTOM_FFT` can be used to specify whether to +// use custom FFT kernels. static bool InitModule() { - const char* use_fftw_string = std::getenv("TFMRI_USE_FFTW"); + const char* use_fftw_string = std::getenv("TFMRI_USE_CUSTOM_FFT"); bool use_fftw; if (use_fftw_string == nullptr) { // Default to using FFTW if environment variable is not set. @@ -269,10 +269,13 @@ static bool InitModule() { use_fftw = false; } else { LOG(FATAL) << "Invalid value for environment variable " - << "TFMRI_USE_FFTW: " << str; + << "TFMRI_USE_CUSTOM_FFT: " << str; } } if (use_fftw) { + // Register with priority 1 so that these kernels take precedence over the + // default Eigen implementation. Note that core TF registers the FFT GPU + // kernels with priority 1 too, so those still take precedence over these. REGISTER_KERNEL_BUILDER(Name("FFT").Device(DEVICE_CPU).Priority(1), FFTCPU); REGISTER_KERNEL_BUILDER(Name("IFFT").Device(DEVICE_CPU).Priority(1), diff --git a/tools/docs/guide/fft.ipynb b/tools/docs/guide/fft.ipynb new file mode 100644 index 00000000..f8608e63 --- /dev/null +++ b/tools/docs/guide/fft.ipynb @@ -0,0 +1,58 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fast Fourier transform (FFT)\n", + "\n", + "TensorFlow MRI uses the built-in FFT ops in core TensorFlow. These are [`tf.signal.fft`](https://www.tensorflow.org/api_docs/python/tf/signal/fft), [`tf.signal.fft2d`](https://www.tensorflow.org/api_docs/python/tf/signal/fft2d) and [`tf.signal.fft3d`](https://www.tensorflow.org/api_docs/python/tf/signal/fft3d).\n", + "\n", + "## Custom FFT kernels for CPU\n", + "\n", + "Unfortunately, TensorFlow's FFT ops are [known to be slow](https://github.com/tensorflow/tensorflow/issues/6541) on CPU. As a result, the FFT can become a significant bottleneck on MRI processing pipelines, especially on iterative reconstructions where the FFT is called repeatedly.\n", + "\n", + "To address this issue, TensorFlow MRI provides a set of custom FFT kernels based on the FFTW library. These offer a significant boost in performance compared to the kernels in core TensorFlow.\n", + "\n", + "The custom FFT kernels are automatically registered to the TensorFlow framework when importing TensorFlow MRI. If you have imported TensorFlow MRI, then the standard FFT ops will use the optimized kernels automatically.\n", + "\n", + ":::{tip}\n", + "You only need to `import tensorflow_mri` in order to use the custom FFT kernels. You can then access them as usual through `tf.signal.fft`, `tf.signal.fft2d` and `tf.signal.fft3d`.\n", + ":::\n", + "\n", + "The only caveat is that the [FFTW license](https://www.fftw.org/doc/License-and-Copyright.html) is more restrictive than the [Apache 2.0 license](https://www.apache.org/licenses/LICENSE-2.0) used by TensorFlow MRI. In particular, GNU GPL requires you to distribute any derivative software under equivalent terms.\n", + "\n", + ":::{warning}\n", + "If you intend to use custom FFT kernels for commercial purposes, you will need to purchase a commercial FFTW license.\n", + ":::\n", + "\n", + "### Disable the use of custom FFT kernels\n", + "\n", + "You can control whether custom FFT kernels are used via the `TFMRI_USE_CUSTOM_FFT` environment variable. When set to false, TensorFlow MRI will not register its custom FFT kernels, falling back to the standard FFT kernels in core TensorFlow. If the variable is unset, its value defaults to true.\n", + "\n", + ":::{tip}\n", + "Set `TFMRI_USE_CUSTOM_FFT=0` to disable the custom FFT kernels. This must be done **before** importing TensorFlow MRI. Setting or changing the value of `TFMRI_USE_CUSTOM_FFT` after importing the package will have no effect.\n", + ":::" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.10 64-bit", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.8.10" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tools/docs/templates/index.rst b/tools/docs/templates/index.rst index f7099966..e410e98e 100644 --- a/tools/docs/templates/index.rst +++ b/tools/docs/templates/index.rst @@ -16,6 +16,7 @@ TensorFlow MRI |release| Guide Installation + Fast Fourier transform Non-uniform FFT Linear algebra Optimization From 26cb09d3601fa405498d1c9d145e2d5130de10ca Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Fri, 29 Jul 2022 14:39:39 +0000 Subject: [PATCH 005/101] Refactored linalg submodule --- tensorflow_mri/__init__.py | 1 - tensorflow_mri/_api/linalg/__init__.py | 28 +- .../python/layers/data_consistency.py | 127 ++ .../python/layers/data_consistency_test.py | 51 + tensorflow_mri/python/linalg/__init__.py | 30 + .../python/linalg/conjugate_gradient.py | 233 +++ .../python/linalg/conjugate_gradient_test.py | 161 ++ .../linear_operator.py} | 416 +---- .../python/linalg/linear_operator_addition.py | 71 + .../linalg/linear_operator_addition_test.py | 15 + .../python/linalg/linear_operator_adjoint.py | 22 + .../linalg/linear_operator_adjoint_test.py | 15 + .../linalg/linear_operator_composition.py | 83 + .../linear_operator_composition_test.py | 16 + .../python/linalg/linear_operator_diag.py | 101 ++ .../linalg/linear_operator_diag_test.py | 103 ++ .../linear_operator_finite_difference.py | 125 ++ .../linear_operator_finite_difference_test.py | 81 + .../linalg/linear_operator_gram_matrix.py | 147 ++ .../linear_operator_gram_matrix_test.py | 15 + .../python/linalg/linear_operator_gram_mri.py | 144 ++ .../linalg/linear_operator_gram_mri_test.py | 76 + .../linalg/linear_operator_gram_nufft.py | 259 +++ .../linalg/linear_operator_gram_nufft_test.py | 75 + .../python/linalg/linear_operator_mri.py | 466 +++++ .../python/linalg/linear_operator_mri_test.py | 175 ++ .../python/linalg/linear_operator_nufft.py | 253 +++ .../linalg/linear_operator_nufft_test.py | 200 +++ .../linalg/linear_operator_scaled_identity.py | 103 ++ .../linear_operator_scaled_identity_test.py | 15 + .../linear_operator_test.py} | 96 +- .../python/linalg/linear_operator_wavelet.py | 153 ++ .../linalg/linear_operator_wavelet_test.py | 87 + tensorflow_mri/python/ops/convex_ops.py | 30 +- tensorflow_mri/python/ops/linalg_ops.py | 1497 ----------------- tensorflow_mri/python/ops/linalg_ops_test.py | 686 -------- tensorflow_mri/python/ops/optimizer_ops.py | 4 +- tensorflow_mri/python/ops/recon_ops.py | 49 +- tensorflow_mri/python/util/__init__.py | 1 - tools/build/create_api.py | 1 - tools/docs/tutorials/recon/unet_fastmri.ipynb | 130 ++ tools/docs/tutorials/recon/varnet.ipynb | 37 + 42 files changed, 3641 insertions(+), 2737 deletions(-) create mode 100644 tensorflow_mri/python/layers/data_consistency.py create mode 100644 tensorflow_mri/python/layers/data_consistency_test.py create mode 100644 tensorflow_mri/python/linalg/__init__.py create mode 100644 tensorflow_mri/python/linalg/conjugate_gradient.py create mode 100755 tensorflow_mri/python/linalg/conjugate_gradient_test.py rename tensorflow_mri/python/{util/linalg_imaging.py => linalg/linear_operator.py} (50%) create mode 100644 tensorflow_mri/python/linalg/linear_operator_addition.py create mode 100644 tensorflow_mri/python/linalg/linear_operator_addition_test.py create mode 100644 tensorflow_mri/python/linalg/linear_operator_adjoint.py create mode 100644 tensorflow_mri/python/linalg/linear_operator_adjoint_test.py create mode 100644 tensorflow_mri/python/linalg/linear_operator_composition.py create mode 100644 tensorflow_mri/python/linalg/linear_operator_composition_test.py create mode 100644 tensorflow_mri/python/linalg/linear_operator_diag.py create mode 100644 tensorflow_mri/python/linalg/linear_operator_diag_test.py create mode 100644 tensorflow_mri/python/linalg/linear_operator_finite_difference.py create mode 100755 tensorflow_mri/python/linalg/linear_operator_finite_difference_test.py create mode 100644 tensorflow_mri/python/linalg/linear_operator_gram_matrix.py create mode 100644 tensorflow_mri/python/linalg/linear_operator_gram_matrix_test.py create mode 100644 tensorflow_mri/python/linalg/linear_operator_gram_mri.py create mode 100755 tensorflow_mri/python/linalg/linear_operator_gram_mri_test.py create mode 100644 tensorflow_mri/python/linalg/linear_operator_gram_nufft.py create mode 100755 tensorflow_mri/python/linalg/linear_operator_gram_nufft_test.py create mode 100644 tensorflow_mri/python/linalg/linear_operator_mri.py create mode 100755 tensorflow_mri/python/linalg/linear_operator_mri_test.py create mode 100644 tensorflow_mri/python/linalg/linear_operator_nufft.py create mode 100755 tensorflow_mri/python/linalg/linear_operator_nufft_test.py create mode 100644 tensorflow_mri/python/linalg/linear_operator_scaled_identity.py create mode 100644 tensorflow_mri/python/linalg/linear_operator_scaled_identity_test.py rename tensorflow_mri/python/{util/linalg_imaging_test.py => linalg/linear_operator_test.py} (56%) create mode 100644 tensorflow_mri/python/linalg/linear_operator_wavelet.py create mode 100755 tensorflow_mri/python/linalg/linear_operator_wavelet_test.py delete mode 100644 tensorflow_mri/python/ops/linalg_ops.py delete mode 100755 tensorflow_mri/python/ops/linalg_ops_test.py create mode 100644 tools/docs/tutorials/recon/unet_fastmri.ipynb create mode 100644 tools/docs/tutorials/recon/varnet.ipynb diff --git a/tensorflow_mri/__init__.py b/tensorflow_mri/__init__.py index 35b8f0e9..f28d39b6 100644 --- a/tensorflow_mri/__init__.py +++ b/tensorflow_mri/__init__.py @@ -13,7 +13,6 @@ from tensorflow_mri.python.ops.fft_ops import * from tensorflow_mri.python.ops.geom_ops import * from tensorflow_mri.python.ops.image_ops import * -from tensorflow_mri.python.ops.linalg_ops import * from tensorflow_mri.python.ops.math_ops import * from tensorflow_mri.python.ops.optimizer_ops import * from tensorflow_mri.python.ops.recon_ops import * diff --git a/tensorflow_mri/_api/linalg/__init__.py b/tensorflow_mri/_api/linalg/__init__.py index b4fb6a80..6876e706 100644 --- a/tensorflow_mri/_api/linalg/__init__.py +++ b/tensorflow_mri/_api/linalg/__init__.py @@ -2,17 +2,17 @@ # Do not edit. """Linear algebra operations.""" -from tensorflow_mri.python.util.linalg_imaging import LinearOperator as LinearOperator -from tensorflow_mri.python.util.linalg_imaging import LinearOperatorAdjoint as LinearOperatorAdjoint -from tensorflow_mri.python.util.linalg_imaging import LinearOperatorComposition as LinearOperatorComposition -from tensorflow_mri.python.util.linalg_imaging import LinearOperatorAddition as LinearOperatorAddition -from tensorflow_mri.python.util.linalg_imaging import LinearOperatorScaledIdentity as LinearOperatorScaledIdentity -from tensorflow_mri.python.util.linalg_imaging import LinearOperatorDiag as LinearOperatorDiag -from tensorflow_mri.python.util.linalg_imaging import LinearOperatorGramMatrix as LinearOperatorGramMatrix -from tensorflow_mri.python.ops.linalg_ops import LinearOperatorNUFFT as LinearOperatorNUFFT -from tensorflow_mri.python.ops.linalg_ops import LinearOperatorGramNUFFT as LinearOperatorGramNUFFT -from tensorflow_mri.python.ops.linalg_ops import LinearOperatorFiniteDifference as LinearOperatorFiniteDifference -from tensorflow_mri.python.ops.linalg_ops import LinearOperatorWavelet as LinearOperatorWavelet -from tensorflow_mri.python.ops.linalg_ops import LinearOperatorMRI as LinearOperatorMRI -from tensorflow_mri.python.ops.linalg_ops import LinearOperatorGramMRI as LinearOperatorGramMRI -from tensorflow_mri.python.ops.linalg_ops import conjugate_gradient as conjugate_gradient +from tensorflow_mri.python.linalg.linear_operator import LinearOperator as LinearOperator +from tensorflow_mri.python.linalg.linear_operator import LinearOperatorAdjoint as LinearOperatorAdjoint +from tensorflow_mri.python.linalg.conjugate_gradient import conjugate_gradient as conjugate_gradient +from tensorflow_mri.python.linalg.linear_operator_addition import LinearOperatorAddition as LinearOperatorAddition +from tensorflow_mri.python.linalg.linear_operator_composition import LinearOperatorComposition as LinearOperatorComposition +from tensorflow_mri.python.linalg.linear_operator_diag import LinearOperatorDiag as LinearOperatorDiag +from tensorflow_mri.python.linalg.linear_operator_finite_difference import LinearOperatorFiniteDifference as LinearOperatorFiniteDifference +from tensorflow_mri.python.linalg.linear_operator_scaled_identity import LinearOperatorScaledIdentity as LinearOperatorScaledIdentity +from tensorflow_mri.python.linalg.linear_operator_gram_matrix import LinearOperatorGramMatrix as LinearOperatorGramMatrix +from tensorflow_mri.python.linalg.linear_operator_nufft import LinearOperatorNUFFT as LinearOperatorNUFFT +from tensorflow_mri.python.linalg.linear_operator_gram_nufft import LinearOperatorGramNUFFT as LinearOperatorGramNUFFT +from tensorflow_mri.python.linalg.linear_operator_mri import LinearOperatorMRI as LinearOperatorMRI +from tensorflow_mri.python.linalg.linear_operator_gram_mri import LinearOperatorGramMRI as LinearOperatorGramMRI +from tensorflow_mri.python.linalg.linear_operator_wavelet import LinearOperatorWavelet as LinearOperatorWavelet diff --git a/tensorflow_mri/python/layers/data_consistency.py b/tensorflow_mri/python/layers/data_consistency.py new file mode 100644 index 00000000..60c96536 --- /dev/null +++ b/tensorflow_mri/python/layers/data_consistency.py @@ -0,0 +1,127 @@ +# Copyright 2022 University College London. 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. +# ============================================================================== +"""Data consistency layers.""" + +import tensorflow as tf + +from tensorflow_mri.python.linalg import linear_operator + + +class LeastSquaresGradientDescentStep(tf.keras.layers.Layer): + + def __init__(self, + operator, + scale_initializer=1.0, + dtype=None, + **kwargs): + + if not isinstance(operator, linear_operator.LinearOperator): + raise TypeError( + f"operator must be a `tfmri.linalg.LinearOperator` or a subclass " + f"thereof, but got type: {type(operator)}") + self.operator = operator + if isinstance(scale_initializer, (float, int)): + self.scale_initializer = tf.keras.initializers.Constant(scale_initializer) + else: + self.scale_initializer = tf.keras.initializers.get(scale_initializer) + if dtype is not None: + if tf.as_dtype(dtype) != self.operator.dtype: + raise ValueError( + f"dtype must be the same as the operator's dtype, but got " + f"dtype: {dtype} and operator's dtype: {self.operator.dtype}") + else: + dtype = self.operator.dtype + super().__init__(dtype=dtype, **kwargs) + + def build(self, input_shape): + self.scale = self.add_weight( + name='scale', + shape=(), + dtype=self.dtype.real_dtype, + initializer=self.scale_initializer, + trainable=self.trainable, + constraint=tf.keras.constraints.NonNeg()) + super().build(input_shape) + + def call(self, inputs): + x, y, args, kwargs = self._parse_inputs(inputs) + if args or kwargs: + raise ValueError( + f"unexpected arguments in call when GradientDescentStep has a " + f"predefined operator: {args}, {kwargs}") + operator = self.operator + return x - self.scale * operator.transform( + operator.transform(x) - y, adjoint=True) + + def _parse_inputs(self, inputs): + if isinstance(inputs, dict): + if 'x' not in inputs or 'y' not in inputs: + raise ValueError( + f"inputs dictionary must at least contain the keys 'x' and " + f"'y', but got keys: {inputs.keys()}") + x = inputs.pop('x') + y = inputs.pop('y') + args, kwargs = (), inputs + elif isinstance(inputs, tuple): + if len(inputs) < 2: + raise ValueError( + f"inputs tuple must contain at least two elements, " + f"x and y, but got tuple with length: {len(inputs)}") + x = inputs[0] + y = inputs[1] + args, kwargs = inputs[2:], {} + else: + raise TypeError("inputs must be a tuple or a dictionary.") + return x, y, args, kwargs + + def get_config(self): + config = { + 'operator': self.operator, + 'scale_initializer': tf.keras.initializers.serialize(self.scale_initializer) + } + base_config = super().get_config() + return {**config, **base_config} + + # @classmethod + # def from_config(cls, config): + # config = config.copy() + # operator = deserialize_linear_operator(config.pop('operator')) + # return cls(operator, **config) + + + +# def serialize_linear_operator(operator): +# if isinstance(operator, linear_operator.LinearOperator): +# return { +# 'class_name': operator.__class__.__name__, +# 'config': operator.parameters +# } +# raise TypeError( +# f"operator must be a `tfmri.linalg.LinearOperator` or a subclass " +# f"thereof, but got type: {type(operator)}") + + +# def deserialize_linear_operator(config): +# if (not isinstance(config, dict) or +# set(config.keys()) != {'class_name', 'config'}): +# raise ValueError( +# f"config must be a dictionary with keys 'class_name' and 'config', " +# f"but got: {config}") +# class_name = config['class_name'] +# config = config['config'] +# if class_name == 'LinearOperator': +# return linear_operator.LinearOperator(**config) +# raise ValueError( +# f"unexpected class name in serialized linear operator: {class_name}") diff --git a/tensorflow_mri/python/layers/data_consistency_test.py b/tensorflow_mri/python/layers/data_consistency_test.py new file mode 100644 index 00000000..cbf4c544 --- /dev/null +++ b/tensorflow_mri/python/layers/data_consistency_test.py @@ -0,0 +1,51 @@ +# Copyright 2022 University College London. 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. +# ============================================================================== +"""Tests for data consistency layers.""" + +import tensorflow as tf +from tensorflow.python.ops.linalg import linear_operator + +from tensorflow_mri.python.layers import data_consistency +from tensorflow_mri.python.linalg import linear_operator +from tensorflow_mri.python.util import test_util + + +class LeastSquaresGradientDescentStepTest(test_util.TestCase): + def test_general(self): + @linear_operator.make_composite_tensor + class LinearOperatorScalarMultiply(linear_operator.LinearOperator): + def __init__(self, scale): + parameters = {'scale': scale} + self.scale = tf.convert_to_tensor(scale) + super().__init__(dtype=self.scale.dtype, parameters=parameters) + + def _transform(self, x, adjoint=False): + if adjoint: + return x * tf.math.conj(self.scale) + else: + return x * self.scale + + def _domain_shape(self): + return tf.TensorShape([2]) + + def _range_shape(self): + return self._domain_shape() + + operator = LinearOperatorScalarMultiply(2.0 + 1.0j) + layer = data_consistency.LeastSquaresGradientDescentStep(operator) + + inputs = [3, 3], [1, 1] + result = layer(inputs) + print(result) diff --git a/tensorflow_mri/python/linalg/__init__.py b/tensorflow_mri/python/linalg/__init__.py new file mode 100644 index 00000000..a8797cd4 --- /dev/null +++ b/tensorflow_mri/python/linalg/__init__.py @@ -0,0 +1,30 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Linear algebra operators.""" + +from tensorflow_mri.python.linalg import conjugate_gradient +from tensorflow_mri.python.linalg import linear_operator_addition +from tensorflow_mri.python.linalg import linear_operator_adjoint +from tensorflow_mri.python.linalg import linear_operator_composition +from tensorflow_mri.python.linalg import linear_operator_diag +from tensorflow_mri.python.linalg import linear_operator_finite_difference +from tensorflow_mri.python.linalg import linear_operator_gram_matrix +from tensorflow_mri.python.linalg import linear_operator_gram_mri +from tensorflow_mri.python.linalg import linear_operator_gram_nufft +from tensorflow_mri.python.linalg import linear_operator_mri +from tensorflow_mri.python.linalg import linear_operator_nufft +from tensorflow_mri.python.linalg import linear_operator_scaled_identity +from tensorflow_mri.python.linalg import linear_operator_wavelet +from tensorflow_mri.python.linalg import linear_operator diff --git a/tensorflow_mri/python/linalg/conjugate_gradient.py b/tensorflow_mri/python/linalg/conjugate_gradient.py new file mode 100644 index 00000000..4aba7357 --- /dev/null +++ b/tensorflow_mri/python/linalg/conjugate_gradient.py @@ -0,0 +1,233 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== + +# Copyright 2019 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. +# ============================================================================== +"""Conjugate gradient solver.""" + +import collections + +import tensorflow as tf + +from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.linalg import linear_operator + + +@api_util.export("linalg.conjugate_gradient") +def conjugate_gradient(operator, + rhs, + preconditioner=None, + x=None, + tol=1e-5, + max_iterations=20, + bypass_gradient=False, + name=None): + r"""Conjugate gradient solver. + + Solves a linear system of equations :math:`Ax = b` for self-adjoint, positive + definite matrix :math:`A` and right-hand side vector :math:`b`, using an + iterative, matrix-free algorithm where the action of the matrix :math:`A` is + represented by `operator`. The iteration terminates when either the number of + iterations exceeds `max_iterations` or when the residual norm has been reduced + to `tol` times its initial value, i.e. + :math:`(\left\| b - A x_k \right\| <= \mathrm{tol} \left\| b \right\|\\)`. + + .. note:: + This function is similar to + `tf.linalg.experimental.conjugate_gradient`, except it adds support for + complex-valued linear systems and for imaging operators. + + Args: + operator: A `LinearOperator` that is self-adjoint and positive definite. + rhs: A `tf.Tensor` of shape `[..., N]`. The right hand-side of the linear + system. + preconditioner: A `LinearOperator` that approximates the inverse of `A`. + An efficient preconditioner could dramatically improve the rate of + convergence. If `preconditioner` represents matrix `M`(`M` approximates + `A^{-1}`), the algorithm uses `preconditioner.apply(x)` to estimate + `A^{-1}x`. For this to be useful, the cost of applying `M` should be + much lower than computing `A^{-1}` directly. + x: A `tf.Tensor` of shape `[..., N]`. The initial guess for the solution. + tol: A float scalar convergence tolerance. + max_iterations: An `int` giving the maximum number of iterations. + bypass_gradient: A `boolean`. If `True`, the gradient with respect to `rhs` + will be computed by applying the inverse of `operator` to the upstream + gradient with respect to `x` (through CG iteration), instead of relying + on TensorFlow's automatic differentiation. This may reduce memory usage + when training neural networks, but `operator` must not have any trainable + parameters. If `False`, gradients are computed normally. For more details, + see ref. [1]. + name: A name scope for the operation. + + Returns: + A `namedtuple` representing the final state with fields + + - i: A scalar `int32` `tf.Tensor`. Number of iterations executed. + - x: A rank-1 `tf.Tensor` of shape `[..., N]` containing the computed + solution. + - r: A rank-1 `tf.Tensor` of shape `[.., M]` containing the residual vector. + - p: A rank-1 `tf.Tensor` of shape `[..., N]`. `A`-conjugate basis vector. + - gamma: \\(r \dot M \dot r\\), equivalent to \\(||r||_2^2\\) when + `preconditioner=None`. + + Raises: + ValueError: If `operator` is not self-adjoint and positive definite. + + References: + .. [1] Aggarwal, H. K., Mani, M. P., & Jacob, M. (2018). MoDL: Model-based + deep learning architecture for inverse problems. IEEE transactions on + medical imaging, 38(2), 394-405. + """ + if bypass_gradient: + if preconditioner is not None: + raise ValueError( + "preconditioner is not supported when bypass_gradient is True.") + if x is not None: + raise ValueError("x is not supported when bypass_gradient is True.") + + def _conjugate_gradient_simple(rhs): + return _conjugate_gradient_internal(operator, rhs, + tol=tol, + max_iterations=max_iterations, + name=name) + + @tf.custom_gradient + def _conjugate_gradient_internal_grad(rhs): + result = _conjugate_gradient_simple(rhs) + + def grad(*upstream_grads): + # upstream_grads has the upstream gradient for each element of the + # output tuple (i, x, r, p, gamma). + _, dx, _, _, _ = upstream_grads + return _conjugate_gradient_simple(dx).x + + return result, grad + + return _conjugate_gradient_internal_grad(rhs) + + return _conjugate_gradient_internal(operator, rhs, + preconditioner=preconditioner, + x=x, + tol=tol, + max_iterations=max_iterations, + name=name) + + +def _conjugate_gradient_internal(operator, + rhs, + preconditioner=None, + x=None, + tol=1e-5, + max_iterations=20, + name=None): + """Implementation of `conjugate_gradient`. + + For the parameters, see `conjugate_gradient`. + """ + if isinstance(operator, linear_operator.LinearOperatorMixin): + rhs = operator.flatten_domain_shape(rhs) + + if not (operator.is_self_adjoint and operator.is_positive_definite): + raise ValueError('Expected a self-adjoint, positive definite operator.') + + cg_state = collections.namedtuple('CGState', ['i', 'x', 'r', 'p', 'gamma']) + + def stopping_criterion(i, state): + return tf.math.logical_and( + i < max_iterations, + tf.math.reduce_any( + tf.math.real(tf.norm(state.r, axis=-1)) > tf.math.real(tol))) + + def dot(x, y): + return tf.squeeze( + tf.linalg.matvec( + x[..., tf.newaxis], + y, adjoint_a=True), axis=-1) + + def cg_step(i, state): # pylint: disable=missing-docstring + z = tf.linalg.matvec(operator, state.p) + alpha = state.gamma / dot(state.p, z) + x = state.x + alpha[..., tf.newaxis] * state.p + r = state.r - alpha[..., tf.newaxis] * z + if preconditioner is None: + q = r + else: + q = preconditioner.matvec(r) + gamma = dot(r, q) + beta = gamma / state.gamma + p = q + beta[..., tf.newaxis] * state.p + return i + 1, cg_state(i + 1, x, r, p, gamma) + + # We now broadcast initial shapes so that we have fixed shapes per iteration. + + with tf.name_scope(name or 'conjugate_gradient'): + broadcast_shape = tf.broadcast_dynamic_shape( + tf.shape(rhs)[:-1], + operator.batch_shape_tensor()) + static_broadcast_shape = tf.broadcast_static_shape( + rhs.shape[:-1], + operator.batch_shape) + if preconditioner is not None: + broadcast_shape = tf.broadcast_dynamic_shape( + broadcast_shape, + preconditioner.batch_shape_tensor()) + static_broadcast_shape = tf.broadcast_static_shape( + static_broadcast_shape, + preconditioner.batch_shape) + broadcast_rhs_shape = tf.concat([broadcast_shape, [tf.shape(rhs)[-1]]], -1) + static_broadcast_rhs_shape = static_broadcast_shape.concatenate( + [rhs.shape[-1]]) + r0 = tf.broadcast_to(rhs, broadcast_rhs_shape) + tol *= tf.norm(r0, axis=-1) + + if x is None: + x = tf.zeros( + broadcast_rhs_shape, dtype=rhs.dtype.base_dtype) + x = tf.ensure_shape(x, static_broadcast_rhs_shape) + else: + r0 = rhs - tf.linalg.matvec(operator, x) + if preconditioner is None: + p0 = r0 + else: + p0 = tf.linalg.matvec(preconditioner, r0) + gamma0 = dot(r0, p0) + i = tf.constant(0, dtype=tf.int32) + state = cg_state(i=i, x=x, r=r0, p=p0, gamma=gamma0) + _, state = tf.while_loop( + stopping_criterion, cg_step, [i, state]) + + if isinstance(operator, linear_operator.LinearOperatorMixin): + x = operator.expand_range_dimension(state.x) + else: + x = state.x + + return cg_state( + state.i, + x=x, + r=state.r, + p=state.p, + gamma=state.gamma) diff --git a/tensorflow_mri/python/linalg/conjugate_gradient_test.py b/tensorflow_mri/python/linalg/conjugate_gradient_test.py new file mode 100755 index 00000000..a653ac21 --- /dev/null +++ b/tensorflow_mri/python/linalg/conjugate_gradient_test.py @@ -0,0 +1,161 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== + +# Copyright 2019 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. +# ============================================================================== +"""Tests for module `conjugate_gradient`.""" +# pylint: disable=missing-class-docstring,missing-function-docstring + +from absl.testing import parameterized +import numpy as np +import tensorflow as tf + +from tensorflow_mri.python.linalg import conjugate_gradient +from tensorflow_mri.python.util import test_util + + +@test_util.run_all_in_graph_and_eager_modes +class ConjugateGradientTest(test_util.TestCase): + """Tests for op `conjugate_gradient`.""" + @parameterized.product(dtype=[np.float32, np.float64], + shape=[[1, 1], [4, 4], [10, 10]], + use_static_shape=[True, False]) + def test_conjugate_gradient(self, dtype, shape, use_static_shape): # pylint: disable=missing-param-doc + """Test CG method.""" + np.random.seed(1) + a_np = np.random.uniform( + low=-1.0, high=1.0, size=np.prod(shape)).reshape(shape).astype(dtype) + # Make a self-adjoint, positive definite. + a_np = np.dot(a_np.T, a_np) + # jacobi preconditioner + jacobi_np = np.zeros_like(a_np) + jacobi_np[range(a_np.shape[0]), range(a_np.shape[1])] = ( + 1.0 / a_np.diagonal()) + rhs_np = np.random.uniform( + low=-1.0, high=1.0, size=shape[0]).astype(dtype) + x_np = np.zeros_like(rhs_np) + tol = 1e-6 if dtype == np.float64 else 1e-3 + max_iterations = 20 + + if use_static_shape: + a = tf.constant(a_np) + rhs = tf.constant(rhs_np) + x = tf.constant(x_np) + jacobi = tf.constant(jacobi_np) + else: + a = tf.compat.v1.placeholder_with_default(a_np, shape=None) + rhs = tf.compat.v1.placeholder_with_default(rhs_np, shape=None) + x = tf.compat.v1.placeholder_with_default(x_np, shape=None) + jacobi = tf.compat.v1.placeholder_with_default(jacobi_np, shape=None) + + operator = tf.linalg.LinearOperatorFullMatrix( + a, is_positive_definite=True, is_self_adjoint=True) + preconditioners = [ + None, + # Preconditioner that does nothing beyond change shape. + tf.linalg.LinearOperatorIdentity( + a_np.shape[-1], + dtype=a_np.dtype, + is_positive_definite=True, + is_self_adjoint=True), + # Jacobi preconditioner. + tf.linalg.LinearOperatorFullMatrix( + jacobi, + is_positive_definite=True, + is_self_adjoint=True), + ] + cg_results = [] + for preconditioner in preconditioners: + cg_graph = conjugate_gradient.conjugate_gradient( + operator, + rhs, + preconditioner=preconditioner, + x=x, + tol=tol, + max_iterations=max_iterations) + cg_val = self.evaluate(cg_graph) + norm_r0 = np.linalg.norm(rhs_np) + norm_r = np.linalg.norm(cg_val.r) + self.assertLessEqual(norm_r, tol * norm_r0) + # Validate that we get an equally small residual norm with numpy + # using the computed solution. + r_np = rhs_np - np.dot(a_np, cg_val.x) + norm_r_np = np.linalg.norm(r_np) + self.assertLessEqual(norm_r_np, tol * norm_r0) + cg_results.append(cg_val) + + # Validate that we get same results using identity_preconditioner + # and None + self.assertEqual(cg_results[0].i, cg_results[1].i) + self.assertAlmostEqual(cg_results[0].gamma, cg_results[1].gamma) + self.assertAllClose(cg_results[0].r, cg_results[1].r, rtol=tol) + self.assertAllClose(cg_results[0].x, cg_results[1].x, rtol=tol) + self.assertAllClose(cg_results[0].p, cg_results[1].p, rtol=tol) + + def test_bypass_gradient(self): + """Tests the `bypass_gradient` argument.""" + dtype = np.float32 + shape = [4, 4] + np.random.seed(1) + a_np = np.random.uniform( + low=-1.0, high=1.0, size=np.prod(shape)).reshape(shape).astype(dtype) + # Make a self-adjoint, positive definite. + a_np = np.dot(a_np.T, a_np) + + rhs_np = np.random.uniform( + low=-1.0, high=1.0, size=shape[0]).astype(dtype) + + tol = 1e-3 + max_iterations = 20 + + a = tf.constant(a_np) + rhs = tf.constant(rhs_np) + operator = tf.linalg.LinearOperatorFullMatrix( + a, is_positive_definite=True, is_self_adjoint=True) + + with tf.GradientTape(persistent=True) as tape: + tape.watch(rhs) + result = conjugate_gradient.conjugate_gradient( + operator, + rhs, + tol=tol, + max_iterations=max_iterations) + result_bypass = conjugate_gradient.conjugate_gradient( + operator, + rhs, + tol=tol, + max_iterations=max_iterations, + bypass_gradient=True) + + grad = tape.gradient(result.x, rhs) + grad_bypass = tape.gradient(result_bypass.x, rhs) + self.assertAllClose(result, result_bypass) + self.assertAllClose(grad, grad_bypass, rtol=tol) + + +if __name__ == '__main__': + tf.test.main() diff --git a/tensorflow_mri/python/util/linalg_imaging.py b/tensorflow_mri/python/linalg/linear_operator.py similarity index 50% rename from tensorflow_mri/python/util/linalg_imaging.py rename to tensorflow_mri/python/linalg/linear_operator.py index 1bd7bd9e..b5853e35 100644 --- a/tensorflow_mri/python/util/linalg_imaging.py +++ b/tensorflow_mri/python/linalg/linear_operator.py @@ -12,23 +12,17 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== -"""Linear algebra for images. - -Contains the imaging mixin and imaging extensions of basic linear operators. -""" +"""Base linear operator.""" import abc import tensorflow as tf -from tensorflow_mri.python.ops import array_ops from tensorflow_mri.python.util import api_util -from tensorflow_mri.python.util import check_util -from tensorflow_mri.python.util import linalg_ext from tensorflow_mri.python.util import tensor_util -class LinalgImagingMixin(tf.linalg.LinearOperator): +class LinearOperatorMixin(tf.linalg.LinearOperator): """Mixin for linear operators meant to operate on images.""" def transform(self, x, adjoint=False, name="transform"): """Transform a batch of images. @@ -87,7 +81,7 @@ def batch_shape_tensor(self, name="batch_shape_tensor"): def adjoint(self, name="adjoint"): """Returns the adjoint of this linear operator. - The returned operator is a valid `LinalgImagingMixin` instance. + The returned operator is a valid `LinearOperatorMixin` instance. Calling `self.adjoint()` and `self.H` are equivalent. @@ -95,7 +89,7 @@ def adjoint(self, name="adjoint"): name: A name for this operation. Returns: - A `LinearOperator` derived from `LinalgImagingMixin`, which + A `LinearOperator` derived from `LinearOperatorMixin`, which represents the adjoint of this linear operator. """ if self.is_self_adjoint: @@ -270,7 +264,7 @@ def expand_range_dimension(self, x): @api_util.export("linalg.LinearOperator") -class LinearOperator(LinalgImagingMixin, tf.linalg.LinearOperator): # pylint: disable=abstract-method +class LinearOperator(LinearOperatorMixin, tf.linalg.LinearOperator): # pylint: disable=abstract-method r"""Base class defining a [batch of] linear operator[s]. Provides access to common matrix operations without the need to materialize @@ -369,7 +363,7 @@ class LinearOperator(LinalgImagingMixin, tf.linalg.LinearOperator): # pylint: d @api_util.export("linalg.LinearOperatorAdjoint") -class LinearOperatorAdjoint(LinalgImagingMixin, # pylint: disable=abstract-method +class LinearOperatorAdjoint(LinearOperatorMixin, # pylint: disable=abstract-method tf.linalg.LinearOperatorAdjoint): """Linear operator representing the adjoint of another operator. @@ -415,401 +409,3 @@ def _range_shape_tensor(self): def _batch_shape_tensor(self): return self.operator.batch_shape_tensor() - - -@api_util.export("linalg.LinearOperatorComposition") -class LinearOperatorComposition(LinalgImagingMixin, # pylint: disable=abstract-method - tf.linalg.LinearOperatorComposition): - """Composes one or more linear operators. - - `LinearOperatorComposition` is initialized with a list of operators - :math:`A_1, A_2, ..., A_J` and represents their composition - :math:`A_1 A_2 ... A_J`. - - .. note: - Similar to `tf.linalg.LinearOperatorComposition`_, but with imaging - extensions. - - Args: - operators: A `list` of `LinearOperator` objects, each with the same `dtype` - and composable shape. - is_non_singular: Expect that this operator is non-singular. - is_self_adjoint: Expect that this operator is equal to its Hermitian - transpose. - is_positive_definite: Expect that this operator is positive definite, - meaning the quadratic form :math:`x^H A x` has positive real part for all - nonzero :math:`x`. Note that we do not require the operator to be - self-adjoint to be positive-definite. - is_square: Expect that this operator acts like square [batch] matrices. - name: A name for this `LinearOperator`. Default is the individual - operators names joined with `_o_`. - - .. _tf.linalg.LinearOperatorComposition: https://www.tensorflow.org/api_docs/python/tf/linalg/LinearOperatorComposition - """ - def _transform(self, x, adjoint=False): - # pylint: disable=protected-access - if adjoint: - transform_order_list = self.operators - else: - transform_order_list = list(reversed(self.operators)) - - result = transform_order_list[0]._transform(x, adjoint=adjoint) - for operator in transform_order_list[1:]: - result = operator._transform(result, adjoint=adjoint) - return result - - def _domain_shape(self): - return self.operators[-1].domain_shape - - def _range_shape(self): - return self.operators[0].range_shape - - def _batch_shape(self): - return array_ops.broadcast_static_shapes( - *[operator.batch_shape for operator in self.operators]) - - def _domain_shape_tensor(self): - return self.operators[-1].domain_shape_tensor() - - def _range_shape_tensor(self): - return self.operators[0].range_shape_tensor() - - def _batch_shape_tensor(self): - return array_ops.broadcast_dynamic_shapes( - *[operator.batch_shape_tensor() for operator in self.operators]) - - -@api_util.export("linalg.LinearOperatorAddition") -class LinearOperatorAddition(LinalgImagingMixin, # pylint: disable=abstract-method - linalg_ext.LinearOperatorAddition): - """Adds one or more linear operators. - - `LinearOperatorAddition` is initialized with a list of operators - :math:`A_1, A_2, ..., A_J` and represents their addition - :math:`A_1 + A_2 + ... + A_J`. - - Args: - operators: A `list` of `LinearOperator` objects, each with the same `dtype` - and shape. - is_non_singular: Expect that this operator is non-singular. - is_self_adjoint: Expect that this operator is equal to its Hermitian - transpose. - is_positive_definite: Expect that this operator is positive definite, - meaning the quadratic form :math:`x^H A x` has positive real part for all - nonzero :math:`x`. Note that we do not require the operator to be - self-adjoint to be positive-definite. - is_square: Expect that this operator acts like square [batch] matrices. - name: A name for this `LinearOperator`. Default is the individual - operators names joined with `_p_`. - """ - def _transform(self, x, adjoint=False): - # pylint: disable=protected-access - result = self.operators[0]._transform(x, adjoint=adjoint) - for operator in self.operators[1:]: - result += operator._transform(x, adjoint=adjoint) - return result - - def _domain_shape(self): - return self.operators[0].domain_shape - - def _range_shape(self): - return self.operators[0].range_shape - - def _batch_shape(self): - return array_ops.broadcast_static_shapes( - *[operator.batch_shape for operator in self.operators]) - - def _domain_shape_tensor(self): - return self.operators[0].domain_shape_tensor() - - def _range_shape_tensor(self): - return self.operators[0].range_shape_tensor() - - def _batch_shape_tensor(self): - return array_ops.broadcast_dynamic_shapes( - *[operator.batch_shape_tensor() for operator in self.operators]) - - -@api_util.export("linalg.LinearOperatorScaledIdentity") -class LinearOperatorScaledIdentity(LinalgImagingMixin, # pylint: disable=abstract-method - tf.linalg.LinearOperatorScaledIdentity): - """Linear operator representing a scaled identity matrix. - - .. note: - Similar to `tf.linalg.LinearOperatorScaledIdentity`_, but with imaging - extensions. - - Args: - shape: Non-negative integer `Tensor`. The shape of the operator. - multiplier: A `Tensor` of shape `[B1, ..., Bb]`, or `[]` (a scalar). - is_non_singular: Expect that this operator is non-singular. - is_self_adjoint: Expect that this operator is equal to its hermitian - transpose. - is_positive_definite: Expect that this operator is positive definite, - meaning the quadratic form `x^H A x` has positive real part for all - nonzero `x`. Note that we do not require the operator to be - self-adjoint to be positive-definite. See: - https://en.wikipedia.org/wiki/Positive-definite_matrix#Extension_for_non-symmetric_matrices - is_square: Expect that this operator acts like square [batch] matrices. - assert_proper_shapes: Python `bool`. If `False`, only perform static - checks that initialization and method arguments have proper shape. - If `True`, and static checks are inconclusive, add asserts to the graph. - name: A name for this `LinearOperator`. - - .. _tf.linalg.LinearOperatorScaledIdentity: https://www.tensorflow.org/api_docs/python/tf/linalg/LinearOperatorScaledIdentity - """ - def __init__(self, - shape, - multiplier, - is_non_singular=None, - is_self_adjoint=None, - is_positive_definite=None, - is_square=True, - assert_proper_shapes=False, - name="LinearOperatorScaledIdentity"): - - self._domain_shape_tensor_value = tensor_util.convert_shape_to_tensor( - shape, name="shape") - self._domain_shape_value = tf.TensorShape(tf.get_static_value( - self._domain_shape_tensor_value)) - - super().__init__( - num_rows=tf.math.reduce_prod(shape), - multiplier=multiplier, - is_non_singular=is_non_singular, - is_self_adjoint=is_self_adjoint, - is_positive_definite=is_positive_definite, - is_square=is_square, - assert_proper_shapes=assert_proper_shapes, - name=name) - - def _transform(self, x, adjoint=False): - domain_rank = tf.size(self.domain_shape_tensor()) - multiplier_shape = tf.concat([ - tf.shape(self.multiplier), - tf.ones((domain_rank,), dtype=tf.int32)], 0) - multiplier_matrix = tf.reshape(self.multiplier, multiplier_shape) - if adjoint: - multiplier_matrix = tf.math.conj(multiplier_matrix) - return x * multiplier_matrix - - def _domain_shape(self): - return self._domain_shape_value - - def _range_shape(self): - return self._domain_shape_value - - def _batch_shape(self): - return self.multiplier.shape - - def _domain_shape_tensor(self): - return self._domain_shape_tensor_value - - def _range_shape_tensor(self): - return self._domain_shape_tensor_value - - def _batch_shape_tensor(self): - return tf.shape(self.multiplier) - - -@api_util.export("linalg.LinearOperatorDiag") -class LinearOperatorDiag(LinalgImagingMixin, tf.linalg.LinearOperatorDiag): # pylint: disable=abstract-method - """Linear operator representing a square diagonal matrix. - - This operator acts like a [batch] diagonal matrix `A` with shape - `[B1, ..., Bb, N, N]` for some `b >= 0`. The first `b` indices index a - batch member. For every batch index `(i1, ..., ib)`, `A[i1, ..., ib, : :]` is - an `N x N` matrix. This matrix `A` is not materialized, but for - purposes of broadcasting this shape will be relevant. - - .. note: - Similar to `tf.linalg.LinearOperatorDiag`_, but with imaging extensions. - - Args: - diag: A `tf.Tensor` of shape `[B1, ..., Bb, *S]`. - rank: An `int`. The rank of `S`. Must be <= `diag.shape.rank`. - is_non_singular: Expect that this operator is non-singular. - is_self_adjoint: Expect that this operator is equal to its Hermitian - transpose. If `diag` is real, this is auto-set to `True`. - is_positive_definite: Expect that this operator is positive definite, - meaning the quadratic form :math:`x^H A x` has positive real part for all - nonzero :math:`x`. Note that we do not require the operator to be - self-adjoint to be positive-definite. - is_square: Expect that this operator acts like square [batch] matrices. - name: A name for this `LinearOperator`. - - .. _tf.linalg.LinearOperatorDiag: https://www.tensorflow.org/api_docs/python/tf/linalg/LinearOperatorDiag - """ - # pylint: disable=invalid-unary-operand-type - def __init__(self, - diag, - rank, - is_non_singular=None, - is_self_adjoint=None, - is_positive_definite=None, - is_square=True, - name='LinearOperatorDiag'): - # pylint: disable=invalid-unary-operand-type - diag = tf.convert_to_tensor(diag, name='diag') - self._rank = check_util.validate_rank(rank, name='rank', accept_none=False) - if self._rank > diag.shape.rank: - raise ValueError( - f"Argument `rank` must be <= `diag.shape.rank`, but got: {rank}") - - self._shape_tensor_value = tf.shape(diag) - self._shape_value = diag.shape - batch_shape = self._shape_tensor_value[:-self._rank] - - super().__init__( - diag=tf.reshape(diag, tf.concat([batch_shape, [-1]], 0)), - is_non_singular=is_non_singular, - is_self_adjoint=is_self_adjoint, - is_positive_definite=is_positive_definite, - is_square=is_square, - name=name) - - def _transform(self, x, adjoint=False): - diag = tf.math.conj(self.diag) if adjoint else self.diag - return tf.reshape(diag, self.domain_shape_tensor()) * x - - def _domain_shape(self): - return self._shape_value[-self._rank:] - - def _range_shape(self): - return self._shape_value[-self._rank:] - - def _batch_shape(self): - return self._shape_value[:-self._rank] - - def _domain_shape_tensor(self): - return self._shape_tensor_value[-self._rank:] - - def _range_shape_tensor(self): - return self._shape_tensor_value[-self._rank:] - - def _batch_shape_tensor(self): - return self._shape_tensor_value[:-self._rank] - - -@api_util.export("linalg.LinearOperatorGramMatrix") -class LinearOperatorGramMatrix(LinearOperator): # pylint: disable=abstract-method - r"""Linear operator representing the Gram matrix of an operator. - - If :math:`A` is a `LinearOperator`, this operator is equivalent to - :math:`A^H A`. - - The Gram matrix of :math:`A` appears in the normal equation - :math:`A^H A x = A^H b` associated with the least squares problem - :math:`{\mathop{\mathrm{argmin}}_x} {\left \| Ax-b \right \|_2^2}`. - - This operator is self-adjoint and positive definite. Therefore, linear systems - defined by this linear operator can be solved using the conjugate gradient - method. - - This operator supports the optional addition of a regularization parameter - :math:`\lambda` and a transform matrix :math:`T`. If these are provided, - this operator becomes :math:`A^H A + \lambda T^H T`. This appears - in the regularized normal equation - :math:`\left ( A^H A + \lambda T^H T \right ) x = A^H b + \lambda T^H T x_0`, - associated with the regularized least squares problem - :math:`{\mathop{\mathrm{argmin}}_x} {\left \| Ax-b \right \|_2^2 + \lambda \left \| T(x-x_0) \right \|_2^2}`. - - Args: - operator: A `tfmri.linalg.LinearOperator`. The operator :math:`A` whose Gram - matrix is represented by this linear operator. - reg_parameter: A `Tensor` of shape `[B1, ..., Bb]` and real dtype. - The regularization parameter :math:`\lambda`. Defaults to 0. - reg_operator: A `tfmri.linalg.LinearOperator`. The regularization transform - :math:`T`. Defaults to the identity. - gram_operator: A `tfmri.linalg.LinearOperator`. The Gram matrix - :math:`A^H A`. This may be optionally provided to use a specialized - Gram matrix implementation. Defaults to `None`. - is_non_singular: Expect that this operator is non-singular. - is_self_adjoint: Expect that this operator is equal to its Hermitian - transpose. - is_positive_definite: Expect that this operator is positive definite, - meaning the quadratic form :math:`x^H A x` has positive real part for all - nonzero :math:`x`. Note that we do not require the operator to be - self-adjoint to be positive-definite. - is_square: Expect that this operator acts like square [batch] matrices. - name: A name for this `LinearOperator`. - """ - def __init__(self, - operator, - reg_parameter=None, - reg_operator=None, - gram_operator=None, - is_non_singular=None, - is_self_adjoint=True, - is_positive_definite=True, - is_square=True, - name=None): - parameters = dict( - operator=operator, - reg_parameter=reg_parameter, - reg_operator=reg_operator, - is_non_singular=is_non_singular, - is_self_adjoint=is_self_adjoint, - is_positive_definite=is_positive_definite, - is_square=is_square, - name=name) - self._operator = operator - self._reg_parameter = reg_parameter - self._reg_operator = reg_operator - self._gram_operator = gram_operator - if gram_operator is not None: - self._composed = gram_operator - else: - self._composed = LinearOperatorComposition( - operators=[self._operator.H, self._operator]) - - if not is_self_adjoint: - raise ValueError("A Gram matrix is always self-adjoint.") - if not is_positive_definite: - raise ValueError("A Gram matrix is always positive-definite.") - if not is_square: - raise ValueError("A Gram matrix is always square.") - - if self._reg_parameter is not None: - reg_operator_gm = LinearOperatorScaledIdentity( - shape=self._operator.domain_shape, - multiplier=tf.cast(self._reg_parameter, self._operator.dtype)) - if self._reg_operator is not None: - reg_operator_gm = LinearOperatorComposition( - operators=[reg_operator_gm, - self._reg_operator.H, - self._reg_operator]) - self._composed = LinearOperatorAddition( - operators=[self._composed, reg_operator_gm]) - - super().__init__(operator.dtype, - is_non_singular=is_non_singular, - is_self_adjoint=is_self_adjoint, - is_positive_definite=is_positive_definite, - is_square=is_square, - parameters=parameters) - - def _transform(self, x, adjoint=False): - return self._composed.transform(x, adjoint=adjoint) - - def _domain_shape(self): - return self.operator.domain_shape - - def _range_shape(self): - return self.operator.domain_shape - - def _batch_shape(self): - return self.operator.batch_shape - - def _domain_shape_tensor(self): - return self.operator.domain_shape_tensor() - - def _range_shape_tensor(self): - return self.operator.domain_shape_tensor() - - def _batch_shape_tensor(self): - return self.operator.batch_shape_tensor() - - @property - def operator(self): - return self._operator diff --git a/tensorflow_mri/python/linalg/linear_operator_addition.py b/tensorflow_mri/python/linalg/linear_operator_addition.py new file mode 100644 index 00000000..5097cd59 --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_addition.py @@ -0,0 +1,71 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Addition of linear operators.""" + +from tensorflow_mri.python.ops import array_ops +from tensorflow_mri.python.linalg import linear_operator +from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.util import linalg_ext + + +@api_util.export("linalg.LinearOperatorAddition") +class LinearOperatorAddition(linear_operator.LinearOperatorMixin, # pylint: disable=abstract-method + linalg_ext.LinearOperatorAddition): + """Adds one or more linear operators. + + `LinearOperatorAddition` is initialized with a list of operators + :math:`A_1, A_2, ..., A_J` and represents their addition + :math:`A_1 + A_2 + ... + A_J`. + + Args: + operators: A `list` of `LinearOperator` objects, each with the same `dtype` + and shape. + is_non_singular: Expect that this operator is non-singular. + is_self_adjoint: Expect that this operator is equal to its Hermitian + transpose. + is_positive_definite: Expect that this operator is positive definite, + meaning the quadratic form :math:`x^H A x` has positive real part for all + nonzero :math:`x`. Note that we do not require the operator to be + self-adjoint to be positive-definite. + is_square: Expect that this operator acts like square [batch] matrices. + name: A name for this `LinearOperator`. Default is the individual + operators names joined with `_p_`. + """ + def _transform(self, x, adjoint=False): + # pylint: disable=protected-access + result = self.operators[0]._transform(x, adjoint=adjoint) + for operator in self.operators[1:]: + result += operator._transform(x, adjoint=adjoint) + return result + + def _domain_shape(self): + return self.operators[0].domain_shape + + def _range_shape(self): + return self.operators[0].range_shape + + def _batch_shape(self): + return array_ops.broadcast_static_shapes( + *[operator.batch_shape for operator in self.operators]) + + def _domain_shape_tensor(self): + return self.operators[0].domain_shape_tensor() + + def _range_shape_tensor(self): + return self.operators[0].range_shape_tensor() + + def _batch_shape_tensor(self): + return array_ops.broadcast_dynamic_shapes( + *[operator.batch_shape_tensor() for operator in self.operators]) diff --git a/tensorflow_mri/python/linalg/linear_operator_addition_test.py b/tensorflow_mri/python/linalg/linear_operator_addition_test.py new file mode 100644 index 00000000..5eb4ac3d --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_addition_test.py @@ -0,0 +1,15 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Tests for module `linear_operator_addition`.""" diff --git a/tensorflow_mri/python/linalg/linear_operator_adjoint.py b/tensorflow_mri/python/linalg/linear_operator_adjoint.py new file mode 100644 index 00000000..e5c53928 --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_adjoint.py @@ -0,0 +1,22 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Adjoint of a linear operator.""" + +from tensorflow_mri.python.linalg import linear_operator + + +# This is actually defined in `linear_operator` module to avoid circular +# dependencies. +LinearOperatorAdjoint = linear_operator.LinearOperatorAdjoint diff --git a/tensorflow_mri/python/linalg/linear_operator_adjoint_test.py b/tensorflow_mri/python/linalg/linear_operator_adjoint_test.py new file mode 100644 index 00000000..529158d7 --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_adjoint_test.py @@ -0,0 +1,15 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Tests for module `linear_operator_adjoint`.""" diff --git a/tensorflow_mri/python/linalg/linear_operator_composition.py b/tensorflow_mri/python/linalg/linear_operator_composition.py new file mode 100644 index 00000000..3078ba71 --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_composition.py @@ -0,0 +1,83 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Composition of linear operators.""" + +import tensorflow as tf + +from tensorflow_mri.python.ops import array_ops +from tensorflow_mri.python.linalg import linear_operator +from tensorflow_mri.python.util import api_util + + +@api_util.export("linalg.LinearOperatorComposition") +class LinearOperatorComposition(linear_operator.LinearOperatorMixin, # pylint: disable=abstract-method + tf.linalg.LinearOperatorComposition): + """Composes one or more linear operators. + + `LinearOperatorComposition` is initialized with a list of operators + :math:`A_1, A_2, ..., A_J` and represents their composition + :math:`A_1 A_2 ... A_J`. + + .. note: + Similar to `tf.linalg.LinearOperatorComposition`_, but with imaging + extensions. + + Args: + operators: A `list` of `LinearOperator` objects, each with the same `dtype` + and composable shape. + is_non_singular: Expect that this operator is non-singular. + is_self_adjoint: Expect that this operator is equal to its Hermitian + transpose. + is_positive_definite: Expect that this operator is positive definite, + meaning the quadratic form :math:`x^H A x` has positive real part for all + nonzero :math:`x`. Note that we do not require the operator to be + self-adjoint to be positive-definite. + is_square: Expect that this operator acts like square [batch] matrices. + name: A name for this `LinearOperator`. Default is the individual + operators names joined with `_o_`. + + .. _tf.linalg.LinearOperatorComposition: https://www.tensorflow.org/api_docs/python/tf/linalg/LinearOperatorComposition + """ + def _transform(self, x, adjoint=False): + # pylint: disable=protected-access + if adjoint: + transform_order_list = self.operators + else: + transform_order_list = list(reversed(self.operators)) + + result = transform_order_list[0]._transform(x, adjoint=adjoint) + for operator in transform_order_list[1:]: + result = operator._transform(result, adjoint=adjoint) + return result + + def _domain_shape(self): + return self.operators[-1].domain_shape + + def _range_shape(self): + return self.operators[0].range_shape + + def _batch_shape(self): + return array_ops.broadcast_static_shapes( + *[operator.batch_shape for operator in self.operators]) + + def _domain_shape_tensor(self): + return self.operators[-1].domain_shape_tensor() + + def _range_shape_tensor(self): + return self.operators[0].range_shape_tensor() + + def _batch_shape_tensor(self): + return array_ops.broadcast_dynamic_shapes( + *[operator.batch_shape_tensor() for operator in self.operators]) diff --git a/tensorflow_mri/python/linalg/linear_operator_composition_test.py b/tensorflow_mri/python/linalg/linear_operator_composition_test.py new file mode 100644 index 00000000..304fbac1 --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_composition_test.py @@ -0,0 +1,16 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Tests for module `linear_operator_composition`.""" +# pylint: disable=missing-class-docstring,missing-function-docstring diff --git a/tensorflow_mri/python/linalg/linear_operator_diag.py b/tensorflow_mri/python/linalg/linear_operator_diag.py new file mode 100644 index 00000000..a6658317 --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_diag.py @@ -0,0 +1,101 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Diagonal linear operator.""" + +import tensorflow as tf + +from tensorflow_mri.python.linalg import linear_operator +from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.util import check_util + + +@api_util.export("linalg.LinearOperatorDiag") +class LinearOperatorDiag(linear_operator.LinearOperatorMixin, # pylint: disable=abstract-method + tf.linalg.LinearOperatorDiag): + """Linear operator representing a square diagonal matrix. + + This operator acts like a [batch] diagonal matrix `A` with shape + `[B1, ..., Bb, N, N]` for some `b >= 0`. The first `b` indices index a + batch member. For every batch index `(i1, ..., ib)`, `A[i1, ..., ib, : :]` is + an `N x N` matrix. This matrix `A` is not materialized, but for + purposes of broadcasting this shape will be relevant. + + .. note: + Similar to `tf.linalg.LinearOperatorDiag`_, but with imaging extensions. + + Args: + diag: A `tf.Tensor` of shape `[B1, ..., Bb, *S]`. + rank: An `int`. The rank of `S`. Must be <= `diag.shape.rank`. + is_non_singular: Expect that this operator is non-singular. + is_self_adjoint: Expect that this operator is equal to its Hermitian + transpose. If `diag` is real, this is auto-set to `True`. + is_positive_definite: Expect that this operator is positive definite, + meaning the quadratic form :math:`x^H A x` has positive real part for all + nonzero :math:`x`. Note that we do not require the operator to be + self-adjoint to be positive-definite. + is_square: Expect that this operator acts like square [batch] matrices. + name: A name for this `LinearOperator`. + + .. _tf.linalg.LinearOperatorDiag: https://www.tensorflow.org/api_docs/python/tf/linalg/LinearOperatorDiag + """ + # pylint: disable=invalid-unary-operand-type + def __init__(self, + diag, + rank, + is_non_singular=None, + is_self_adjoint=None, + is_positive_definite=None, + is_square=True, + name='LinearOperatorDiag'): + # pylint: disable=invalid-unary-operand-type + diag = tf.convert_to_tensor(diag, name='diag') + self._rank = check_util.validate_rank(rank, name='rank', accept_none=False) + if self._rank > diag.shape.rank: + raise ValueError( + f"Argument `rank` must be <= `diag.shape.rank`, but got: {rank}") + + self._shape_tensor_value = tf.shape(diag) + self._shape_value = diag.shape + batch_shape = self._shape_tensor_value[:-self._rank] + + super().__init__( + diag=tf.reshape(diag, tf.concat([batch_shape, [-1]], 0)), + is_non_singular=is_non_singular, + is_self_adjoint=is_self_adjoint, + is_positive_definite=is_positive_definite, + is_square=is_square, + name=name) + + def _transform(self, x, adjoint=False): + diag = tf.math.conj(self.diag) if adjoint else self.diag + return tf.reshape(diag, self.domain_shape_tensor()) * x + + def _domain_shape(self): + return self._shape_value[-self._rank:] + + def _range_shape(self): + return self._shape_value[-self._rank:] + + def _batch_shape(self): + return self._shape_value[:-self._rank] + + def _domain_shape_tensor(self): + return self._shape_tensor_value[-self._rank:] + + def _range_shape_tensor(self): + return self._shape_tensor_value[-self._rank:] + + def _batch_shape_tensor(self): + return self._shape_tensor_value[:-self._rank] diff --git a/tensorflow_mri/python/linalg/linear_operator_diag_test.py b/tensorflow_mri/python/linalg/linear_operator_diag_test.py new file mode 100644 index 00000000..d5018221 --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_diag_test.py @@ -0,0 +1,103 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Tests for module `linear_operator_diag`.""" +# pylint: disable=missing-class-docstring,missing-function-docstring + +import tensorflow as tf + +from tensorflow_mri.python.linalg import linear_operator +from tensorflow_mri.python.util import test_util + + +class LinearOperatorDiagTest(test_util.TestCase): + """Tests for `linear_operator.LinearOperatorDiag`.""" + def test_transform(self): + """Test `transform` method.""" + diag = tf.constant([[1., 2.], [3., 4.]]) + diag_linop = linear_operator.LinearOperatorDiag(diag, rank=2) + x = tf.constant([[2., 2.], [2., 2.]]) + self.assertAllClose([[2., 4.], [6., 8.]], diag_linop.transform(x)) + + def test_transform_adjoint(self): + """Test `transform` method with adjoint.""" + diag = tf.constant([[1., 2.], [3., 4.]]) + diag_linop = linear_operator.LinearOperatorDiag(diag, rank=2) + x = tf.constant([[2., 2.], [2., 2.]]) + self.assertAllClose([[2., 4.], [6., 8.]], + diag_linop.transform(x, adjoint=True)) + + def test_transform_complex(self): + """Test `transform` method with complex values.""" + diag = tf.constant([[1. + 1.j, 2. + 2.j], [3. + 3.j, 4. + 4.j]], + dtype=tf.complex64) + diag_linop = linear_operator.LinearOperatorDiag(diag, rank=2) + x = tf.constant([[2., 2.], [2., 2.]], dtype=tf.complex64) + self.assertAllClose([[2. + 2.j, 4. + 4.j], [6. + 6.j, 8. + 8.j]], + diag_linop.transform(x)) + + def test_transform_adjoint_complex(self): + """Test `transform` method with adjoint and complex values.""" + diag = tf.constant([[1. + 1.j, 2. + 2.j], [3. + 3.j, 4. + 4.j]], + dtype=tf.complex64) + diag_linop = linear_operator.LinearOperatorDiag(diag, rank=2) + x = tf.constant([[2., 2.], [2., 2.]], dtype=tf.complex64) + self.assertAllClose([[2. - 2.j, 4. - 4.j], [6. - 6.j, 8. - 8.j]], + diag_linop.transform(x, adjoint=True)) + + def test_shapes(self): + """Test shapes.""" + diag = tf.constant([[1., 2.], [3., 4.]]) + diag_linop = linear_operator.LinearOperatorDiag(diag, rank=2) + self.assertIsInstance(diag_linop.domain_shape, tf.TensorShape) + self.assertIsInstance(diag_linop.range_shape, tf.TensorShape) + self.assertAllEqual([2, 2], diag_linop.domain_shape) + self.assertAllEqual([2, 2], diag_linop.range_shape) + + def test_tensor_shapes(self): + """Test tensor shapes.""" + diag = tf.constant([[1., 2.], [3., 4.]]) + diag_linop = linear_operator.LinearOperatorDiag(diag, rank=2) + self.assertIsInstance(diag_linop.domain_shape_tensor(), tf.Tensor) + self.assertIsInstance(diag_linop.range_shape_tensor(), tf.Tensor) + self.assertAllEqual([2, 2], diag_linop.domain_shape_tensor()) + self.assertAllEqual([2, 2], diag_linop.range_shape_tensor()) + + def test_batch_shapes(self): + """Test batch shapes.""" + diag = tf.constant([[1., 2., 3.], [4., 5., 6.]]) + diag_linop = linear_operator.LinearOperatorDiag(diag, rank=1) + self.assertIsInstance(diag_linop.domain_shape, tf.TensorShape) + self.assertIsInstance(diag_linop.range_shape, tf.TensorShape) + self.assertIsInstance(diag_linop.batch_shape, tf.TensorShape) + self.assertAllEqual([3], diag_linop.domain_shape) + self.assertAllEqual([3], diag_linop.range_shape) + self.assertAllEqual([2], diag_linop.batch_shape) + + def test_tensor_batch_shapes(self): + """Test tensor batch shapes.""" + diag = tf.constant([[1., 2., 3.], [4., 5., 6.]]) + diag_linop = linear_operator.LinearOperatorDiag(diag, rank=1) + self.assertIsInstance(diag_linop.domain_shape_tensor(), tf.Tensor) + self.assertIsInstance(diag_linop.range_shape_tensor(), tf.Tensor) + self.assertIsInstance(diag_linop.batch_shape_tensor(), tf.Tensor) + self.assertAllEqual([3], diag_linop.domain_shape) + self.assertAllEqual([3], diag_linop.range_shape) + self.assertAllEqual([2], diag_linop.batch_shape) + + def test_name(self): + """Test names.""" + diag = tf.constant([[1., 2.], [3., 4.]]) + diag_linop = linear_operator.LinearOperatorDiag(diag, rank=2) + self.assertEqual("LinearOperatorDiag", diag_linop.name) diff --git a/tensorflow_mri/python/linalg/linear_operator_finite_difference.py b/tensorflow_mri/python/linalg/linear_operator_finite_difference.py new file mode 100644 index 00000000..b0cda807 --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_finite_difference.py @@ -0,0 +1,125 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Finite difference linear operator.""" + + +import tensorflow as tf + +from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.util import check_util +from tensorflow_mri.python.linalg import linear_operator +from tensorflow_mri.python.util import tensor_util + + +@api_util.export("linalg.LinearOperatorFiniteDifference") +class LinearOperatorFiniteDifference(linear_operator.LinearOperator): # pylint: disable=abstract-method + """Linear operator representing a finite difference matrix. + + Args: + domain_shape: A 1D `tf.Tensor` or a `list` of `int`. The domain shape of + this linear operator. + axis: An `int`. The axis along which the finite difference is taken. + Defaults to -1. + dtype: A `tf.dtypes.DType`. The data type for this operator. Defaults to + `float32`. + name: A `str`. A name for this operator. + """ + def __init__(self, + domain_shape, + axis=-1, + dtype=tf.dtypes.float32, + name="LinearOperatorFiniteDifference"): + + parameters = dict( + domain_shape=domain_shape, + axis=axis, + dtype=dtype, + name=name + ) + + # Compute the static and dynamic shapes and save them for later use. + self._domain_shape_static, self._domain_shape_dynamic = ( + tensor_util.static_and_dynamic_shapes_from_shape(domain_shape)) + + # Validate axis and canonicalize to negative. This ensures the correct + # axis is selected in the presence of batch dimensions. + self.axis = check_util.validate_static_axes( + axis, self._domain_shape_static.rank, + min_length=1, + max_length=1, + canonicalize="negative", + scalar_to_list=False) + + # Compute range shape statically. The range has one less element along + # the difference axis than the domain. + range_shape_static = self._domain_shape_static.as_list() + if range_shape_static[self.axis] is not None: + range_shape_static[self.axis] -= 1 + range_shape_static = tf.TensorShape(range_shape_static) + self._range_shape_static = range_shape_static + + # Now compute dynamic range shape. First concatenate the leading axes with + # the updated difference dimension. Then, iff the difference axis is not + # the last one, concatenate the trailing axes. + range_shape_dynamic = self._domain_shape_dynamic + range_shape_dynamic = tf.concat([ + range_shape_dynamic[:self.axis], + [range_shape_dynamic[self.axis] - 1]], 0) + if self.axis != -1: + range_shape_dynamic = tf.concat([ + range_shape_dynamic, + range_shape_dynamic[self.axis + 1:]], 0) + self._range_shape_dynamic = range_shape_dynamic + + super().__init__(dtype, + is_non_singular=None, + is_self_adjoint=None, + is_positive_definite=None, + is_square=None, + name=name, + parameters=parameters) + + def _transform(self, x, adjoint=False): + + if adjoint: + paddings1 = [[0, 0]] * x.shape.rank + paddings2 = [[0, 0]] * x.shape.rank + paddings1[self.axis] = [1, 0] + paddings2[self.axis] = [0, 1] + x1 = tf.pad(x, paddings1) # pylint: disable=no-value-for-parameter + x2 = tf.pad(x, paddings2) # pylint: disable=no-value-for-parameter + x = x1 - x2 + else: + slice1 = [slice(None)] * x.shape.rank + slice2 = [slice(None)] * x.shape.rank + slice1[self.axis] = slice(1, None) + slice2[self.axis] = slice(None, -1) + x1 = x[tuple(slice1)] + x2 = x[tuple(slice2)] + x = x1 - x2 + + return x + + def _domain_shape(self): + return self._domain_shape_static + + def _range_shape(self): + return self._range_shape_static + + def _domain_shape_tensor(self): + return self._domain_shape_dynamic + + def _range_shape_tensor(self): + return self._range_shape_dynamic diff --git a/tensorflow_mri/python/linalg/linear_operator_finite_difference_test.py b/tensorflow_mri/python/linalg/linear_operator_finite_difference_test.py new file mode 100755 index 00000000..730a9cf7 --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_finite_difference_test.py @@ -0,0 +1,81 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Tests for module `linear_operator_finite_difference`.""" +# pylint: disable=missing-class-docstring,missing-function-docstring + +import numpy as np +import tensorflow as tf + +from tensorflow_mri.python.linalg import linear_operator_finite_difference +from tensorflow_mri.python.util import test_util + + +class LinearOperatorFiniteDifferenceTest(test_util.TestCase): + """Tests for difference linear operator.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.linop1 = ( + linear_operator_finite_difference.LinearOperatorFiniteDifference([4])) + cls.linop2 = ( + linear_operator_finite_difference.LinearOperatorFiniteDifference( + [4, 4], axis=-2)) + cls.matrix1 = tf.convert_to_tensor([[-1, 1, 0, 0], + [0, -1, 1, 0], + [0, 0, -1, 1]], dtype=tf.float32) + + def test_transform(self): + """Test transform method.""" + signal = tf.random.normal([4, 4]) + result = self.linop2.transform(signal) + self.assertAllClose(result, np.diff(signal, axis=-2)) + + def test_matvec(self): + """Test matvec method.""" + signal = tf.constant([1, 2, 4, 8], dtype=tf.float32) + result = tf.linalg.matvec(self.linop1, signal) + self.assertAllClose(result, [1, 2, 4]) + self.assertAllClose(result, np.diff(signal)) + self.assertAllClose(result, tf.linalg.matvec(self.matrix1, signal)) + + signal2 = tf.range(16, dtype=tf.float32) + result = tf.linalg.matvec(self.linop2, signal2) + self.assertAllClose(result, [4] * 12) + + def test_matvec_adjoint(self): + """Test matvec with adjoint.""" + signal = tf.constant([1, 2, 4], dtype=tf.float32) + result = tf.linalg.matvec(self.linop1, signal, adjoint_a=True) + self.assertAllClose(result, + tf.linalg.matvec(tf.transpose(self.matrix1), signal)) + + def test_shapes(self): + """Test shapes.""" + self._test_all_shapes(self.linop1, [4], [3]) + self._test_all_shapes(self.linop2, [4, 4], [3, 4]) + + def _test_all_shapes(self, linop, domain_shape, range_shape): + """Test shapes.""" + self.assertIsInstance(linop.domain_shape, tf.TensorShape) + self.assertAllEqual(linop.domain_shape, domain_shape) + self.assertAllEqual(linop.domain_shape_tensor(), domain_shape) + + self.assertIsInstance(linop.range_shape, tf.TensorShape) + self.assertAllEqual(linop.range_shape, range_shape) + self.assertAllEqual(linop.range_shape_tensor(), range_shape) + + +if __name__ == '__main__': + tf.test.main() diff --git a/tensorflow_mri/python/linalg/linear_operator_gram_matrix.py b/tensorflow_mri/python/linalg/linear_operator_gram_matrix.py new file mode 100644 index 00000000..552e003b --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_gram_matrix.py @@ -0,0 +1,147 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Gram matrix of a linear operator.""" + +import tensorflow as tf + +from tensorflow_mri.python.linalg import linear_operator +from tensorflow_mri.python.linalg import linear_operator_addition +from tensorflow_mri.python.linalg import linear_operator_composition +from tensorflow_mri.python.linalg import linear_operator_scaled_identity +from tensorflow_mri.python.util import api_util + + +@api_util.export("linalg.LinearOperatorGramMatrix") +class LinearOperatorGramMatrix(linear_operator.LinearOperator): # pylint: disable=abstract-method + r"""Linear operator representing the Gram matrix of an operator. + + If :math:`A` is a `LinearOperator`, this operator is equivalent to + :math:`A^H A`. + + The Gram matrix of :math:`A` appears in the normal equation + :math:`A^H A x = A^H b` associated with the least squares problem + :math:`{\mathop{\mathrm{argmin}}_x} {\left \| Ax-b \right \|_2^2}`. + + This operator is self-adjoint and positive definite. Therefore, linear systems + defined by this linear operator can be solved using the conjugate gradient + method. + + This operator supports the optional addition of a regularization parameter + :math:`\lambda` and a transform matrix :math:`T`. If these are provided, + this operator becomes :math:`A^H A + \lambda T^H T`. This appears + in the regularized normal equation + :math:`\left ( A^H A + \lambda T^H T \right ) x = A^H b + \lambda T^H T x_0`, + associated with the regularized least squares problem + :math:`{\mathop{\mathrm{argmin}}_x} {\left \| Ax-b \right \|_2^2 + \lambda \left \| T(x-x_0) \right \|_2^2}`. + + Args: + operator: A `tfmri.linalg.LinearOperator`. The operator :math:`A` whose Gram + matrix is represented by this linear operator. + reg_parameter: A `Tensor` of shape `[B1, ..., Bb]` and real dtype. + The regularization parameter :math:`\lambda`. Defaults to 0. + reg_operator: A `tfmri.linalg.LinearOperator`. The regularization transform + :math:`T`. Defaults to the identity. + gram_operator: A `tfmri.linalg.LinearOperator`. The Gram matrix + :math:`A^H A`. This may be optionally provided to use a specialized + Gram matrix implementation. Defaults to `None`. + is_non_singular: Expect that this operator is non-singular. + is_self_adjoint: Expect that this operator is equal to its Hermitian + transpose. + is_positive_definite: Expect that this operator is positive definite, + meaning the quadratic form :math:`x^H A x` has positive real part for all + nonzero :math:`x`. Note that we do not require the operator to be + self-adjoint to be positive-definite. + is_square: Expect that this operator acts like square [batch] matrices. + name: A name for this `LinearOperator`. + """ + def __init__(self, + operator, + reg_parameter=None, + reg_operator=None, + gram_operator=None, + is_non_singular=None, + is_self_adjoint=True, + is_positive_definite=True, + is_square=True, + name=None): + parameters = dict( + operator=operator, + reg_parameter=reg_parameter, + reg_operator=reg_operator, + is_non_singular=is_non_singular, + is_self_adjoint=is_self_adjoint, + is_positive_definite=is_positive_definite, + is_square=is_square, + name=name) + self._operator = operator + self._reg_parameter = reg_parameter + self._reg_operator = reg_operator + self._gram_operator = gram_operator + if gram_operator is not None: + self._composed = gram_operator + else: + self._composed = linear_operator_composition.LinearOperatorComposition( + operators=[self._operator.H, self._operator]) + + if not is_self_adjoint: + raise ValueError("A Gram matrix is always self-adjoint.") + if not is_positive_definite: + raise ValueError("A Gram matrix is always positive-definite.") + if not is_square: + raise ValueError("A Gram matrix is always square.") + + if self._reg_parameter is not None: + reg_operator_gm = linear_operator_scaled_identity.LinearOperatorScaledIdentity( + shape=self._operator.domain_shape, + multiplier=tf.cast(self._reg_parameter, self._operator.dtype)) + if self._reg_operator is not None: + reg_operator_gm = linear_operator_composition.LinearOperatorComposition( + operators=[reg_operator_gm, + self._reg_operator.H, + self._reg_operator]) + self._composed = linear_operator_addition.LinearOperatorAddition( + operators=[self._composed, reg_operator_gm]) + + super().__init__(operator.dtype, + is_non_singular=is_non_singular, + is_self_adjoint=is_self_adjoint, + is_positive_definite=is_positive_definite, + is_square=is_square, + parameters=parameters) + + def _transform(self, x, adjoint=False): + return self._composed.transform(x, adjoint=adjoint) + + def _domain_shape(self): + return self.operator.domain_shape + + def _range_shape(self): + return self.operator.domain_shape + + def _batch_shape(self): + return self.operator.batch_shape + + def _domain_shape_tensor(self): + return self.operator.domain_shape_tensor() + + def _range_shape_tensor(self): + return self.operator.domain_shape_tensor() + + def _batch_shape_tensor(self): + return self.operator.batch_shape_tensor() + + @property + def operator(self): + return self._operator diff --git a/tensorflow_mri/python/linalg/linear_operator_gram_matrix_test.py b/tensorflow_mri/python/linalg/linear_operator_gram_matrix_test.py new file mode 100644 index 00000000..d03f5ef6 --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_gram_matrix_test.py @@ -0,0 +1,15 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Tests for module `linear_operator_gram_matrix`.""" diff --git a/tensorflow_mri/python/linalg/linear_operator_gram_mri.py b/tensorflow_mri/python/linalg/linear_operator_gram_mri.py new file mode 100644 index 00000000..ca99548d --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_gram_mri.py @@ -0,0 +1,144 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Linear algebra operations. + +This module contains linear operators and solvers. +""" + +import collections + +import tensorflow as tf + +from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.linalg import linear_operator_gram_nufft +from tensorflow_mri.python.linalg import linear_operator_mri + + +@api_util.export("linalg.LinearOperatorGramMRI") +class LinearOperatorGramMRI(linear_operator_mri.LinearOperatorMRI): # pylint: disable=abstract-method + """Linear operator representing an MRI encoding matrix. + + If :math:`A` is a `tfmri.linalg.LinearOperatorMRI`, then this ooperator + represents the matrix :math:`G = A^H A`. + + In certain circumstances, this operator may be able to apply the matrix + :math:`G` more efficiently than the composition :math:`G = A^H A` using + `tfmri.linalg.LinearOperatorMRI` objects. + + Args: + image_shape: A `tf.TensorShape` or a list of `ints`. The shape of the images + that this operator acts on. Must have length 2 or 3. + extra_shape: An optional `tf.TensorShape` or list of `ints`. Additional + dimensions that should be included within the operator domain. Note that + `extra_shape` is not needed to reconstruct independent batches of images. + However, it is useful when this operator is used as part of a + reconstruction that performs computation along non-spatial dimensions, + e.g. for temporal regularization. Defaults to `None`. + mask: An optional `tf.Tensor` of type `tf.bool`. The sampling mask. Must + have shape `[..., *S]`, where `S` is the `image_shape` and `...` is + the batch shape, which can have any number of dimensions. If `mask` is + passed, this operator represents an undersampled MRI operator. + trajectory: An optional `tf.Tensor` of type `float32` or `float64`. Must + have shape `[..., M, N]`, where `N` is the rank (number of spatial + dimensions), `M` is the number of samples in the encoded space and `...` + is the batch shape, which can have any number of dimensions. If + `trajectory` is passed, this operator represents a non-Cartesian MRI + operator. + density: An optional `tf.Tensor` of type `float32` or `float64`. The + sampling densities. Must have shape `[..., M]`, where `M` is the number of + samples and `...` is the batch shape, which can have any number of + dimensions. This input is only relevant for non-Cartesian MRI operators. + If passed, the non-Cartesian operator will include sampling density + compensation. If `None`, the operator will not perform sampling density + compensation. + sensitivities: An optional `tf.Tensor` of type `complex64` or `complex128`. + The coil sensitivity maps. Must have shape `[..., C, *S]`, where `S` + is the `image_shape`, `C` is the number of coils and `...` is the batch + shape, which can have any number of dimensions. + phase: An optional `tf.Tensor` of type `float32` or `float64`. A phase + estimate for the image. If provided, this operator will be + phase-constrained. + fft_norm: FFT normalization mode. Must be `None` (no normalization) + or `'ortho'`. Defaults to `'ortho'`. + sens_norm: A `boolean`. Whether to normalize coil sensitivities. Defaults to + `True`. + dynamic_domain: A `str`. The domain of the dynamic dimension, if present. + Must be one of `'time'` or `'frequency'`. May only be provided together + with a non-scalar `extra_shape`. The dynamic dimension is the last + dimension of `extra_shape`. The `'time'` mode (default) should be + used for regular dynamic reconstruction. The `'frequency'` mode should be + used for reconstruction in x-f space. + toeplitz_nufft: A `boolean`. If `True`, uses the Toeplitz approach [5] + to compute :math:`F^H F x`, where :math:`F` is the non-uniform Fourier + operator. If `False`, the same operation is performed using the standard + NUFFT operation. The Toeplitz approach might be faster than the direct + approach but is slightly less accurate. This argument is only relevant + for non-Cartesian reconstruction and will be ignored for Cartesian + problems. + dtype: A `tf.dtypes.DType`. The dtype of this operator. Must be `complex64` + or `complex128`. Defaults to `complex64`. + name: An optional `str`. The name of this operator. + """ + def __init__(self, + image_shape, + extra_shape=None, + mask=None, + trajectory=None, + density=None, + sensitivities=None, + phase=None, + fft_norm='ortho', + sens_norm=True, + dynamic_domain=None, + toeplitz_nufft=False, + dtype=tf.complex64, + name="LinearOperatorGramMRI"): + super().__init__( + image_shape, + extra_shape=extra_shape, + mask=mask, + trajectory=trajectory, + density=density, + sensitivities=sensitivities, + phase=phase, + fft_norm=fft_norm, + sens_norm=sens_norm, + dynamic_domain=dynamic_domain, + dtype=dtype, + name=name + ) + + self.toeplitz_nufft = toeplitz_nufft + if self.toeplitz_nufft and self.is_non_cartesian: + # Create a Gram NUFFT operator with Toeplitz embedding. + self._linop_gram_nufft = linear_operator_gram_nufft.LinearOperatorGramNUFFT( + image_shape, trajectory=self._trajectory, density=self._density, + norm=fft_norm, toeplitz=True) + # Disable NUFFT computation on base class. The NUFFT will instead be + # performed by the Gram NUFFT operator. + self._skip_nufft = True + + def _transform(self, x, adjoint=False): + x = super()._transform(x) + if self.toeplitz_nufft: + x = self._linop_gram_nufft.transform(x) + x = super()._transform(x, adjoint=True) + return x + + def _range_shape(self): + return self._domain_shape() + + def _range_shape_tensor(self): + return self._domain_shape_tensor() diff --git a/tensorflow_mri/python/linalg/linear_operator_gram_mri_test.py b/tensorflow_mri/python/linalg/linear_operator_gram_mri_test.py new file mode 100755 index 00000000..da93a00b --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_gram_mri_test.py @@ -0,0 +1,76 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Tests for module `linear_operator_gram_mri`.""" +# pylint: disable=missing-class-docstring,missing-function-docstring + +from absl.testing import parameterized +import tensorflow as tf + +from tensorflow_mri.python.linalg import linear_operator_gram_mri +from tensorflow_mri.python.ops import image_ops +from tensorflow_mri.python.ops import traj_ops +from tensorflow_mri.python.util import test_util + + +class LinearOperatorGramMRITest(test_util.TestCase): + @parameterized.product(batch=[False, True], extra=[False, True], + toeplitz_nufft=[False, True]) + def test_general(self, batch, extra, toeplitz_nufft): + resolution = 128 + image_shape = [resolution, resolution] + num_coils = 4 + image, sensitivities = image_ops.phantom( + shape=image_shape, num_coils=num_coils, dtype=tf.complex64, + return_sensitivities=True) + image = image_ops.phantom(shape=image_shape, dtype=tf.complex64) + trajectory = traj_ops.radial_trajectory(resolution, resolution // 2 + 1, + flatten_encoding_dims=True) + density = traj_ops.radial_density(resolution, resolution // 2 + 1, + flatten_encoding_dims=True) + if batch: + image = tf.stack([image, image * 2]) + if extra: + extra_shape = [2] + else: + extra_shape = None + else: + extra_shape = None + + linop = linear_operator_gram_mri.LinearOperatorMRI( + image_shape, extra_shape=extra_shape, + trajectory=trajectory, density=density, + sensitivities=sensitivities) + linop_gram = linear_operator_gram_mri.LinearOperatorGramMRI( + image_shape, extra_shape=extra_shape, + trajectory=trajectory, density=density, + sensitivities=sensitivities, toeplitz_nufft=toeplitz_nufft) + + # Test shapes. + expected_domain_shape = image_shape + if extra_shape is not None: + expected_domain_shape = extra_shape + image_shape + self.assertAllClose(expected_domain_shape, linop_gram.domain_shape) + self.assertAllClose(expected_domain_shape, linop_gram.domain_shape_tensor()) + self.assertAllClose(expected_domain_shape, linop_gram.range_shape) + self.assertAllClose(expected_domain_shape, linop_gram.range_shape_tensor()) + + # Test transform. + expected = linop.transform(linop.transform(image), adjoint=True) + self.assertAllClose(expected, linop_gram.transform(image), + rtol=1e-4, atol=1e-4) + + +if __name__ == '__main__': + tf.test.main() diff --git a/tensorflow_mri/python/linalg/linear_operator_gram_nufft.py b/tensorflow_mri/python/linalg/linear_operator_gram_nufft.py new file mode 100644 index 00000000..4da917dd --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_gram_nufft.py @@ -0,0 +1,259 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Gram matrix of an NUFFT linear operator.""" + +import tensorflow as tf + +from tensorflow_mri.python.ops import array_ops +from tensorflow_mri.python.ops import fft_ops +from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.linalg import linear_operator_nufft + + +@api_util.export("linalg.LinearOperatorGramNUFFT") +class LinearOperatorGramNUFFT(linear_operator_nufft.LinearOperatorNUFFT): # pylint: disable=abstract-method + """Linear operator acting like the Gram matrix of an NUFFT operator. + + If :math:`F` is a `tfmri.linalg.LinearOperatorNUFFT`, then this operator + applies :math:`F^H F`. This operator is self-adjoint. + + Args: + domain_shape: A 1D integer `tf.Tensor`. The domain shape of this + operator. This is usually the shape of the image but may include + additional dimensions. + trajectory: A `tf.Tensor` of type `float32` or `float64`. Contains the + sampling locations or *k*-space trajectory. Must have shape + `[..., M, N]`, where `N` is the rank (number of dimensions), `M` is + the number of samples and `...` is the batch shape, which can have any + number of dimensions. + density: A `tf.Tensor` of type `float32` or `float64`. Contains the + sampling density at each point in `trajectory`. Must have shape + `[..., M]`, where `M` is the number of samples and `...` is the batch + shape, which can have any number of dimensions. Defaults to `None`, in + which case the density is assumed to be 1.0 in all locations. + norm: A `str`. The FFT normalization mode. Must be `None` (no normalization) + or `'ortho'`. + toeplitz: A `boolean`. If `True`, uses the Toeplitz approach [1] + to compute :math:`F^H F x`, where :math:`F` is the NUFFT operator. + If `False`, the same operation is performed using the standard + NUFFT operation. The Toeplitz approach might be faster than the direct + approach but is slightly less accurate. This argument is only relevant + for non-Cartesian reconstruction and will be ignored for Cartesian + problems. + name: An optional `str`. The name of this operator. + + References: + [1] Fessler, J. A., Lee, S., Olafsson, V. T., Shi, H. R., & Noll, D. C. + (2005). Toeplitz-based iterative image reconstruction for MRI with + correction for magnetic field inhomogeneity. IEEE Transactions on Signal + Processing, 53(9), 3393-3402. + """ + def __init__(self, + domain_shape, + trajectory, + density=None, + norm='ortho', + toeplitz=False, + name="LinearOperatorNUFFT"): + super().__init__( + domain_shape=domain_shape, + trajectory=trajectory, + density=density, + norm=norm, + name=name + ) + + self.toeplitz = toeplitz + if self.toeplitz: + # Compute the FFT shift for adjoint NUFFT computation. + self._fft_shift = tf.cast(self._grid_shape // 2, self.dtype.real_dtype) + # Compute the Toeplitz kernel. + self._toeplitz_kernel = self._compute_toeplitz_kernel() + # Kernel shape (without batch dimensions). + self._kernel_shape = tf.shape(self._toeplitz_kernel)[-self.rank_tensor():] + + def _transform(self, x, adjoint=False): # pylint: disable=unused-argument + """Applies this linear operator.""" + # This operator is self-adjoint, so `adjoint` arg is unused. + if self.toeplitz: + # Using specialized Toeplitz implementation. + return self._transform_toeplitz(x) + # Using standard NUFFT implementation. + return super()._transform(super()._transform(x), adjoint=True) + + def _transform_toeplitz(self, x): + """Applies this linear operator using the Toeplitz approach.""" + input_shape = tf.shape(x) + fft_axes = tf.range(-self.rank_tensor(), 0) + x = fft_ops.fftn(x, axes=fft_axes, shape=self._kernel_shape) + x *= self._toeplitz_kernel + x = fft_ops.ifftn(x, axes=fft_axes) + x = tf.slice(x, tf.zeros([tf.rank(x)], dtype=tf.int32), input_shape) + return x + + def _compute_toeplitz_kernel(self): + """Computes the kernel for the Toeplitz approach.""" + trajectory = self.trajectory + weights = self.weights + if self.rank is None: + raise NotImplementedError( + f"The rank of {self.name} must be known statically.") + + if weights is None: + # If no weights were passed, use ones. + weights = tf.ones(tf.shape(trajectory)[:-1], dtype=self.dtype.real_dtype) + # Cast weights to complex dtype. + weights = tf.cast(tf.math.sqrt(weights), self.dtype) + + # Compute N-D kernel recursively. Begin with last axis. + last_axis = self.rank - 1 + kernel = self._compute_kernel_recursive(trajectory, weights, last_axis) + + # Make sure that the kernel is symmetric/Hermitian/self-adjoint. + kernel = self._enforce_kernel_symmetry(kernel) + + # Additional normalization by sqrt(2 ** rank). This is required because + # we are using FFTs with twice the length of the original image. + if self.norm == 'ortho': + kernel *= tf.cast(tf.math.sqrt(2.0 ** self.rank), kernel.dtype) + + # Put the kernel in Fourier space. + fft_axes = list(range(-self.rank, 0)) + fft_norm = self.norm or "backward" + return fft_ops.fftn(kernel, axes=fft_axes, norm=fft_norm) + + def _compute_kernel_recursive(self, trajectory, weights, axis): + """Recursively computes the kernel for the Toeplitz approach. + + This function works by computing the two halves of the kernel along each + axis. The "left" half is computed using the input trajectory. The "right" + half is computed using the trajectory flipped along the current axis, and + then reversed. Then the two halves are concatenated, with a block of zeros + inserted in between. If there is more than one axis, the process is repeated + recursively for each axis. + + This function calls the adjoint NUFFT 2 ** N times, where N is the number + of dimensions. NOTE: this could be optimized to 2 ** (N - 1) calls. + + Args: + trajectory: A `tf.Tensor` containing the current *k*-space trajectory. + weights: A `tf.Tensor` containing the current density compensation + weights. + axis: An `int` denoting the current axis. + + Returns: + A `tf.Tensor` containing the kernel. + + Raises: + NotImplementedError: If the rank of the operator is not known statically. + """ + # Account for the batch dimensions. We do not need to do the recursion + # for these. + batch_dims = self.batch_shape.rank + if batch_dims is None: + raise NotImplementedError( + f"The number of batch dimensions of {self.name} must be known " + f"statically.") + # The current axis without the batch dimensions. + image_axis = axis + batch_dims + if axis == 0: + # Outer-most axis. Compute left half, then use Hermitian symmetry to + # compute right half. + # TODO(jmontalt): there should be a way to compute the NUFFT only once. + kernel_left = self._nufft_adjoint(weights, trajectory) + flippings = tf.tensor_scatter_nd_update( + tf.ones([self.rank_tensor()]), [[axis]], [-1]) + kernel_right = self._nufft_adjoint(weights, trajectory * flippings) + else: + # We still have two or more axes to process. Compute left and right kernels + # by calling this function recursively. We call ourselves twice, first + # with current frequencies, then with negated frequencies along current + # axes. + kernel_left = self._compute_kernel_recursive( + trajectory, weights, axis - 1) + flippings = tf.tensor_scatter_nd_update( + tf.ones([self.rank_tensor()]), [[axis]], [-1]) + kernel_right = self._compute_kernel_recursive( + trajectory * flippings, weights, axis - 1) + + # Remove zero frequency and reverse. + kernel_right = tf.reverse(array_ops.slice_along_axis( + kernel_right, image_axis, 1, tf.shape(kernel_right)[image_axis] - 1), + [image_axis]) + + # Create block of zeros to be inserted between the left and right halves of + # the kernel. + zeros_shape = tf.concat([ + tf.shape(kernel_left)[:image_axis], [1], + tf.shape(kernel_left)[(image_axis + 1):]], 0) + zeros = tf.zeros(zeros_shape, dtype=kernel_left.dtype) + + # Concatenate the left and right halves of kernel, with a block of zeros in + # the middle. + kernel = tf.concat([kernel_left, zeros, kernel_right], image_axis) + return kernel + + def _nufft_adjoint(self, x, trajectory=None): + """Applies the adjoint NUFFT operator. + + We use this instead of `super()._transform(x, adjoint=True)` because we + need to be able to change the trajectory and to apply an FFT shift. + + Args: + x: A `tf.Tensor` containing the input data (typically the weights or + ones). + trajectory: A `tf.Tensor` containing the *k*-space trajectory, which + may have been flipped and therefore different from the original. If + `None`, the original trajectory is used. + + Returns: + A `tf.Tensor` containing the result of the adjoint NUFFT. + """ + # Apply FFT shift. + x *= tf.math.exp(tf.dtypes.complex( + tf.constant(0, dtype=self.dtype.real_dtype), + tf.math.reduce_sum(trajectory * self._fft_shift, -1))) + # Temporarily update trajectory. + if trajectory is not None: + temp = self.trajectory + self.trajectory = trajectory + x = super()._transform(x, adjoint=True) + if trajectory is not None: + self.trajectory = temp + return x + + def _enforce_kernel_symmetry(self, kernel): + """Enforces Hermitian symmetry on an input kernel. + + Args: + kernel: A `tf.Tensor`. An approximately Hermitian kernel. + + Returns: + A Hermitian-symmetric kernel. + """ + kernel_axes = list(range(-self.rank, 0)) + reversed_kernel = tf.roll( + tf.reverse(kernel, kernel_axes), + shift=tf.ones([tf.size(kernel_axes)], dtype=tf.int32), + axis=kernel_axes) + return (kernel + tf.math.conj(reversed_kernel)) / 2 + + def _range_shape(self): + # Override the NUFFT operator's range shape. The range shape for this + # operator is the same as the domain shape. + return self._domain_shape() + + def _range_shape_tensor(self): + return self._domain_shape_tensor() diff --git a/tensorflow_mri/python/linalg/linear_operator_gram_nufft_test.py b/tensorflow_mri/python/linalg/linear_operator_gram_nufft_test.py new file mode 100755 index 00000000..0fc91b84 --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_gram_nufft_test.py @@ -0,0 +1,75 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Tests for module `linalg_ops`.""" +# pylint: disable=missing-class-docstring,missing-function-docstring + +from absl.testing import parameterized +import numpy as np +import tensorflow as tf + +from tensorflow_mri.python.ops import geom_ops +from tensorflow_mri.python.ops import image_ops +from tensorflow_mri.python.ops import linalg_ops +from tensorflow_mri.python.ops import traj_ops +from tensorflow_mri.python.util import test_util + + +class LinearOperatorGramNUFFTTest(test_util.TestCase): + @parameterized.product( + density=[False, True], + norm=[None, 'ortho'], + toeplitz=[False, True], + batch=[False, True] + ) + def test_general(self, density, norm, toeplitz, batch): + with tf.device('/cpu:0'): + image_shape = (128, 128) + image = image_ops.phantom(shape=image_shape, dtype=tf.complex64) + trajectory = traj_ops.radial_trajectory( + 128, 129, flatten_encoding_dims=True) + if density is True: + density = traj_ops.radial_density( + 128, 129, flatten_encoding_dims=True) + else: + density = None + + # If testing batches, create new inputs to generate a batch. + if batch: + image = tf.stack([image, image * 0.5]) + trajectory = tf.stack([ + trajectory, geom_ops.rotate_2d(trajectory, [np.pi / 2])]) + if density is not None: + density = tf.stack([density, density]) + + linop = linalg_ops.LinearOperatorNUFFT( + image_shape, trajectory=trajectory, density=density, norm=norm) + linop_gram = linalg_ops.LinearOperatorGramNUFFT( + image_shape, trajectory=trajectory, density=density, norm=norm, + toeplitz=toeplitz) + + recon = linop.transform(linop.transform(image), adjoint=True) + recon_gram = linop_gram.transform(image) + + if norm is None: + # Reduce the magnitude of these values to avoid the need to use a large + # tolerance. + recon /= tf.cast(tf.math.reduce_prod(image_shape), tf.complex64) + recon_gram /= tf.cast(tf.math.reduce_prod(image_shape), tf.complex64) + + self.assertAllClose(recon, recon_gram, rtol=1e-4, atol=1e-4) + + +if __name__ == '__main__': + tf.test.main() diff --git a/tensorflow_mri/python/linalg/linear_operator_mri.py b/tensorflow_mri/python/linalg/linear_operator_mri.py new file mode 100644 index 00000000..d77d91f2 --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_mri.py @@ -0,0 +1,466 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""MRI linear operator.""" + +import tensorflow as tf + +from tensorflow_mri.python.ops import fft_ops +from tensorflow_mri.python.ops import math_ops +from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.util import check_util +from tensorflow_mri.python.linalg import linear_operator +from tensorflow_mri.python.util import tensor_util + + +@api_util.export("linalg.LinearOperatorMRI") +class LinearOperatorMRI(linear_operator.LinearOperator): # pylint: disable=abstract-method + """Linear operator representing an MRI encoding matrix. + + The MRI operator, :math:`A`, maps a [batch of] images, :math:`x` to a + [batch of] measurement data (*k*-space), :math:`b`. + + .. math:: + A x = b + + This object may represent an undersampled MRI operator and supports + Cartesian and non-Cartesian *k*-space sampling. The user may provide a + sampling `mask` to represent an undersampled Cartesian operator, or a + `trajectory` to represent a non-Cartesian operator. + + This object may represent a multicoil MRI operator by providing coil + `sensitivities`. Note that `mask`, `trajectory` and `density` should never + have a coil dimension, including in the case of multicoil imaging. The coil + dimension will be handled automatically. + + The domain shape of this operator is `extra_shape + image_shape`. The range + of this operator is `extra_shape + [num_coils] + image_shape`, for + Cartesian imaging, or `extra_shape + [num_coils] + [num_samples]`, for + non-Cartesian imaging. `[num_coils]` is optional and only present for + multicoil operators. This operator supports batches of images and will + vectorize operations when possible. + + Args: + image_shape: A `tf.TensorShape` or a list of `ints`. The shape of the images + that this operator acts on. Must have length 2 or 3. + extra_shape: An optional `tf.TensorShape` or list of `ints`. Additional + dimensions that should be included within the operator domain. Note that + `extra_shape` is not needed to reconstruct independent batches of images. + However, it is useful when this operator is used as part of a + reconstruction that performs computation along non-spatial dimensions, + e.g. for temporal regularization. Defaults to `None`. + mask: An optional `tf.Tensor` of type `tf.bool`. The sampling mask. Must + have shape `[..., *S]`, where `S` is the `image_shape` and `...` is + the batch shape, which can have any number of dimensions. If `mask` is + passed, this operator represents an undersampled MRI operator. + trajectory: An optional `tf.Tensor` of type `float32` or `float64`. Must + have shape `[..., M, N]`, where `N` is the rank (number of spatial + dimensions), `M` is the number of samples in the encoded space and `...` + is the batch shape, which can have any number of dimensions. If + `trajectory` is passed, this operator represents a non-Cartesian MRI + operator. + density: An optional `tf.Tensor` of type `float32` or `float64`. The + sampling densities. Must have shape `[..., M]`, where `M` is the number of + samples and `...` is the batch shape, which can have any number of + dimensions. This input is only relevant for non-Cartesian MRI operators. + If passed, the non-Cartesian operator will include sampling density + compensation. If `None`, the operator will not perform sampling density + compensation. + sensitivities: An optional `tf.Tensor` of type `complex64` or `complex128`. + The coil sensitivity maps. Must have shape `[..., C, *S]`, where `S` + is the `image_shape`, `C` is the number of coils and `...` is the batch + shape, which can have any number of dimensions. + phase: An optional `tf.Tensor` of type `float32` or `float64`. A phase + estimate for the image. If provided, this operator will be + phase-constrained. + fft_norm: FFT normalization mode. Must be `None` (no normalization) + or `'ortho'`. Defaults to `'ortho'`. + sens_norm: A `boolean`. Whether to normalize coil sensitivities. Defaults to + `True`. + dynamic_domain: A `str`. The domain of the dynamic dimension, if present. + Must be one of `'time'` or `'frequency'`. May only be provided together + with a non-scalar `extra_shape`. The dynamic dimension is the last + dimension of `extra_shape`. The `'time'` mode (default) should be + used for regular dynamic reconstruction. The `'frequency'` mode should be + used for reconstruction in x-f space. + dtype: A `tf.dtypes.DType`. The dtype of this operator. Must be `complex64` + or `complex128`. Defaults to `complex64`. + name: An optional `str`. The name of this operator. + """ + def __init__(self, + image_shape, + extra_shape=None, + mask=None, + trajectory=None, + density=None, + sensitivities=None, + phase=None, + fft_norm='ortho', + sens_norm=True, + dynamic_domain=None, + dtype=tf.complex64, + name=None): + # pylint: disable=invalid-unary-operand-type + parameters = dict( + image_shape=image_shape, + extra_shape=extra_shape, + mask=mask, + trajectory=trajectory, + density=density, + sensitivities=sensitivities, + phase=phase, + fft_norm=fft_norm, + sens_norm=sens_norm, + dynamic_domain=dynamic_domain, + dtype=dtype, + name=name) + + # Set dtype. + dtype = tf.as_dtype(dtype) + if dtype not in (tf.complex64, tf.complex128): + raise ValueError( + f"`dtype` must be `complex64` or `complex128`, but got: {str(dtype)}") + + # Set image shape, rank and extra shape. + image_shape = tf.TensorShape(image_shape) + rank = image_shape.rank + if rank not in (2, 3): + raise ValueError( + f"Rank must be 2 or 3, but got: {rank}") + if not image_shape.is_fully_defined(): + raise ValueError( + f"`image_shape` must be fully defined, but got {image_shape}") + self._rank = rank + self._image_shape = image_shape + self._image_axes = list(range(-self._rank, 0)) # pylint: disable=invalid-unary-operand-type + self._extra_shape = tf.TensorShape(extra_shape or []) + + # Set initial batch shape, then update according to inputs. + batch_shape = self._extra_shape + batch_shape_tensor = tensor_util.convert_shape_to_tensor(batch_shape) + + # Set sampling mask after checking dtype and static shape. + if mask is not None: + mask = tf.convert_to_tensor(mask) + if mask.dtype != tf.bool: + raise TypeError( + f"`mask` must have dtype `bool`, but got: {str(mask.dtype)}") + if not mask.shape[-self._rank:].is_compatible_with(self._image_shape): + raise ValueError( + f"Expected the last dimensions of `mask` to be compatible with " + f"{self._image_shape}], but got: {mask.shape[-self._rank:]}") + batch_shape = tf.broadcast_static_shape( + batch_shape, mask.shape[:-self._rank]) + batch_shape_tensor = tf.broadcast_dynamic_shape( + batch_shape_tensor, tf.shape(mask)[:-self._rank]) + self._mask = mask + + # Set sampling trajectory after checking dtype and static shape. + if trajectory is not None: + if mask is not None: + raise ValueError("`mask` and `trajectory` cannot be both passed.") + trajectory = tf.convert_to_tensor(trajectory) + if trajectory.dtype != dtype.real_dtype: + raise TypeError( + f"Expected `trajectory` to have dtype `{str(dtype.real_dtype)}`, " + f"but got: {str(trajectory.dtype)}") + if trajectory.shape[-1] != self._rank: + raise ValueError( + f"Expected the last dimension of `trajectory` to be " + f"{self._rank}, but got {trajectory.shape[-1]}") + batch_shape = tf.broadcast_static_shape( + batch_shape, trajectory.shape[:-2]) + batch_shape_tensor = tf.broadcast_dynamic_shape( + batch_shape_tensor, tf.shape(trajectory)[:-2]) + self._trajectory = trajectory + + # Set sampling density after checking dtype and static shape. + if density is not None: + if self._trajectory is None: + raise ValueError("`density` must be passed with `trajectory`.") + density = tf.convert_to_tensor(density) + if density.dtype != dtype.real_dtype: + raise TypeError( + f"Expected `density` to have dtype `{str(dtype.real_dtype)}`, " + f"but got: {str(density.dtype)}") + if density.shape[-1] != self._trajectory.shape[-2]: + raise ValueError( + f"Expected the last dimension of `density` to be " + f"{self._trajectory.shape[-2]}, but got {density.shape[-1]}") + batch_shape = tf.broadcast_static_shape( + batch_shape, density.shape[:-1]) + batch_shape_tensor = tf.broadcast_dynamic_shape( + batch_shape_tensor, tf.shape(density)[:-1]) + self._density = density + + # Set sensitivity maps after checking dtype and static shape. + if sensitivities is not None: + sensitivities = tf.convert_to_tensor(sensitivities) + if sensitivities.dtype != dtype: + raise TypeError( + f"Expected `sensitivities` to have dtype `{str(dtype)}`, but got: " + f"{str(sensitivities.dtype)}") + if not sensitivities.shape[-self._rank:].is_compatible_with( + self._image_shape): + raise ValueError( + f"Expected the last dimensions of `sensitivities` to be " + f"compatible with {self._image_shape}, but got: " + f"{sensitivities.shape[-self._rank:]}") + batch_shape = tf.broadcast_static_shape( + batch_shape, sensitivities.shape[:-(self._rank + 1)]) + batch_shape_tensor = tf.broadcast_dynamic_shape( + batch_shape_tensor, tf.shape(sensitivities)[:-(self._rank + 1)]) + self._sensitivities = sensitivities + + if phase is not None: + phase = tf.convert_to_tensor(phase) + if phase.dtype != dtype.real_dtype: + raise TypeError( + f"Expected `phase` to have dtype `{str(dtype.real_dtype)}`, " + f"but got: {str(phase.dtype)}") + if not phase.shape[-self._rank:].is_compatible_with( + self._image_shape): + raise ValueError( + f"Expected the last dimensions of `phase` to be " + f"compatible with {self._image_shape}, but got: " + f"{phase.shape[-self._rank:]}") + batch_shape = tf.broadcast_static_shape( + batch_shape, phase.shape[:-self._rank]) + batch_shape_tensor = tf.broadcast_dynamic_shape( + batch_shape_tensor, tf.shape(phase)[:-self._rank]) + self._phase = phase + + # Set batch shapes. + self._batch_shape_value = batch_shape + self._batch_shape_tensor_value = batch_shape_tensor + + # If multicoil, add coil dimension to mask, trajectory and density. + if self._sensitivities is not None: + if self._mask is not None: + self._mask = tf.expand_dims(self._mask, axis=-(self._rank + 1)) + if self._trajectory is not None: + self._trajectory = tf.expand_dims(self._trajectory, axis=-3) + if self._density is not None: + self._density = tf.expand_dims(self._density, axis=-2) + if self._phase is not None: + self._phase = tf.expand_dims(self._phase, axis=-(self._rank + 1)) + + # Save some tensors for later use during computation. + if self._mask is not None: + self._mask_linop_dtype = tf.cast(self._mask, dtype) + if self._density is not None: + self._dens_weights_sqrt = tf.cast( + tf.math.sqrt(tf.math.reciprocal_no_nan(self._density)), dtype) + if self._phase is not None: + self._phase_rotator = tf.math.exp( + tf.complex(tf.constant(0.0, dtype=phase.dtype), phase)) + + # Set normalization. + self._fft_norm = check_util.validate_enum( + fft_norm, {None, 'ortho'}, 'fft_norm') + if self._fft_norm == 'ortho': # Compute normalization factors. + self._fft_norm_factor = tf.math.reciprocal( + tf.math.sqrt(tf.cast(self._image_shape.num_elements(), dtype))) + + # Normalize coil sensitivities. + self._sens_norm = sens_norm + if self._sensitivities is not None and self._sens_norm: + self._sensitivities = math_ops.normalize_no_nan( + self._sensitivities, axis=-(self._rank + 1)) + + # Set dynamic domain. + if dynamic_domain is not None and self._extra_shape.rank == 0: + raise ValueError( + "Argument `dynamic_domain` requires a non-scalar `extra_shape`.") + if dynamic_domain is not None: + self._dynamic_domain = check_util.validate_enum( + dynamic_domain, {'time', 'frequency'}, name='dynamic_domain') + else: + self._dynamic_domain = None + + # This variable is used by `LinearOperatorGramMRI` to disable the NUFFT. + self._skip_nufft = False + + super().__init__(dtype, name=name, parameters=parameters) + + def _transform(self, x, adjoint=False): + """Transform [batch] input `x`. + + Args: + x: A `tf.Tensor` of type `self.dtype` and shape + `[..., *self.domain_shape]` containing images, if `adjoint` is `False`, + or a `tf.Tensor` of type `self.dtype` and shape + `[..., *self.range_shape]` containing *k*-space data, if `adjoint` is + `True`. + adjoint: A `boolean` indicating whether to apply the adjoint of the + operator. + + Returns: + A `tf.Tensor` of type `self.dtype` and shape `[..., *self.range_shape]` + containing *k*-space data, if `adjoint` is `False`, or a `tf.Tensor` of + type `self.dtype` and shape `[..., *self.domain_shape]` containing + images, if `adjoint` is `True`. + """ + if adjoint: + # Apply density compensation. + if self._density is not None and not self._skip_nufft: + x *= self._dens_weights_sqrt + + # Apply adjoint Fourier operator. + if self.is_non_cartesian: # Non-Cartesian imaging, use NUFFT. + if not self._skip_nufft: + x = fft_ops.nufft(x, self._trajectory, + grid_shape=self._image_shape, + transform_type='type_1', + fft_direction='backward') + if self._fft_norm is not None: + x *= self._fft_norm_factor + + else: # Cartesian imaging, use FFT. + if self._mask is not None: + x *= self._mask_linop_dtype # Undersampling. + x = fft_ops.ifftn(x, axes=self._image_axes, + norm=self._fft_norm or 'forward', shift=True) + + # Apply coil combination. + if self.is_multicoil: + x *= tf.math.conj(self._sensitivities) + x = tf.math.reduce_sum(x, axis=-(self._rank + 1)) + + # Maybe remove phase from image. + if self.is_phase_constrained: + x *= tf.math.conj(self._phase_rotator) + x = tf.cast(tf.math.real(x), self.dtype) + + # Apply FFT along dynamic axis, if necessary. + if self.is_dynamic and self.dynamic_domain == 'frequency': + x = fft_ops.fftn(x, axes=[self.dynamic_axis], + norm='ortho', shift=True) + + else: # Forward operator. + + # Apply FFT along dynamic axis, if necessary. + if self.is_dynamic and self.dynamic_domain == 'frequency': + x = fft_ops.ifftn(x, axes=[self.dynamic_axis], + norm='ortho', shift=True) + + # Add phase to real-valued image if reconstruction is phase-constrained. + if self.is_phase_constrained: + x = tf.cast(tf.math.real(x), self.dtype) + x *= self._phase_rotator + + # Apply sensitivity modulation. + if self.is_multicoil: + x = tf.expand_dims(x, axis=-(self._rank + 1)) + x *= self._sensitivities + + # Apply Fourier operator. + if self.is_non_cartesian: # Non-Cartesian imaging, use NUFFT. + if not self._skip_nufft: + x = fft_ops.nufft(x, self._trajectory, + transform_type='type_2', + fft_direction='forward') + if self._fft_norm is not None: + x *= self._fft_norm_factor + + else: # Cartesian imaging, use FFT. + x = fft_ops.fftn(x, axes=self._image_axes, + norm=self._fft_norm or 'backward', shift=True) + if self._mask is not None: + x *= self._mask_linop_dtype # Undersampling. + + # Apply density compensation. + if self._density is not None and not self._skip_nufft: + x *= self._dens_weights_sqrt + + return x + + def _domain_shape(self): + """Returns the shape of the domain space of this operator.""" + return self._extra_shape.concatenate(self._image_shape) + + def _range_shape(self): + """Returns the shape of the range space of this operator.""" + if self.is_cartesian: + range_shape = self._image_shape.as_list() + else: + range_shape = [self._trajectory.shape[-2]] + if self.is_multicoil: + range_shape = [self.num_coils] + range_shape + return self._extra_shape.concatenate(range_shape) + + def _batch_shape(self): + """Returns the static batch shape of this operator.""" + return self._batch_shape_value[:-self._extra_shape.rank or None] # pylint: disable=invalid-unary-operand-type + + def _batch_shape_tensor(self): + """Returns the dynamic batch shape of this operator.""" + return self._batch_shape_tensor_value[:-self._extra_shape.rank or None] # pylint: disable=invalid-unary-operand-type + + @property + def image_shape(self): + """The image shape.""" + return self._image_shape + + @property + def rank(self): + """The number of spatial dimensions.""" + return self._rank + + @property + def is_cartesian(self): + """Whether this is a Cartesian MRI operator.""" + return self._trajectory is None + + @property + def is_non_cartesian(self): + """Whether this is a non-Cartesian MRI operator.""" + return self._trajectory is not None + + @property + def is_multicoil(self): + """Whether this is a multicoil MRI operator.""" + return self._sensitivities is not None + + @property + def is_phase_constrained(self): + """Whether this is a phase-constrained MRI operator.""" + return self._phase is not None + + @property + def is_dynamic(self): + """Whether this is a dynamic MRI operator.""" + return self._dynamic_domain is not None + + @property + def dynamic_domain(self): + """The dynamic domain of this operator.""" + return self._dynamic_domain + + @property + def dynamic_axis(self): + """The dynamic axis of this operator.""" + return -(self._rank + 1) if self.is_dynamic else None + + @property + def num_coils(self): + """The number of coils.""" + if self._sensitivities is None: + return None + return self._sensitivities.shape[-(self._rank + 1)] + + @property + def _composite_tensor_fields(self): + return ("image_shape", "mask", "trajectory", "density", "sensitivities", + "fft_norm") diff --git a/tensorflow_mri/python/linalg/linear_operator_mri_test.py b/tensorflow_mri/python/linalg/linear_operator_mri_test.py new file mode 100755 index 00000000..b86d2bd0 --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_mri_test.py @@ -0,0 +1,175 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Tests for module `linear_operator_mri`.""" +# pylint: disable=missing-class-docstring,missing-function-docstring + +import tensorflow as tf + +from tensorflow_mri.python.ops import fft_ops +from tensorflow_mri.python.ops import image_ops +from tensorflow_mri.python.ops import linalg_ops +from tensorflow_mri.python.ops import traj_ops +from tensorflow_mri.python.util import test_util + + +class LinearOperatorMRITest(test_util.TestCase): + """Tests for MRI linear operator.""" + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.linop1 = linalg_ops.LinearOperatorMRI([2, 2], fft_norm=None) + cls.linop2 = linalg_ops.LinearOperatorMRI( + [2, 2], mask=[[False, False], [True, True]], fft_norm=None) + cls.linop3 = linalg_ops.LinearOperatorMRI( + [2, 2], mask=[[[True, True], [False, False]], + [[False, False], [True, True]], + [[False, True], [True, False]]], fft_norm=None) + + def test_fft(self): + """Test FFT operator.""" + # Test init. + linop = linalg_ops.LinearOperatorMRI([2, 2], fft_norm=None) + + # Test matvec. + signal = tf.constant([1, 2, 4, 4], dtype=tf.complex64) + expected = [-1, 5, 1, 11] + result = tf.linalg.matvec(linop, signal) + self.assertAllClose(expected, result) + + # Test domain shape. + self.assertIsInstance(linop.domain_shape, tf.TensorShape) + self.assertAllEqual([2, 2], linop.domain_shape) + self.assertAllEqual([2, 2], linop.domain_shape_tensor()) + + # Test range shape. + self.assertIsInstance(linop.range_shape, tf.TensorShape) + self.assertAllEqual([2, 2], linop.range_shape) + self.assertAllEqual([2, 2], linop.range_shape_tensor()) + + # Test batch shape. + self.assertIsInstance(linop.batch_shape, tf.TensorShape) + self.assertAllEqual([], linop.batch_shape) + self.assertAllEqual([], linop.batch_shape_tensor()) + + def test_fft_with_mask(self): + """Test FFT operator with mask.""" + # Test init. + linop = linalg_ops.LinearOperatorMRI( + [2, 2], mask=[[False, False], [True, True]], fft_norm=None) + + # Test matvec. + signal = tf.constant([1, 2, 4, 4], dtype=tf.complex64) + expected = [0, 0, 1, 11] + result = tf.linalg.matvec(linop, signal) + self.assertAllClose(expected, result) + + # Test domain shape. + self.assertIsInstance(linop.domain_shape, tf.TensorShape) + self.assertAllEqual([2, 2], linop.domain_shape) + self.assertAllEqual([2, 2], linop.domain_shape_tensor()) + + # Test range shape. + self.assertIsInstance(linop.range_shape, tf.TensorShape) + self.assertAllEqual([2, 2], linop.range_shape) + self.assertAllEqual([2, 2], linop.range_shape_tensor()) + + # Test batch shape. + self.assertIsInstance(linop.batch_shape, tf.TensorShape) + self.assertAllEqual([], linop.batch_shape) + self.assertAllEqual([], linop.batch_shape_tensor()) + + def test_fft_with_batch_mask(self): + """Test FFT operator with batch mask.""" + # Test init. + linop = linalg_ops.LinearOperatorMRI( + [2, 2], mask=[[[True, True], [False, False]], + [[False, False], [True, True]], + [[False, True], [True, False]]], fft_norm=None) + + # Test matvec. + signal = tf.constant([1, 2, 4, 4], dtype=tf.complex64) + expected = [[-1, 5, 0, 0], [0, 0, 1, 11], [0, 5, 1, 0]] + result = tf.linalg.matvec(linop, signal) + self.assertAllClose(expected, result) + + # Test domain shape. + self.assertIsInstance(linop.domain_shape, tf.TensorShape) + self.assertAllEqual([2, 2], linop.domain_shape) + self.assertAllEqual([2, 2], linop.domain_shape_tensor()) + + # Test range shape. + self.assertIsInstance(linop.range_shape, tf.TensorShape) + self.assertAllEqual([2, 2], linop.range_shape) + self.assertAllEqual([2, 2], linop.range_shape_tensor()) + + # Test batch shape. + self.assertIsInstance(linop.batch_shape, tf.TensorShape) + self.assertAllEqual([3], linop.batch_shape) + self.assertAllEqual([3], linop.batch_shape_tensor()) + + def test_fft_norm(self): + """Test FFT normalization.""" + linop = linalg_ops.LinearOperatorMRI([2, 2], fft_norm='ortho') + x = tf.constant([1 + 2j, 2 - 2j, -1 - 6j, 3 + 4j], dtype=tf.complex64) + # With norm='ortho', subsequent application of the operator and its adjoint + # should not scale the input. + y = tf.linalg.matvec(linop.H, tf.linalg.matvec(linop, x)) + self.assertAllClose(x, y) + + def test_nufft_with_sensitivities(self): + resolution = 128 + image_shape = [resolution, resolution] + num_coils = 4 + image, sensitivities = image_ops.phantom( + shape=image_shape, num_coils=num_coils, dtype=tf.complex64, + return_sensitivities=True) + image = image_ops.phantom(shape=image_shape, dtype=tf.complex64) + trajectory = traj_ops.radial_trajectory(resolution, resolution // 2 + 1, + flatten_encoding_dims=True) + density = traj_ops.radial_density(resolution, resolution // 2 + 1, + flatten_encoding_dims=True) + + linop = linalg_ops.LinearOperatorMRI( + image_shape, trajectory=trajectory, density=density, + sensitivities=sensitivities) + + # Test shapes. + expected_domain_shape = image_shape + self.assertAllClose(expected_domain_shape, linop.domain_shape) + self.assertAllClose(expected_domain_shape, linop.domain_shape_tensor()) + expected_range_shape = [num_coils, (2 * resolution) * (resolution // 2 + 1)] + self.assertAllClose(expected_range_shape, linop.range_shape) + self.assertAllClose(expected_range_shape, linop.range_shape_tensor()) + + # Test forward. + weights = tf.cast(tf.math.sqrt(tf.math.reciprocal_no_nan(density)), + tf.complex64) + norm = tf.math.sqrt(tf.cast(tf.math.reduce_prod(image_shape), tf.complex64)) + expected = fft_ops.nufft(image * sensitivities, trajectory) * weights / norm + kspace = linop.transform(image) + self.assertAllClose(expected, kspace) + + # Test adjoint. + expected = tf.math.reduce_sum( + fft_ops.nufft( + kspace * weights, trajectory, grid_shape=image_shape, + transform_type='type_1', fft_direction='backward') / norm * + tf.math.conj(sensitivities), axis=-3) + recon = linop.transform(kspace, adjoint=True) + self.assertAllClose(expected, recon) + + +if __name__ == '__main__': + tf.test.main() diff --git a/tensorflow_mri/python/linalg/linear_operator_nufft.py b/tensorflow_mri/python/linalg/linear_operator_nufft.py new file mode 100644 index 00000000..04dedba9 --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_nufft.py @@ -0,0 +1,253 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Linear algebra operations. + +This module contains linear operators and solvers. +""" + +import tensorflow as tf + +from tensorflow_mri.python.ops import fft_ops +from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.util import check_util +from tensorflow_mri.python.linalg import linear_operator +from tensorflow_mri.python.util import tensor_util + + +@api_util.export("linalg.LinearOperatorNUFFT") +class LinearOperatorNUFFT(linear_operator.LinearOperator): # pylint: disable=abstract-method + """Linear operator acting like a nonuniform DFT matrix. + + Args: + domain_shape: A 1D integer `tf.Tensor`. The domain shape of this + operator. This is usually the shape of the image but may include + additional dimensions. + trajectory: A `tf.Tensor` of type `float32` or `float64`. Contains the + sampling locations or *k*-space trajectory. Must have shape + `[..., M, N]`, where `N` is the rank (number of dimensions), `M` is + the number of samples and `...` is the batch shape, which can have any + number of dimensions. + density: A `tf.Tensor` of type `float32` or `float64`. Contains the + sampling density at each point in `trajectory`. Must have shape + `[..., M]`, where `M` is the number of samples and `...` is the batch + shape, which can have any number of dimensions. Defaults to `None`, in + which case the density is assumed to be 1.0 in all locations. + norm: A `str`. The FFT normalization mode. Must be `None` (no normalization) + or `'ortho'`. + name: An optional `str`. The name of this operator. + + Notes: + In MRI, sampling density compensation is typically performed during the + adjoint transform. However, in order to maintain the validity of the linear + operator, this operator applies the compensation orthogonally, i.e., + it scales the data by the square root of `density` in both forward and + adjoint transforms. If you are using this operator to compute the adjoint + and wish to apply the full compensation, you can do so via the + `precompensate` method. + + >>> import tensorflow as tf + >>> import tensorflow_mri as tfmri + >>> # Create some data. + >>> image_shape = (128, 128) + >>> image = image_ops.phantom(shape=image_shape, dtype=tf.complex64) + >>> trajectory = tfmri.sampling.radial_trajectory( + >>> 128, 128, flatten_encoding_dims=True) + >>> density = tfmri.sampling.radial_density( + >>> 128, 128, flatten_encoding_dims=True) + >>> # Create a NUFFT operator. + >>> linop = tfmri.linalg.LinearOperatorNUFFT( + >>> image_shape, trajectory=trajectory, density=density) + >>> # Create k-space. + >>> kspace = tfmri.signal.nufft(image, trajectory) + >>> # This reconstructs the image applying only partial compensation + >>> # (square root of weights). + >>> image = linop.transform(kspace, adjoint=True) + >>> # This reconstructs the image with full compensation. + >>> image = linop.transform(linop.precompensate(kspace), adjoint=True) + """ + def __init__(self, + domain_shape, + trajectory, + density=None, + norm='ortho', + name="LinearOperatorNUFFT"): + + parameters = dict( + domain_shape=domain_shape, + trajectory=trajectory, + norm=norm, + name=name + ) + + # Get domain shapes. + self._domain_shape_static, self._domain_shape_dynamic = ( + tensor_util.static_and_dynamic_shapes_from_shape(domain_shape)) + + # Validate the remaining inputs. + self.trajectory = check_util.validate_tensor_dtype( + tf.convert_to_tensor(trajectory), 'floating', 'trajectory') + self.norm = check_util.validate_enum(norm, {None, 'ortho'}, 'norm') + + # We infer the operation's rank from the trajectory. + self._rank_static = self.trajectory.shape[-1] + self._rank_dynamic = tf.shape(self.trajectory)[-1] + # The domain rank is >= the operation rank. + domain_rank_static = self._domain_shape_static.rank + domain_rank_dynamic = tf.shape(self._domain_shape_dynamic)[0] + # The difference between this operation's rank and the domain rank is the + # number of extra dims. + extra_dims_static = domain_rank_static - self._rank_static + extra_dims_dynamic = domain_rank_dynamic - self._rank_dynamic + + # The grid shape are the last `rank` dimensions of domain_shape. We don't + # need the static grid shape. + self._grid_shape = self._domain_shape_dynamic[-self._rank_dynamic:] + + # We need to do some work to figure out the batch shapes. This operator + # could have a batch shape, if the trajectory has a batch shape. However, + # we allow the user to include one or more batch dimensions in the domain + # shape, if they so wish. Therefore, not all batch dimensions in the + # trajectory are necessarily part of the batch shape. + + # The total number of dimensions in `trajectory` is equal to + # `batch_dims + extra_dims + 2`. + # Compute the true batch shape (i.e., the batch dimensions that are + # NOT included in the domain shape). + batch_dims_dynamic = tf.rank(self.trajectory) - extra_dims_dynamic - 2 + if (self.trajectory.shape.rank is not None and + extra_dims_static is not None): + # We know the total number of dimensions in `trajectory` and we know + # the number of extra dims, so we can compute the number of batch dims + # statically. + batch_dims_static = self.trajectory.shape.rank - extra_dims_static - 2 + else: + # We are missing at least some information, so the number of batch + # dimensions is unknown. + batch_dims_static = None + + self._batch_shape_dynamic = tf.shape(self.trajectory)[:batch_dims_dynamic] + if batch_dims_static is not None: + self._batch_shape_static = self.trajectory.shape[:batch_dims_static] + else: + self._batch_shape_static = tf.TensorShape(None) + + # Compute the "extra" shape. This shape includes those dimensions which + # are not part of the NUFFT (e.g., they are effectively batch dimensions), + # but which are included in the domain shape rather than in the batch shape. + extra_shape_dynamic = self._domain_shape_dynamic[:-self._rank_dynamic] + if self._rank_static is not None: + extra_shape_static = self._domain_shape_static[:-self._rank_static] + else: + extra_shape_static = tf.TensorShape(None) + + # Check that the "extra" shape in `domain_shape` and `trajectory` are + # compatible for broadcasting. + shape1, shape2 = extra_shape_static, self.trajectory.shape[:-2] + try: + tf.broadcast_static_shape(shape1, shape2) + except ValueError as err: + raise ValueError( + f"The \"batch\" shapes in `domain_shape` and `trajectory` are not " + f"compatible for broadcasting: {shape1} vs {shape2}") from err + + # Compute the range shape. + self._range_shape_dynamic = tf.concat( + [extra_shape_dynamic, tf.shape(self.trajectory)[-2:-1]], 0) + self._range_shape_static = extra_shape_static.concatenate( + self.trajectory.shape[-2:-1]) + + # Statically check that density can be broadcasted with trajectory. + if density is not None: + try: + tf.broadcast_static_shape(self.trajectory.shape[:-1], density.shape) + except ValueError as err: + raise ValueError( + f"The \"batch\" shapes in `trajectory` and `density` are not " + f"compatible for broadcasting: {self.trajectory.shape[:-1]} vs " + f"{density.shape}") from err + self.density = tf.convert_to_tensor(density) + self.weights = tf.math.reciprocal_no_nan(self.density) + self._weights_sqrt = tf.cast( + tf.math.sqrt(self.weights), + tensor_util.get_complex_dtype(self.trajectory.dtype)) + else: + self.density = None + self.weights = None + + super().__init__(tensor_util.get_complex_dtype(self.trajectory.dtype), + is_non_singular=None, + is_self_adjoint=None, + is_positive_definite=None, + is_square=None, + name=name, + parameters=parameters) + + # Compute normalization factors. + if self.norm == 'ortho': + norm_factor = tf.math.reciprocal( + tf.math.sqrt(tf.cast(tf.math.reduce_prod(self._grid_shape), + self.dtype))) + self._norm_factor_forward = norm_factor + self._norm_factor_adjoint = norm_factor + + def _transform(self, x, adjoint=False): + if adjoint: + if self.density is not None: + x *= self._weights_sqrt + x = fft_ops.nufft(x, self.trajectory, + grid_shape=self._grid_shape, + transform_type='type_1', + fft_direction='backward') + if self.norm is not None: + x *= self._norm_factor_adjoint + else: + x = fft_ops.nufft(x, self.trajectory, + transform_type='type_2', + fft_direction='forward') + if self.norm is not None: + x *= self._norm_factor_forward + if self.density is not None: + x *= self._weights_sqrt + return x + + def precompensate(self, x): + if self.density is not None: + return x * self._weights_sqrt + return x + + def _domain_shape(self): + return self._domain_shape_static + + def _domain_shape_tensor(self): + return self._domain_shape_dynamic + + def _range_shape(self): + return self._range_shape_static + + def _range_shape_tensor(self): + return self._range_shape_dynamic + + def _batch_shape(self): + return self._batch_shape_static + + def _batch_shape_tensor(self): + return self._batch_shape_dynamic + + @property + def rank(self): + return self._rank_static + + def rank_tensor(self): + return self._rank_dynamic diff --git a/tensorflow_mri/python/linalg/linear_operator_nufft_test.py b/tensorflow_mri/python/linalg/linear_operator_nufft_test.py new file mode 100755 index 00000000..ee75067a --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_nufft_test.py @@ -0,0 +1,200 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Tests for module `linear_operator_nufft`.""" +# pylint: disable=missing-class-docstring,missing-function-docstring + +from absl.testing import parameterized +import numpy as np +import tensorflow as tf + +from tensorflow_mri.python.linalg import linear_operator_nufft +from tensorflow_mri.python.ops import fft_ops +from tensorflow_mri.python.ops import image_ops +from tensorflow_mri.python.ops import traj_ops +from tensorflow_mri.python.util import test_util + + +class LinearOperatorNUFFTTest(test_util.TestCase): + @parameterized.named_parameters( + ("normalized", "ortho"), + ("unnormalized", None) + ) + def test_general(self, norm): + shape = [8, 12] + n_points = 100 + rank = 2 + rng = np.random.default_rng() + traj = rng.uniform(low=-np.pi, high=np.pi, size=(n_points, rank)) + traj = traj.astype(np.float32) + linop = linear_operator_nufft.LinearOperatorNUFFT(shape, traj, norm=norm) + + self.assertIsInstance(linop.domain_shape, tf.TensorShape) + self.assertIsInstance(linop.domain_shape_tensor(), tf.Tensor) + self.assertIsInstance(linop.range_shape, tf.TensorShape) + self.assertIsInstance(linop.range_shape_tensor(), tf.Tensor) + self.assertIsInstance(linop.batch_shape, tf.TensorShape) + self.assertIsInstance(linop.batch_shape_tensor(), tf.Tensor) + self.assertAllClose(shape, linop.domain_shape) + self.assertAllClose(shape, linop.domain_shape_tensor()) + self.assertAllClose([n_points], linop.range_shape) + self.assertAllClose([n_points], linop.range_shape_tensor()) + self.assertAllClose([], linop.batch_shape) + self.assertAllClose([], linop.batch_shape_tensor()) + + # Check forward. + x = (rng.uniform(size=shape).astype(np.float32) + + rng.uniform(size=shape).astype(np.float32) * 1j) + expected_forward = fft_ops.nufft(x, traj) + if norm: + expected_forward /= np.sqrt(np.prod(shape)) + result_forward = linop.transform(x) + self.assertAllClose(expected_forward, result_forward, rtol=1e-5, atol=1e-5) + + # Check adjoint. + expected_adjoint = fft_ops.nufft(result_forward, traj, grid_shape=shape, + transform_type="type_1", + fft_direction="backward") + if norm: + expected_adjoint /= np.sqrt(np.prod(shape)) + result_adjoint = linop.transform(result_forward, adjoint=True) + self.assertAllClose(expected_adjoint, result_adjoint, rtol=1e-5, atol=1e-5) + + + @parameterized.named_parameters( + ("normalized", "ortho"), + ("unnormalized", None) + ) + def test_with_batch_dim(self, norm): + shape = [8, 12] + n_points = 100 + batch_size = 4 + traj_shape = [batch_size, n_points] + rank = 2 + rng = np.random.default_rng() + traj = rng.uniform(low=-np.pi, high=np.pi, size=(*traj_shape, rank)) + traj = traj.astype(np.float32) + linop = linear_operator_nufft.LinearOperatorNUFFT(shape, traj, norm=norm) + + self.assertIsInstance(linop.domain_shape, tf.TensorShape) + self.assertIsInstance(linop.domain_shape_tensor(), tf.Tensor) + self.assertIsInstance(linop.range_shape, tf.TensorShape) + self.assertIsInstance(linop.range_shape_tensor(), tf.Tensor) + self.assertIsInstance(linop.batch_shape, tf.TensorShape) + self.assertIsInstance(linop.batch_shape_tensor(), tf.Tensor) + self.assertAllClose(shape, linop.domain_shape) + self.assertAllClose(shape, linop.domain_shape_tensor()) + self.assertAllClose([n_points], linop.range_shape) + self.assertAllClose([n_points], linop.range_shape_tensor()) + self.assertAllClose([batch_size], linop.batch_shape) + self.assertAllClose([batch_size], linop.batch_shape_tensor()) + + # Check forward. + x = (rng.uniform(size=shape).astype(np.float32) + + rng.uniform(size=shape).astype(np.float32) * 1j) + expected_forward = fft_ops.nufft(x, traj) + if norm: + expected_forward /= np.sqrt(np.prod(shape)) + result_forward = linop.transform(x) + self.assertAllClose(expected_forward, result_forward, rtol=1e-5, atol=1e-5) + + # Check adjoint. + expected_adjoint = fft_ops.nufft(result_forward, traj, grid_shape=shape, + transform_type="type_1", + fft_direction="backward") + if norm: + expected_adjoint /= np.sqrt(np.prod(shape)) + result_adjoint = linop.transform(result_forward, adjoint=True) + self.assertAllClose(expected_adjoint, result_adjoint, rtol=1e-5, atol=1e-5) + + + @parameterized.named_parameters( + ("normalized", "ortho"), + ("unnormalized", None) + ) + def test_with_extra_dim(self, norm): + shape = [8, 12] + n_points = 100 + batch_size = 4 + traj_shape = [batch_size, n_points] + rank = 2 + rng = np.random.default_rng() + traj = rng.uniform(low=-np.pi, high=np.pi, size=(*traj_shape, rank)) + traj = traj.astype(np.float32) + linop = linear_operator_nufft.LinearOperatorNUFFT( + [batch_size, *shape], traj, norm=norm) + + self.assertIsInstance(linop.domain_shape, tf.TensorShape) + self.assertIsInstance(linop.domain_shape_tensor(), tf.Tensor) + self.assertIsInstance(linop.range_shape, tf.TensorShape) + self.assertIsInstance(linop.range_shape_tensor(), tf.Tensor) + self.assertIsInstance(linop.batch_shape, tf.TensorShape) + self.assertIsInstance(linop.batch_shape_tensor(), tf.Tensor) + self.assertAllClose([batch_size, *shape], linop.domain_shape) + self.assertAllClose([batch_size, *shape], linop.domain_shape_tensor()) + self.assertAllClose([batch_size, n_points], linop.range_shape) + self.assertAllClose([batch_size, n_points], linop.range_shape_tensor()) + self.assertAllClose([], linop.batch_shape) + self.assertAllClose([], linop.batch_shape_tensor()) + + # Check forward. + x = (rng.uniform(size=[batch_size, *shape]).astype(np.float32) + + rng.uniform(size=[batch_size, *shape]).astype(np.float32) * 1j) + expected_forward = fft_ops.nufft(x, traj) + if norm: + expected_forward /= np.sqrt(np.prod(shape)) + result_forward = linop.transform(x) + self.assertAllClose(expected_forward, result_forward, rtol=1e-5, atol=1e-5) + + # Check adjoint. + expected_adjoint = fft_ops.nufft(result_forward, traj, grid_shape=shape, + transform_type="type_1", + fft_direction="backward") + if norm: + expected_adjoint /= np.sqrt(np.prod(shape)) + result_adjoint = linop.transform(result_forward, adjoint=True) + self.assertAllClose(expected_adjoint, result_adjoint, rtol=1e-5, atol=1e-5) + + + def test_with_density(self): + image_shape = (128, 128) + image = image_ops.phantom(shape=image_shape, dtype=tf.complex64) + trajectory = traj_ops.radial_trajectory( + 128, 128, flatten_encoding_dims=True) + density = traj_ops.radial_density( + 128, 128, flatten_encoding_dims=True) + weights = tf.cast(tf.math.sqrt(tf.math.reciprocal_no_nan(density)), + tf.complex64) + + linop = linear_operator_nufft.LinearOperatorNUFFT( + image_shape, trajectory=trajectory) + linop_d = linear_operator_nufft.LinearOperatorNUFFT( + image_shape, trajectory=trajectory, density=density) + + # Test forward. + kspace = linop.transform(image) + kspace_d = linop_d.transform(image) + self.assertAllClose(kspace * weights, kspace_d) + + # Test adjoint and precompensate function. + recon = linop.transform(linop.precompensate(kspace) * weights * weights, + adjoint=True) + recon_d1 = linop_d.transform(kspace_d, adjoint=True) + recon_d2 = linop_d.transform(linop_d.precompensate(kspace), adjoint=True) + self.assertAllClose(recon, recon_d1) + self.assertAllClose(recon, recon_d2) + + +if __name__ == '__main__': + tf.test.main() diff --git a/tensorflow_mri/python/linalg/linear_operator_scaled_identity.py b/tensorflow_mri/python/linalg/linear_operator_scaled_identity.py new file mode 100644 index 00000000..e0de5665 --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_scaled_identity.py @@ -0,0 +1,103 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Scaled identity linear operator.""" + +import tensorflow as tf + +from tensorflow_mri.python.linalg import linear_operator +from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.util import tensor_util + + +@api_util.export("linalg.LinearOperatorScaledIdentity") +class LinearOperatorScaledIdentity(linear_operator.LinearOperatorMixin, # pylint: disable=abstract-method + tf.linalg.LinearOperatorScaledIdentity): + """Linear operator representing a scaled identity matrix. + + .. note: + Similar to `tf.linalg.LinearOperatorScaledIdentity`_, but with imaging + extensions. + + Args: + shape: Non-negative integer `Tensor`. The shape of the operator. + multiplier: A `Tensor` of shape `[B1, ..., Bb]`, or `[]` (a scalar). + is_non_singular: Expect that this operator is non-singular. + is_self_adjoint: Expect that this operator is equal to its hermitian + transpose. + is_positive_definite: Expect that this operator is positive definite, + meaning the quadratic form `x^H A x` has positive real part for all + nonzero `x`. Note that we do not require the operator to be + self-adjoint to be positive-definite. See: + https://en.wikipedia.org/wiki/Positive-definite_matrix#Extension_for_non-symmetric_matrices + is_square: Expect that this operator acts like square [batch] matrices. + assert_proper_shapes: Python `bool`. If `False`, only perform static + checks that initialization and method arguments have proper shape. + If `True`, and static checks are inconclusive, add asserts to the graph. + name: A name for this `LinearOperator`. + + .. _tf.linalg.LinearOperatorScaledIdentity: https://www.tensorflow.org/api_docs/python/tf/linalg/LinearOperatorScaledIdentity + """ + def __init__(self, + shape, + multiplier, + is_non_singular=None, + is_self_adjoint=None, + is_positive_definite=None, + is_square=True, + assert_proper_shapes=False, + name="LinearOperatorScaledIdentity"): + + self._domain_shape_tensor_value = tensor_util.convert_shape_to_tensor( + shape, name="shape") + self._domain_shape_value = tf.TensorShape(tf.get_static_value( + self._domain_shape_tensor_value)) + + super().__init__( + num_rows=tf.math.reduce_prod(shape), + multiplier=multiplier, + is_non_singular=is_non_singular, + is_self_adjoint=is_self_adjoint, + is_positive_definite=is_positive_definite, + is_square=is_square, + assert_proper_shapes=assert_proper_shapes, + name=name) + + def _transform(self, x, adjoint=False): + domain_rank = tf.size(self.domain_shape_tensor()) + multiplier_shape = tf.concat([ + tf.shape(self.multiplier), + tf.ones((domain_rank,), dtype=tf.int32)], 0) + multiplier_matrix = tf.reshape(self.multiplier, multiplier_shape) + if adjoint: + multiplier_matrix = tf.math.conj(multiplier_matrix) + return x * multiplier_matrix + + def _domain_shape(self): + return self._domain_shape_value + + def _range_shape(self): + return self._domain_shape_value + + def _batch_shape(self): + return self.multiplier.shape + + def _domain_shape_tensor(self): + return self._domain_shape_tensor_value + + def _range_shape_tensor(self): + return self._domain_shape_tensor_value + + def _batch_shape_tensor(self): + return tf.shape(self.multiplier) diff --git a/tensorflow_mri/python/linalg/linear_operator_scaled_identity_test.py b/tensorflow_mri/python/linalg/linear_operator_scaled_identity_test.py new file mode 100644 index 00000000..04955e3b --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_scaled_identity_test.py @@ -0,0 +1,15 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Tests for module `linear_operator_scaled_identity`.""" diff --git a/tensorflow_mri/python/util/linalg_imaging_test.py b/tensorflow_mri/python/linalg/linear_operator_test.py similarity index 56% rename from tensorflow_mri/python/util/linalg_imaging_test.py rename to tensorflow_mri/python/linalg/linear_operator_test.py index bab6fbcb..8318fca2 100644 --- a/tensorflow_mri/python/util/linalg_imaging_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_test.py @@ -12,16 +12,16 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== -"""Tests for module `util.linalg_imaging`.""" +"""Tests for module `linear_operator`.""" # pylint: disable=missing-class-docstring,missing-function-docstring import tensorflow as tf -from tensorflow_mri.python.util import linalg_imaging +from tensorflow_mri.python.linalg import linear_operator from tensorflow_mri.python.util import test_util -class LinearOperatorAppendColumn(linalg_imaging.LinalgImagingMixin, # pylint: disable=abstract-method +class LinearOperatorAppendColumn(linear_operator.LinearOperatorMixin, # pylint: disable=abstract-method tf.linalg.LinearOperator): """Linear operator which appends a column of zeros to the input. @@ -50,8 +50,8 @@ def _range_shape(self): return self._range_shape_value -class LinalgImagingMixin(test_util.TestCase): - """Tests for `linalg_ops.LinalgImagingMixin`.""" +class LinearOperatorMixin(test_util.TestCase): + """Tests for `LinearOperatorMixin`.""" @classmethod def setUpClass(cls): # Test shapes. @@ -115,7 +115,7 @@ def test_matmul_operator(self): def test_adjoint(self): """Test `adjoint` method.""" self.assertIsInstance(self.linop.adjoint(), - linalg_imaging.LinalgImagingMixin) + linear_operator.LinearOperatorMixin) self.assertAllClose(self.linop.adjoint() @ self.y_col, self.x_col) self.assertAllClose(self.linop.adjoint().domain_shape, self.range_shape) self.assertAllClose(self.linop.adjoint().range_shape, self.domain_shape) @@ -126,7 +126,7 @@ def test_adjoint(self): def test_adjoint_property(self): """Test `H` property.""" - self.assertIsInstance(self.linop.H, linalg_imaging.LinalgImagingMixin) + self.assertIsInstance(self.linop.H, linear_operator.LinearOperatorMixin) self.assertAllClose(self.linop.H @ self.y_col, self.x_col) self.assertAllClose(self.linop.H.domain_shape, self.range_shape) self.assertAllClose(self.linop.H.range_shape, self.domain_shape) @@ -145,85 +145,3 @@ def test_unsupported_matmul(self): tf.linalg.matmul(self.linop, invalid_x) with self.assertRaisesRegex(ValueError, message): self.linop @ invalid_x # pylint: disable=pointless-statement - - -class LinearOperatorDiagTest(test_util.TestCase): - """Tests for `linalg_imaging.LinearOperatorDiag`.""" - def test_transform(self): - """Test `transform` method.""" - diag = tf.constant([[1., 2.], [3., 4.]]) - diag_linop = linalg_imaging.LinearOperatorDiag(diag, rank=2) - x = tf.constant([[2., 2.], [2., 2.]]) - self.assertAllClose([[2., 4.], [6., 8.]], diag_linop.transform(x)) - - def test_transform_adjoint(self): - """Test `transform` method with adjoint.""" - diag = tf.constant([[1., 2.], [3., 4.]]) - diag_linop = linalg_imaging.LinearOperatorDiag(diag, rank=2) - x = tf.constant([[2., 2.], [2., 2.]]) - self.assertAllClose([[2., 4.], [6., 8.]], - diag_linop.transform(x, adjoint=True)) - - def test_transform_complex(self): - """Test `transform` method with complex values.""" - diag = tf.constant([[1. + 1.j, 2. + 2.j], [3. + 3.j, 4. + 4.j]], - dtype=tf.complex64) - diag_linop = linalg_imaging.LinearOperatorDiag(diag, rank=2) - x = tf.constant([[2., 2.], [2., 2.]], dtype=tf.complex64) - self.assertAllClose([[2. + 2.j, 4. + 4.j], [6. + 6.j, 8. + 8.j]], - diag_linop.transform(x)) - - def test_transform_adjoint_complex(self): - """Test `transform` method with adjoint and complex values.""" - diag = tf.constant([[1. + 1.j, 2. + 2.j], [3. + 3.j, 4. + 4.j]], - dtype=tf.complex64) - diag_linop = linalg_imaging.LinearOperatorDiag(diag, rank=2) - x = tf.constant([[2., 2.], [2., 2.]], dtype=tf.complex64) - self.assertAllClose([[2. - 2.j, 4. - 4.j], [6. - 6.j, 8. - 8.j]], - diag_linop.transform(x, adjoint=True)) - - def test_shapes(self): - """Test shapes.""" - diag = tf.constant([[1., 2.], [3., 4.]]) - diag_linop = linalg_imaging.LinearOperatorDiag(diag, rank=2) - self.assertIsInstance(diag_linop.domain_shape, tf.TensorShape) - self.assertIsInstance(diag_linop.range_shape, tf.TensorShape) - self.assertAllEqual([2, 2], diag_linop.domain_shape) - self.assertAllEqual([2, 2], diag_linop.range_shape) - - def test_tensor_shapes(self): - """Test tensor shapes.""" - diag = tf.constant([[1., 2.], [3., 4.]]) - diag_linop = linalg_imaging.LinearOperatorDiag(diag, rank=2) - self.assertIsInstance(diag_linop.domain_shape_tensor(), tf.Tensor) - self.assertIsInstance(diag_linop.range_shape_tensor(), tf.Tensor) - self.assertAllEqual([2, 2], diag_linop.domain_shape_tensor()) - self.assertAllEqual([2, 2], diag_linop.range_shape_tensor()) - - def test_batch_shapes(self): - """Test batch shapes.""" - diag = tf.constant([[1., 2., 3.], [4., 5., 6.]]) - diag_linop = linalg_imaging.LinearOperatorDiag(diag, rank=1) - self.assertIsInstance(diag_linop.domain_shape, tf.TensorShape) - self.assertIsInstance(diag_linop.range_shape, tf.TensorShape) - self.assertIsInstance(diag_linop.batch_shape, tf.TensorShape) - self.assertAllEqual([3], diag_linop.domain_shape) - self.assertAllEqual([3], diag_linop.range_shape) - self.assertAllEqual([2], diag_linop.batch_shape) - - def test_tensor_batch_shapes(self): - """Test tensor batch shapes.""" - diag = tf.constant([[1., 2., 3.], [4., 5., 6.]]) - diag_linop = linalg_imaging.LinearOperatorDiag(diag, rank=1) - self.assertIsInstance(diag_linop.domain_shape_tensor(), tf.Tensor) - self.assertIsInstance(diag_linop.range_shape_tensor(), tf.Tensor) - self.assertIsInstance(diag_linop.batch_shape_tensor(), tf.Tensor) - self.assertAllEqual([3], diag_linop.domain_shape) - self.assertAllEqual([3], diag_linop.range_shape) - self.assertAllEqual([2], diag_linop.batch_shape) - - def test_name(self): - """Test names.""" - diag = tf.constant([[1., 2.], [3., 4.]]) - diag_linop = linalg_imaging.LinearOperatorDiag(diag, rank=2) - self.assertEqual("LinearOperatorDiag", diag_linop.name) diff --git a/tensorflow_mri/python/linalg/linear_operator_wavelet.py b/tensorflow_mri/python/linalg/linear_operator_wavelet.py new file mode 100644 index 00000000..1773d075 --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_wavelet.py @@ -0,0 +1,153 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Wavelet linear operator.""" + +import functools + +import tensorflow as tf + +from tensorflow_mri.python.ops import array_ops +from tensorflow_mri.python.ops import wavelet_ops +from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.util import check_util +from tensorflow_mri.python.linalg import linear_operator +from tensorflow_mri.python.util import tensor_util + + +@api_util.export("linalg.LinearOperatorWavelet") +class LinearOperatorWavelet(linear_operator.LinearOperator): # pylint: disable=abstract-method + """Linear operator representing a wavelet decomposition matrix. + + Args: + domain_shape: A 1D `tf.Tensor` or a `list` of `int`. The domain shape of + this linear operator. + wavelet: A `str` or a `pywt.Wavelet`_, or a `list` thereof. When passed a + `list`, different wavelets are applied along each axis in `axes`. + mode: A `str`. The padding or signal extension mode. Must be one of the + values supported by `tfmri.signal.wavedec`. Defaults to `'symmetric'`. + level: An `int` >= 0. The decomposition level. If `None` (default), + the maximum useful level of decomposition will be used (see + `tfmri.signal.max_wavelet_level`). + axes: A `list` of `int`. The axes over which the DWT is computed. Axes refer + only to domain dimensions without regard for the batch dimensions. + Defaults to `None` (all domain dimensions). + dtype: A `tf.dtypes.DType`. The data type for this operator. Defaults to + `float32`. + name: A `str`. A name for this operator. + """ + def __init__(self, + domain_shape, + wavelet, + mode='symmetric', + level=None, + axes=None, + dtype=tf.dtypes.float32, + name="LinearOperatorWavelet"): + # Set parameters. + parameters = dict( + domain_shape=domain_shape, + wavelet=wavelet, + mode=mode, + level=level, + axes=axes, + dtype=dtype, + name=name + ) + + # Get the static and dynamic shapes and save them for later use. + self._domain_shape_static, self._domain_shape_dynamic = ( + tensor_util.static_and_dynamic_shapes_from_shape(domain_shape)) + # At the moment, the wavelet implementation relies on shapes being + # statically known. + if not self._domain_shape_static.is_fully_defined(): + raise ValueError(f"static `domain_shape` must be fully defined, " + f"but got {self._domain_shape_static}") + static_rank = self._domain_shape_static.rank + + # Set arguments. + self.wavelet = wavelet + self.mode = mode + self.level = level + self.axes = check_util.validate_static_axes(axes, + rank=static_rank, + min_length=1, + canonicalize="negative", + must_be_unique=True, + scalar_to_list=True, + none_means_all=True) + + # Compute the coefficient slices needed for adjoint (wavelet + # reconstruction). + x = tf.ensure_shape(tf.zeros(self._domain_shape_dynamic, dtype=dtype), + self._domain_shape_static) + x = wavelet_ops.wavedec(x, wavelet=self.wavelet, mode=self.mode, + level=self.level, axes=self.axes) + y, self._coeff_slices = wavelet_ops.coeffs_to_tensor(x, axes=self.axes) + + # Get the range shape. + self._range_shape_static = y.shape + self._range_shape_dynamic = tf.shape(y) + + # Call base class. + super().__init__(dtype, + is_non_singular=None, + is_self_adjoint=None, + is_positive_definite=None, + is_square=None, + name=name, + parameters=parameters) + + def _transform(self, x, adjoint=False): + # While `wavedec` and `waverec` can transform only a subset of axes (and + # thus theoretically support batches), there is a caveat due to the + # `coeff_slices` object required by `waverec`. This object contains + # information relevant to a specific batch shape. While we could recompute + # this object for every input batch shape, it is easier to just process + # each batch independently. + if x.shape.rank is not None and self._domain_shape_static.rank is not None: + # Rank of input and this operator are known statically, so we can infer + # the number of batch dimensions statically too. + batch_dims = x.shape.rank - self._domain_shape_static.rank + else: + # We need to obtain the number of batch dimensions dynamically. + batch_dims = tf.rank(x) - tf.shape(self._domain_shape_dynamic)[0] + # Transform each batch. + x = array_ops.map_fn( + functools.partial(self._transform_batch, adjoint=adjoint), + x, batch_dims=batch_dims) + return x + + def _transform_batch(self, x, adjoint=False): + if adjoint: + x = wavelet_ops.tensor_to_coeffs(x, self._coeff_slices) + x = wavelet_ops.waverec(x, wavelet=self.wavelet, mode=self.mode, + axes=self.axes) + else: + x = wavelet_ops.wavedec(x, wavelet=self.wavelet, mode=self.mode, + level=self.level, axes=self.axes) + x, _ = wavelet_ops.coeffs_to_tensor(x, axes=self.axes) + return x + + def _domain_shape(self): + return self._domain_shape_static + + def _range_shape(self): + return self._range_shape_static + + def _domain_shape_tensor(self): + return self._domain_shape_dynamic + + def _range_shape_tensor(self): + return self._range_shape_dynamic diff --git a/tensorflow_mri/python/linalg/linear_operator_wavelet_test.py b/tensorflow_mri/python/linalg/linear_operator_wavelet_test.py new file mode 100755 index 00000000..d80a0665 --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_wavelet_test.py @@ -0,0 +1,87 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Tests for module `linear_operator_wavelet`.""" +# pylint: disable=missing-class-docstring,missing-function-docstring + +from absl.testing import parameterized +import numpy as np +import tensorflow as tf + +from tensorflow_mri.python.linalg import linear_operator_wavelet +from tensorflow_mri.python.ops import wavelet_ops +from tensorflow_mri.python.util import test_util + + +class LinearOperatorWaveletTest(test_util.TestCase): + @parameterized.named_parameters( + # name, wavelet, level, axes, domain_shape, range_shape + ("test0", "haar", None, None, [6, 6], [7, 7]), + ("test1", "haar", 1, None, [6, 6], [6, 6]), + ("test2", "haar", None, -1, [6, 6], [6, 7]), + ("test3", "haar", None, [-1], [6, 6], [6, 7]) + ) + def test_general(self, wavelet, level, axes, domain_shape, range_shape): + # Instantiate. + linop = linear_operator_wavelet.LinearOperatorWavelet( + domain_shape, wavelet=wavelet, level=level, axes=axes) + + # Example data. + data = np.arange(np.prod(domain_shape)).reshape(domain_shape) + data = data.astype("float32") + + # Forward and adjoint. + expected_forward, coeff_slices = wavelet_ops.coeffs_to_tensor( + wavelet_ops.wavedec(data, wavelet=wavelet, level=level, axes=axes), + axes=axes) + expected_adjoint = wavelet_ops.waverec( + wavelet_ops.tensor_to_coeffs(expected_forward, coeff_slices), + wavelet=wavelet, axes=axes) + + # Test shapes. + self.assertAllClose(domain_shape, linop.domain_shape) + self.assertAllClose(domain_shape, linop.domain_shape_tensor()) + self.assertAllClose(range_shape, linop.range_shape) + self.assertAllClose(range_shape, linop.range_shape_tensor()) + + # Test transform. + result_forward = linop.transform(data) + result_adjoint = linop.transform(result_forward, adjoint=True) + self.assertAllClose(expected_forward, result_forward) + self.assertAllClose(expected_adjoint, result_adjoint) + + def test_with_batch_inputs(self): + """Test batch shape.""" + axes = [-2, -1] + data = np.arange(4 * 8 * 8).reshape(4, 8, 8).astype("float32") + linop = linear_operator_wavelet.LinearOperatorWavelet( + (8, 8), wavelet="haar", level=1) + + # Forward and adjoint. + expected_forward, coeff_slices = wavelet_ops.coeffs_to_tensor( + wavelet_ops.wavedec(data, wavelet='haar', level=1, axes=axes), + axes=axes) + expected_adjoint = wavelet_ops.waverec( + wavelet_ops.tensor_to_coeffs(expected_forward, coeff_slices), + wavelet='haar', axes=axes) + + result_forward = linop.transform(data) + self.assertAllClose(expected_forward, result_forward) + + result_adjoint = linop.transform(result_forward, adjoint=True) + self.assertAllClose(expected_adjoint, result_adjoint) + + +if __name__ == '__main__': + tf.test.main() diff --git a/tensorflow_mri/python/ops/convex_ops.py b/tensorflow_mri/python/ops/convex_ops.py index cd21bdb1..76b89e56 100644 --- a/tensorflow_mri/python/ops/convex_ops.py +++ b/tensorflow_mri/python/ops/convex_ops.py @@ -20,14 +20,16 @@ import numpy as np import tensorflow as tf +from tensorflow_mri.python.linalg import conjugate_gradient +from tensorflow_mri.python.linalg import linear_operator_finite_difference +from tensorflow_mri.python.linalg import linear_operator_wavelet from tensorflow_mri.python.ops import array_ops -from tensorflow_mri.python.util import deprecation -from tensorflow_mri.python.ops import linalg_ops from tensorflow_mri.python.ops import math_ops from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util from tensorflow_mri.python.util import linalg_ext -from tensorflow_mri.python.util import linalg_imaging +from tensorflow_mri.python.linalg import linear_operator +from tensorflow_mri.python.util import deprecation from tensorflow_mri.python.util import tensor_util @@ -703,8 +705,9 @@ def __init__(self, # `LinearOperatorFiniteDifference` operates along one axis only. So for # multiple axes, we create one operator for each axis and vertically stack # them. - operators = [linalg_ops.LinearOperatorFiniteDifference( - domain_shape, axis=axis, dtype=dtype) for axis in axes] + operators = [ + linear_operator_finite_difference.LinearOperatorFiniteDifference( + domain_shape, axis=axis, dtype=dtype) for axis in axes] operator = linalg_ext.LinearOperatorVerticalStack(operators) function = ConvexFunctionL1Norm( domain_dimension=operator.range_dimension_tensor(), @@ -749,12 +752,12 @@ def __init__(self, scale=None, dtype=tf.dtypes.float32, name=None): - operator = linalg_ops.LinearOperatorWavelet(domain_shape, - wavelet, - mode=mode, - level=level, - axes=axes, - dtype=dtype) + operator = linear_operator_wavelet.LinearOperatorWavelet(domain_shape, + wavelet, + mode=mode, + level=level, + axes=axes, + dtype=dtype) function = ConvexFunctionL1Norm( domain_dimension=operator.range_dimension_tensor(), scale=scale, @@ -834,7 +837,8 @@ def _prox(self, x, scale=None, solver_kwargs=None): # pylint: disable=arguments rhs -= self._linear_coefficient solver_kwargs = solver_kwargs or {} - state = linalg_ops.conjugate_gradient(self._operator, rhs, **solver_kwargs) + state = conjugate_gradient.conjugate_gradient( + self._operator, rhs, **solver_kwargs) return state.x @@ -918,7 +922,7 @@ class ConvexFunctionLeastSquares(ConvexFunctionQuadratic): # pylint: disable=ab name: A name for this `ConvexFunction`. """ def __init__(self, operator, rhs, gram_operator=None, scale=None, name=None): - if isinstance(operator, linalg_imaging.LinalgImagingMixin): + if isinstance(operator, linear_operator.LinearOperatorMixin): rhs = operator.flatten_range_shape(rhs) if gram_operator: quadratic_coefficient = gram_operator diff --git a/tensorflow_mri/python/ops/linalg_ops.py b/tensorflow_mri/python/ops/linalg_ops.py deleted file mode 100644 index 1bd99788..00000000 --- a/tensorflow_mri/python/ops/linalg_ops.py +++ /dev/null @@ -1,1497 +0,0 @@ -# Copyright 2021 University College London. 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. -# ============================================================================== -"""Linear algebra operations. - -This module contains linear operators and solvers. -""" - -import collections -import functools - -import tensorflow as tf -import tensorflow_nufft as tfft - -from tensorflow_mri.python.ops import array_ops -from tensorflow_mri.python.ops import fft_ops -from tensorflow_mri.python.ops import math_ops -from tensorflow_mri.python.ops import wavelet_ops -from tensorflow_mri.python.util import api_util -from tensorflow_mri.python.util import check_util -from tensorflow_mri.python.util import linalg_imaging -from tensorflow_mri.python.util import tensor_util - - -@api_util.export("linalg.LinearOperatorNUFFT") -class LinearOperatorNUFFT(linalg_imaging.LinearOperator): # pylint: disable=abstract-method - """Linear operator acting like a nonuniform DFT matrix. - - Args: - domain_shape: A 1D integer `tf.Tensor`. The domain shape of this - operator. This is usually the shape of the image but may include - additional dimensions. - trajectory: A `tf.Tensor` of type `float32` or `float64`. Contains the - sampling locations or *k*-space trajectory. Must have shape - `[..., M, N]`, where `N` is the rank (number of dimensions), `M` is - the number of samples and `...` is the batch shape, which can have any - number of dimensions. - density: A `tf.Tensor` of type `float32` or `float64`. Contains the - sampling density at each point in `trajectory`. Must have shape - `[..., M]`, where `M` is the number of samples and `...` is the batch - shape, which can have any number of dimensions. Defaults to `None`, in - which case the density is assumed to be 1.0 in all locations. - norm: A `str`. The FFT normalization mode. Must be `None` (no normalization) - or `'ortho'`. - name: An optional `str`. The name of this operator. - - Notes: - In MRI, sampling density compensation is typically performed during the - adjoint transform. However, in order to maintain the validity of the linear - operator, this operator applies the compensation orthogonally, i.e., - it scales the data by the square root of `density` in both forward and - adjoint transforms. If you are using this operator to compute the adjoint - and wish to apply the full compensation, you can do so via the - `precompensate` method. - - >>> import tensorflow as tf - >>> import tensorflow_mri as tfmri - >>> # Create some data. - >>> image_shape = (128, 128) - >>> image = image_ops.phantom(shape=image_shape, dtype=tf.complex64) - >>> trajectory = tfmri.sampling.radial_trajectory( - >>> 128, 128, flatten_encoding_dims=True) - >>> density = tfmri.sampling.radial_density( - >>> 128, 128, flatten_encoding_dims=True) - >>> # Create a NUFFT operator. - >>> linop = tfmri.linalg.LinearOperatorNUFFT( - >>> image_shape, trajectory=trajectory, density=density) - >>> # Create k-space. - >>> kspace = tfmri.signal.nufft(image, trajectory) - >>> # This reconstructs the image applying only partial compensation - >>> # (square root of weights). - >>> image = linop.transform(kspace, adjoint=True) - >>> # This reconstructs the image with full compensation. - >>> image = linop.transform(linop.precompensate(kspace), adjoint=True) - """ - def __init__(self, - domain_shape, - trajectory, - density=None, - norm='ortho', - name="LinearOperatorNUFFT"): - - parameters = dict( - domain_shape=domain_shape, - trajectory=trajectory, - norm=norm, - name=name - ) - - # Get domain shapes. - self._domain_shape_static, self._domain_shape_dynamic = ( - tensor_util.static_and_dynamic_shapes_from_shape(domain_shape)) - - # Validate the remaining inputs. - self.trajectory = check_util.validate_tensor_dtype( - tf.convert_to_tensor(trajectory), 'floating', 'trajectory') - self.norm = check_util.validate_enum(norm, {None, 'ortho'}, 'norm') - - # We infer the operation's rank from the trajectory. - self._rank_static = self.trajectory.shape[-1] - self._rank_dynamic = tf.shape(self.trajectory)[-1] - # The domain rank is >= the operation rank. - domain_rank_static = self._domain_shape_static.rank - domain_rank_dynamic = tf.shape(self._domain_shape_dynamic)[0] - # The difference between this operation's rank and the domain rank is the - # number of extra dims. - extra_dims_static = domain_rank_static - self._rank_static - extra_dims_dynamic = domain_rank_dynamic - self._rank_dynamic - - # The grid shape are the last `rank` dimensions of domain_shape. We don't - # need the static grid shape. - self._grid_shape = self._domain_shape_dynamic[-self._rank_dynamic:] - - # We need to do some work to figure out the batch shapes. This operator - # could have a batch shape, if the trajectory has a batch shape. However, - # we allow the user to include one or more batch dimensions in the domain - # shape, if they so wish. Therefore, not all batch dimensions in the - # trajectory are necessarily part of the batch shape. - - # The total number of dimensions in `trajectory` is equal to - # `batch_dims + extra_dims + 2`. - # Compute the true batch shape (i.e., the batch dimensions that are - # NOT included in the domain shape). - batch_dims_dynamic = tf.rank(self.trajectory) - extra_dims_dynamic - 2 - if (self.trajectory.shape.rank is not None and - extra_dims_static is not None): - # We know the total number of dimensions in `trajectory` and we know - # the number of extra dims, so we can compute the number of batch dims - # statically. - batch_dims_static = self.trajectory.shape.rank - extra_dims_static - 2 - else: - # We are missing at least some information, so the number of batch - # dimensions is unknown. - batch_dims_static = None - - self._batch_shape_dynamic = tf.shape(self.trajectory)[:batch_dims_dynamic] - if batch_dims_static is not None: - self._batch_shape_static = self.trajectory.shape[:batch_dims_static] - else: - self._batch_shape_static = tf.TensorShape(None) - - # Compute the "extra" shape. This shape includes those dimensions which - # are not part of the NUFFT (e.g., they are effectively batch dimensions), - # but which are included in the domain shape rather than in the batch shape. - extra_shape_dynamic = self._domain_shape_dynamic[:-self._rank_dynamic] - if self._rank_static is not None: - extra_shape_static = self._domain_shape_static[:-self._rank_static] - else: - extra_shape_static = tf.TensorShape(None) - - # Check that the "extra" shape in `domain_shape` and `trajectory` are - # compatible for broadcasting. - shape1, shape2 = extra_shape_static, self.trajectory.shape[:-2] - try: - tf.broadcast_static_shape(shape1, shape2) - except ValueError as err: - raise ValueError( - f"The \"batch\" shapes in `domain_shape` and `trajectory` are not " - f"compatible for broadcasting: {shape1} vs {shape2}") from err - - # Compute the range shape. - self._range_shape_dynamic = tf.concat( - [extra_shape_dynamic, tf.shape(self.trajectory)[-2:-1]], 0) - self._range_shape_static = extra_shape_static.concatenate( - self.trajectory.shape[-2:-1]) - - # Statically check that density can be broadcasted with trajectory. - if density is not None: - try: - tf.broadcast_static_shape(self.trajectory.shape[:-1], density.shape) - except ValueError as err: - raise ValueError( - f"The \"batch\" shapes in `trajectory` and `density` are not " - f"compatible for broadcasting: {self.trajectory.shape[:-1]} vs " - f"{density.shape}") from err - self.density = tf.convert_to_tensor(density) - self.weights = tf.math.reciprocal_no_nan(self.density) - self._weights_sqrt = tf.cast( - tf.math.sqrt(self.weights), - tensor_util.get_complex_dtype(self.trajectory.dtype)) - else: - self.density = None - self.weights = None - - super().__init__(tensor_util.get_complex_dtype(self.trajectory.dtype), - is_non_singular=None, - is_self_adjoint=None, - is_positive_definite=None, - is_square=None, - name=name, - parameters=parameters) - - # Compute normalization factors. - if self.norm == 'ortho': - norm_factor = tf.math.reciprocal( - tf.math.sqrt(tf.cast(tf.math.reduce_prod(self._grid_shape), - self.dtype))) - self._norm_factor_forward = norm_factor - self._norm_factor_adjoint = norm_factor - - def _transform(self, x, adjoint=False): - if adjoint: - if self.density is not None: - x *= self._weights_sqrt - x = fft_ops.nufft(x, self.trajectory, - grid_shape=self._grid_shape, - transform_type='type_1', - fft_direction='backward') - if self.norm is not None: - x *= self._norm_factor_adjoint - else: - x = fft_ops.nufft(x, self.trajectory, - transform_type='type_2', - fft_direction='forward') - if self.norm is not None: - x *= self._norm_factor_forward - if self.density is not None: - x *= self._weights_sqrt - return x - - def precompensate(self, x): - if self.density is not None: - return x * self._weights_sqrt - return x - - def _domain_shape(self): - return self._domain_shape_static - - def _domain_shape_tensor(self): - return self._domain_shape_dynamic - - def _range_shape(self): - return self._range_shape_static - - def _range_shape_tensor(self): - return self._range_shape_dynamic - - def _batch_shape(self): - return self._batch_shape_static - - def _batch_shape_tensor(self): - return self._batch_shape_dynamic - - @property - def rank(self): - return self._rank_static - - def rank_tensor(self): - return self._rank_dynamic - - -@api_util.export("linalg.LinearOperatorGramNUFFT") -class LinearOperatorGramNUFFT(LinearOperatorNUFFT): # pylint: disable=abstract-method - """Linear operator acting like the Gram matrix of an NUFFT operator. - - If :math:`F` is a `tfmri.linalg.LinearOperatorNUFFT`, then this operator - applies :math:`F^H F`. This operator is self-adjoint. - - Args: - domain_shape: A 1D integer `tf.Tensor`. The domain shape of this - operator. This is usually the shape of the image but may include - additional dimensions. - trajectory: A `tf.Tensor` of type `float32` or `float64`. Contains the - sampling locations or *k*-space trajectory. Must have shape - `[..., M, N]`, where `N` is the rank (number of dimensions), `M` is - the number of samples and `...` is the batch shape, which can have any - number of dimensions. - density: A `tf.Tensor` of type `float32` or `float64`. Contains the - sampling density at each point in `trajectory`. Must have shape - `[..., M]`, where `M` is the number of samples and `...` is the batch - shape, which can have any number of dimensions. Defaults to `None`, in - which case the density is assumed to be 1.0 in all locations. - norm: A `str`. The FFT normalization mode. Must be `None` (no normalization) - or `'ortho'`. - toeplitz: A `boolean`. If `True`, uses the Toeplitz approach [1] - to compute :math:`F^H F x`, where :math:`F` is the NUFFT operator. - If `False`, the same operation is performed using the standard - NUFFT operation. The Toeplitz approach might be faster than the direct - approach but is slightly less accurate. This argument is only relevant - for non-Cartesian reconstruction and will be ignored for Cartesian - problems. - name: An optional `str`. The name of this operator. - - References: - [1] Fessler, J. A., Lee, S., Olafsson, V. T., Shi, H. R., & Noll, D. C. - (2005). Toeplitz-based iterative image reconstruction for MRI with - correction for magnetic field inhomogeneity. IEEE Transactions on Signal - Processing, 53(9), 3393-3402. - """ - def __init__(self, - domain_shape, - trajectory, - density=None, - norm='ortho', - toeplitz=False, - name="LinearOperatorNUFFT"): - super().__init__( - domain_shape=domain_shape, - trajectory=trajectory, - density=density, - norm=norm, - name=name - ) - - self.toeplitz = toeplitz - if self.toeplitz: - # Compute the FFT shift for adjoint NUFFT computation. - self._fft_shift = tf.cast(self._grid_shape // 2, self.dtype.real_dtype) - # Compute the Toeplitz kernel. - self._toeplitz_kernel = self._compute_toeplitz_kernel() - # Kernel shape (without batch dimensions). - self._kernel_shape = tf.shape(self._toeplitz_kernel)[-self.rank_tensor():] - - def _transform(self, x, adjoint=False): # pylint: disable=unused-argument - """Applies this linear operator.""" - # This operator is self-adjoint, so `adjoint` arg is unused. - if self.toeplitz: - # Using specialized Toeplitz implementation. - return self._transform_toeplitz(x) - # Using standard NUFFT implementation. - return super()._transform(super()._transform(x), adjoint=True) - - def _transform_toeplitz(self, x): - """Applies this linear operator using the Toeplitz approach.""" - input_shape = tf.shape(x) - fft_axes = tf.range(-self.rank_tensor(), 0) - x = fft_ops.fftn(x, axes=fft_axes, shape=self._kernel_shape) - x *= self._toeplitz_kernel - x = fft_ops.ifftn(x, axes=fft_axes) - x = tf.slice(x, tf.zeros([tf.rank(x)], dtype=tf.int32), input_shape) - return x - - def _compute_toeplitz_kernel(self): - """Computes the kernel for the Toeplitz approach.""" - trajectory = self.trajectory - weights = self.weights - if self.rank is None: - raise NotImplementedError( - f"The rank of {self.name} must be known statically.") - - if weights is None: - # If no weights were passed, use ones. - weights = tf.ones(tf.shape(trajectory)[:-1], dtype=self.dtype.real_dtype) - # Cast weights to complex dtype. - weights = tf.cast(tf.math.sqrt(weights), self.dtype) - - # Compute N-D kernel recursively. Begin with last axis. - last_axis = self.rank - 1 - kernel = self._compute_kernel_recursive(trajectory, weights, last_axis) - - # Make sure that the kernel is symmetric/Hermitian/self-adjoint. - kernel = self._enforce_kernel_symmetry(kernel) - - # Additional normalization by sqrt(2 ** rank). This is required because - # we are using FFTs with twice the length of the original image. - if self.norm == 'ortho': - kernel *= tf.cast(tf.math.sqrt(2.0 ** self.rank), kernel.dtype) - - # Put the kernel in Fourier space. - fft_axes = list(range(-self.rank, 0)) - fft_norm = self.norm or "backward" - return fft_ops.fftn(kernel, axes=fft_axes, norm=fft_norm) - - def _compute_kernel_recursive(self, trajectory, weights, axis): - """Recursively computes the kernel for the Toeplitz approach. - - This function works by computing the two halves of the kernel along each - axis. The "left" half is computed using the input trajectory. The "right" - half is computed using the trajectory flipped along the current axis, and - then reversed. Then the two halves are concatenated, with a block of zeros - inserted in between. If there is more than one axis, the process is repeated - recursively for each axis. - - This function calls the adjoint NUFFT 2 ** N times, where N is the number - of dimensions. NOTE: this could be optimized to 2 ** (N - 1) calls. - - Args: - trajectory: A `tf.Tensor` containing the current *k*-space trajectory. - weights: A `tf.Tensor` containing the current density compensation - weights. - axis: An `int` denoting the current axis. - - Returns: - A `tf.Tensor` containing the kernel. - - Raises: - NotImplementedError: If the rank of the operator is not known statically. - """ - # Account for the batch dimensions. We do not need to do the recursion - # for these. - batch_dims = self.batch_shape.rank - if batch_dims is None: - raise NotImplementedError( - f"The number of batch dimensions of {self.name} must be known " - f"statically.") - # The current axis without the batch dimensions. - image_axis = axis + batch_dims - if axis == 0: - # Outer-most axis. Compute left half, then use Hermitian symmetry to - # compute right half. - # TODO(jmontalt): there should be a way to compute the NUFFT only once. - kernel_left = self._nufft_adjoint(weights, trajectory) - flippings = tf.tensor_scatter_nd_update( - tf.ones([self.rank_tensor()]), [[axis]], [-1]) - kernel_right = self._nufft_adjoint(weights, trajectory * flippings) - else: - # We still have two or more axes to process. Compute left and right kernels - # by calling this function recursively. We call ourselves twice, first - # with current frequencies, then with negated frequencies along current - # axes. - kernel_left = self._compute_kernel_recursive( - trajectory, weights, axis - 1) - flippings = tf.tensor_scatter_nd_update( - tf.ones([self.rank_tensor()]), [[axis]], [-1]) - kernel_right = self._compute_kernel_recursive( - trajectory * flippings, weights, axis - 1) - - # Remove zero frequency and reverse. - kernel_right = tf.reverse(array_ops.slice_along_axis( - kernel_right, image_axis, 1, tf.shape(kernel_right)[image_axis] - 1), - [image_axis]) - - # Create block of zeros to be inserted between the left and right halves of - # the kernel. - zeros_shape = tf.concat([ - tf.shape(kernel_left)[:image_axis], [1], - tf.shape(kernel_left)[(image_axis + 1):]], 0) - zeros = tf.zeros(zeros_shape, dtype=kernel_left.dtype) - - # Concatenate the left and right halves of kernel, with a block of zeros in - # the middle. - kernel = tf.concat([kernel_left, zeros, kernel_right], image_axis) - return kernel - - def _nufft_adjoint(self, x, trajectory=None): - """Applies the adjoint NUFFT operator. - - We use this instead of `super()._transform(x, adjoint=True)` because we - need to be able to change the trajectory and to apply an FFT shift. - - Args: - x: A `tf.Tensor` containing the input data (typically the weights or - ones). - trajectory: A `tf.Tensor` containing the *k*-space trajectory, which - may have been flipped and therefore different from the original. If - `None`, the original trajectory is used. - - Returns: - A `tf.Tensor` containing the result of the adjoint NUFFT. - """ - # Apply FFT shift. - x *= tf.math.exp(tf.dtypes.complex( - tf.constant(0, dtype=self.dtype.real_dtype), - tf.math.reduce_sum(trajectory * self._fft_shift, -1))) - # Temporarily update trajectory. - if trajectory is not None: - temp = self.trajectory - self.trajectory = trajectory - x = super()._transform(x, adjoint=True) - if trajectory is not None: - self.trajectory = temp - return x - - def _enforce_kernel_symmetry(self, kernel): - """Enforces Hermitian symmetry on an input kernel. - - Args: - kernel: A `tf.Tensor`. An approximately Hermitian kernel. - - Returns: - A Hermitian-symmetric kernel. - """ - kernel_axes = list(range(-self.rank, 0)) - reversed_kernel = tf.roll( - tf.reverse(kernel, kernel_axes), - shift=tf.ones([tf.size(kernel_axes)], dtype=tf.int32), - axis=kernel_axes) - return (kernel + tf.math.conj(reversed_kernel)) / 2 - - def _range_shape(self): - # Override the NUFFT operator's range shape. The range shape for this - # operator is the same as the domain shape. - return self._domain_shape() - - def _range_shape_tensor(self): - return self._domain_shape_tensor() - - -@api_util.export("linalg.LinearOperatorFiniteDifference") -class LinearOperatorFiniteDifference(linalg_imaging.LinearOperator): # pylint: disable=abstract-method - """Linear operator representing a finite difference matrix. - - Args: - domain_shape: A 1D `tf.Tensor` or a `list` of `int`. The domain shape of - this linear operator. - axis: An `int`. The axis along which the finite difference is taken. - Defaults to -1. - dtype: A `tf.dtypes.DType`. The data type for this operator. Defaults to - `float32`. - name: A `str`. A name for this operator. - """ - def __init__(self, - domain_shape, - axis=-1, - dtype=tf.dtypes.float32, - name="LinearOperatorFiniteDifference"): - - parameters = dict( - domain_shape=domain_shape, - axis=axis, - dtype=dtype, - name=name - ) - - # Compute the static and dynamic shapes and save them for later use. - self._domain_shape_static, self._domain_shape_dynamic = ( - tensor_util.static_and_dynamic_shapes_from_shape(domain_shape)) - - # Validate axis and canonicalize to negative. This ensures the correct - # axis is selected in the presence of batch dimensions. - self.axis = check_util.validate_static_axes( - axis, self._domain_shape_static.rank, - min_length=1, - max_length=1, - canonicalize="negative", - scalar_to_list=False) - - # Compute range shape statically. The range has one less element along - # the difference axis than the domain. - range_shape_static = self._domain_shape_static.as_list() - if range_shape_static[self.axis] is not None: - range_shape_static[self.axis] -= 1 - range_shape_static = tf.TensorShape(range_shape_static) - self._range_shape_static = range_shape_static - - # Now compute dynamic range shape. First concatenate the leading axes with - # the updated difference dimension. Then, iff the difference axis is not - # the last one, concatenate the trailing axes. - range_shape_dynamic = self._domain_shape_dynamic - range_shape_dynamic = tf.concat([ - range_shape_dynamic[:self.axis], - [range_shape_dynamic[self.axis] - 1]], 0) - if self.axis != -1: - range_shape_dynamic = tf.concat([ - range_shape_dynamic, - range_shape_dynamic[self.axis + 1:]], 0) - self._range_shape_dynamic = range_shape_dynamic - - super().__init__(dtype, - is_non_singular=None, - is_self_adjoint=None, - is_positive_definite=None, - is_square=None, - name=name, - parameters=parameters) - - def _transform(self, x, adjoint=False): - - if adjoint: - paddings1 = [[0, 0]] * x.shape.rank - paddings2 = [[0, 0]] * x.shape.rank - paddings1[self.axis] = [1, 0] - paddings2[self.axis] = [0, 1] - x1 = tf.pad(x, paddings1) # pylint: disable=no-value-for-parameter - x2 = tf.pad(x, paddings2) # pylint: disable=no-value-for-parameter - x = x1 - x2 - else: - slice1 = [slice(None)] * x.shape.rank - slice2 = [slice(None)] * x.shape.rank - slice1[self.axis] = slice(1, None) - slice2[self.axis] = slice(None, -1) - x1 = x[tuple(slice1)] - x2 = x[tuple(slice2)] - x = x1 - x2 - - return x - - def _domain_shape(self): - return self._domain_shape_static - - def _range_shape(self): - return self._range_shape_static - - def _domain_shape_tensor(self): - return self._domain_shape_dynamic - - def _range_shape_tensor(self): - return self._range_shape_dynamic - - -@api_util.export("linalg.LinearOperatorWavelet") -class LinearOperatorWavelet(linalg_imaging.LinearOperator): # pylint: disable=abstract-method - """Linear operator representing a wavelet decomposition matrix. - - Args: - domain_shape: A 1D `tf.Tensor` or a `list` of `int`. The domain shape of - this linear operator. - wavelet: A `str` or a `pywt.Wavelet`_, or a `list` thereof. When passed a - `list`, different wavelets are applied along each axis in `axes`. - mode: A `str`. The padding or signal extension mode. Must be one of the - values supported by `tfmri.signal.wavedec`. Defaults to `'symmetric'`. - level: An `int` >= 0. The decomposition level. If `None` (default), - the maximum useful level of decomposition will be used (see - `tfmri.signal.max_wavelet_level`). - axes: A `list` of `int`. The axes over which the DWT is computed. Axes refer - only to domain dimensions without regard for the batch dimensions. - Defaults to `None` (all domain dimensions). - dtype: A `tf.dtypes.DType`. The data type for this operator. Defaults to - `float32`. - name: A `str`. A name for this operator. - """ - def __init__(self, - domain_shape, - wavelet, - mode='symmetric', - level=None, - axes=None, - dtype=tf.dtypes.float32, - name="LinearOperatorWavelet"): - # Set parameters. - parameters = dict( - domain_shape=domain_shape, - wavelet=wavelet, - mode=mode, - level=level, - axes=axes, - dtype=dtype, - name=name - ) - - # Get the static and dynamic shapes and save them for later use. - self._domain_shape_static, self._domain_shape_dynamic = ( - tensor_util.static_and_dynamic_shapes_from_shape(domain_shape)) - # At the moment, the wavelet implementation relies on shapes being - # statically known. - if not self._domain_shape_static.is_fully_defined(): - raise ValueError(f"static `domain_shape` must be fully defined, " - f"but got {self._domain_shape_static}") - static_rank = self._domain_shape_static.rank - - # Set arguments. - self.wavelet = wavelet - self.mode = mode - self.level = level - self.axes = check_util.validate_static_axes(axes, - rank=static_rank, - min_length=1, - canonicalize="negative", - must_be_unique=True, - scalar_to_list=True, - none_means_all=True) - - # Compute the coefficient slices needed for adjoint (wavelet - # reconstruction). - x = tf.ensure_shape(tf.zeros(self._domain_shape_dynamic, dtype=dtype), - self._domain_shape_static) - x = wavelet_ops.wavedec(x, wavelet=self.wavelet, mode=self.mode, - level=self.level, axes=self.axes) - y, self._coeff_slices = wavelet_ops.coeffs_to_tensor(x, axes=self.axes) - - # Get the range shape. - self._range_shape_static = y.shape - self._range_shape_dynamic = tf.shape(y) - - # Call base class. - super().__init__(dtype, - is_non_singular=None, - is_self_adjoint=None, - is_positive_definite=None, - is_square=None, - name=name, - parameters=parameters) - - def _transform(self, x, adjoint=False): - # While `wavedec` and `waverec` can transform only a subset of axes (and - # thus theoretically support batches), there is a caveat due to the - # `coeff_slices` object required by `waverec`. This object contains - # information relevant to a specific batch shape. While we could recompute - # this object for every input batch shape, it is easier to just process - # each batch independently. - if x.shape.rank is not None and self._domain_shape_static.rank is not None: - # Rank of input and this operator are known statically, so we can infer - # the number of batch dimensions statically too. - batch_dims = x.shape.rank - self._domain_shape_static.rank - else: - # We need to obtain the number of batch dimensions dynamically. - batch_dims = tf.rank(x) - tf.shape(self._domain_shape_dynamic)[0] - # Transform each batch. - x = array_ops.map_fn( - functools.partial(self._transform_batch, adjoint=adjoint), - x, batch_dims=batch_dims) - return x - - def _transform_batch(self, x, adjoint=False): - if adjoint: - x = wavelet_ops.tensor_to_coeffs(x, self._coeff_slices) - x = wavelet_ops.waverec(x, wavelet=self.wavelet, mode=self.mode, - axes=self.axes) - else: - x = wavelet_ops.wavedec(x, wavelet=self.wavelet, mode=self.mode, - level=self.level, axes=self.axes) - x, _ = wavelet_ops.coeffs_to_tensor(x, axes=self.axes) - return x - - def _domain_shape(self): - return self._domain_shape_static - - def _range_shape(self): - return self._range_shape_static - - def _domain_shape_tensor(self): - return self._domain_shape_dynamic - - def _range_shape_tensor(self): - return self._range_shape_dynamic - - -@api_util.export("linalg.LinearOperatorMRI") -class LinearOperatorMRI(linalg_imaging.LinearOperator): # pylint: disable=abstract-method - """Linear operator representing an MRI encoding matrix. - - The MRI operator, :math:`A`, maps a [batch of] images, :math:`x` to a - [batch of] measurement data (*k*-space), :math:`b`. - - .. math:: - A x = b - - This object may represent an undersampled MRI operator and supports - Cartesian and non-Cartesian *k*-space sampling. The user may provide a - sampling `mask` to represent an undersampled Cartesian operator, or a - `trajectory` to represent a non-Cartesian operator. - - This object may represent a multicoil MRI operator by providing coil - `sensitivities`. Note that `mask`, `trajectory` and `density` should never - have a coil dimension, including in the case of multicoil imaging. The coil - dimension will be handled automatically. - - The domain shape of this operator is `extra_shape + image_shape`. The range - of this operator is `extra_shape + [num_coils] + image_shape`, for - Cartesian imaging, or `extra_shape + [num_coils] + [num_samples]`, for - non-Cartesian imaging. `[num_coils]` is optional and only present for - multicoil operators. This operator supports batches of images and will - vectorize operations when possible. - - Args: - image_shape: A `tf.TensorShape` or a list of `ints`. The shape of the images - that this operator acts on. Must have length 2 or 3. - extra_shape: An optional `tf.TensorShape` or list of `ints`. Additional - dimensions that should be included within the operator domain. Note that - `extra_shape` is not needed to reconstruct independent batches of images. - However, it is useful when this operator is used as part of a - reconstruction that performs computation along non-spatial dimensions, - e.g. for temporal regularization. Defaults to `None`. - mask: An optional `tf.Tensor` of type `tf.bool`. The sampling mask. Must - have shape `[..., *S]`, where `S` is the `image_shape` and `...` is - the batch shape, which can have any number of dimensions. If `mask` is - passed, this operator represents an undersampled MRI operator. - trajectory: An optional `tf.Tensor` of type `float32` or `float64`. Must - have shape `[..., M, N]`, where `N` is the rank (number of spatial - dimensions), `M` is the number of samples in the encoded space and `...` - is the batch shape, which can have any number of dimensions. If - `trajectory` is passed, this operator represents a non-Cartesian MRI - operator. - density: An optional `tf.Tensor` of type `float32` or `float64`. The - sampling densities. Must have shape `[..., M]`, where `M` is the number of - samples and `...` is the batch shape, which can have any number of - dimensions. This input is only relevant for non-Cartesian MRI operators. - If passed, the non-Cartesian operator will include sampling density - compensation. If `None`, the operator will not perform sampling density - compensation. - sensitivities: An optional `tf.Tensor` of type `complex64` or `complex128`. - The coil sensitivity maps. Must have shape `[..., C, *S]`, where `S` - is the `image_shape`, `C` is the number of coils and `...` is the batch - shape, which can have any number of dimensions. - phase: An optional `tf.Tensor` of type `float32` or `float64`. A phase - estimate for the image. If provided, this operator will be - phase-constrained. - fft_norm: FFT normalization mode. Must be `None` (no normalization) - or `'ortho'`. Defaults to `'ortho'`. - sens_norm: A `boolean`. Whether to normalize coil sensitivities. Defaults to - `True`. - dynamic_domain: A `str`. The domain of the dynamic dimension, if present. - Must be one of `'time'` or `'frequency'`. May only be provided together - with a non-scalar `extra_shape`. The dynamic dimension is the last - dimension of `extra_shape`. The `'time'` mode (default) should be - used for regular dynamic reconstruction. The `'frequency'` mode should be - used for reconstruction in x-f space. - dtype: A `tf.dtypes.DType`. The dtype of this operator. Must be `complex64` - or `complex128`. Defaults to `complex64`. - name: An optional `str`. The name of this operator. - """ - def __init__(self, - image_shape, - extra_shape=None, - mask=None, - trajectory=None, - density=None, - sensitivities=None, - phase=None, - fft_norm='ortho', - sens_norm=True, - dynamic_domain=None, - dtype=tf.complex64, - name=None): - # pylint: disable=invalid-unary-operand-type - parameters = dict( - image_shape=image_shape, - extra_shape=extra_shape, - mask=mask, - trajectory=trajectory, - density=density, - sensitivities=sensitivities, - phase=phase, - fft_norm=fft_norm, - sens_norm=sens_norm, - dynamic_domain=dynamic_domain, - dtype=dtype, - name=name) - - # Set dtype. - dtype = tf.as_dtype(dtype) - if dtype not in (tf.complex64, tf.complex128): - raise ValueError( - f"`dtype` must be `complex64` or `complex128`, but got: {str(dtype)}") - - # Set image shape, rank and extra shape. - image_shape = tf.TensorShape(image_shape) - rank = image_shape.rank - if rank not in (2, 3): - raise ValueError( - f"Rank must be 2 or 3, but got: {rank}") - if not image_shape.is_fully_defined(): - raise ValueError( - f"`image_shape` must be fully defined, but got {image_shape}") - self._rank = rank - self._image_shape = image_shape - self._image_axes = list(range(-self._rank, 0)) # pylint: disable=invalid-unary-operand-type - self._extra_shape = tf.TensorShape(extra_shape or []) - - # Set initial batch shape, then update according to inputs. - batch_shape = self._extra_shape - batch_shape_tensor = tensor_util.convert_shape_to_tensor(batch_shape) - - # Set sampling mask after checking dtype and static shape. - if mask is not None: - mask = tf.convert_to_tensor(mask) - if mask.dtype != tf.bool: - raise TypeError( - f"`mask` must have dtype `bool`, but got: {str(mask.dtype)}") - if not mask.shape[-self._rank:].is_compatible_with(self._image_shape): - raise ValueError( - f"Expected the last dimensions of `mask` to be compatible with " - f"{self._image_shape}], but got: {mask.shape[-self._rank:]}") - batch_shape = tf.broadcast_static_shape( - batch_shape, mask.shape[:-self._rank]) - batch_shape_tensor = tf.broadcast_dynamic_shape( - batch_shape_tensor, tf.shape(mask)[:-self._rank]) - self._mask = mask - - # Set sampling trajectory after checking dtype and static shape. - if trajectory is not None: - if mask is not None: - raise ValueError("`mask` and `trajectory` cannot be both passed.") - trajectory = tf.convert_to_tensor(trajectory) - if trajectory.dtype != dtype.real_dtype: - raise TypeError( - f"Expected `trajectory` to have dtype `{str(dtype.real_dtype)}`, " - f"but got: {str(trajectory.dtype)}") - if trajectory.shape[-1] != self._rank: - raise ValueError( - f"Expected the last dimension of `trajectory` to be " - f"{self._rank}, but got {trajectory.shape[-1]}") - batch_shape = tf.broadcast_static_shape( - batch_shape, trajectory.shape[:-2]) - batch_shape_tensor = tf.broadcast_dynamic_shape( - batch_shape_tensor, tf.shape(trajectory)[:-2]) - self._trajectory = trajectory - - # Set sampling density after checking dtype and static shape. - if density is not None: - if self._trajectory is None: - raise ValueError("`density` must be passed with `trajectory`.") - density = tf.convert_to_tensor(density) - if density.dtype != dtype.real_dtype: - raise TypeError( - f"Expected `density` to have dtype `{str(dtype.real_dtype)}`, " - f"but got: {str(density.dtype)}") - if density.shape[-1] != self._trajectory.shape[-2]: - raise ValueError( - f"Expected the last dimension of `density` to be " - f"{self._trajectory.shape[-2]}, but got {density.shape[-1]}") - batch_shape = tf.broadcast_static_shape( - batch_shape, density.shape[:-1]) - batch_shape_tensor = tf.broadcast_dynamic_shape( - batch_shape_tensor, tf.shape(density)[:-1]) - self._density = density - - # Set sensitivity maps after checking dtype and static shape. - if sensitivities is not None: - sensitivities = tf.convert_to_tensor(sensitivities) - if sensitivities.dtype != dtype: - raise TypeError( - f"Expected `sensitivities` to have dtype `{str(dtype)}`, but got: " - f"{str(sensitivities.dtype)}") - if not sensitivities.shape[-self._rank:].is_compatible_with( - self._image_shape): - raise ValueError( - f"Expected the last dimensions of `sensitivities` to be " - f"compatible with {self._image_shape}, but got: " - f"{sensitivities.shape[-self._rank:]}") - batch_shape = tf.broadcast_static_shape( - batch_shape, sensitivities.shape[:-(self._rank + 1)]) - batch_shape_tensor = tf.broadcast_dynamic_shape( - batch_shape_tensor, tf.shape(sensitivities)[:-(self._rank + 1)]) - self._sensitivities = sensitivities - - if phase is not None: - phase = tf.convert_to_tensor(phase) - if phase.dtype != dtype.real_dtype: - raise TypeError( - f"Expected `phase` to have dtype `{str(dtype.real_dtype)}`, " - f"but got: {str(phase.dtype)}") - if not phase.shape[-self._rank:].is_compatible_with( - self._image_shape): - raise ValueError( - f"Expected the last dimensions of `phase` to be " - f"compatible with {self._image_shape}, but got: " - f"{phase.shape[-self._rank:]}") - batch_shape = tf.broadcast_static_shape( - batch_shape, phase.shape[:-self._rank]) - batch_shape_tensor = tf.broadcast_dynamic_shape( - batch_shape_tensor, tf.shape(phase)[:-self._rank]) - self._phase = phase - - # Set batch shapes. - self._batch_shape_value = batch_shape - self._batch_shape_tensor_value = batch_shape_tensor - - # If multicoil, add coil dimension to mask, trajectory and density. - if self._sensitivities is not None: - if self._mask is not None: - self._mask = tf.expand_dims(self._mask, axis=-(self._rank + 1)) - if self._trajectory is not None: - self._trajectory = tf.expand_dims(self._trajectory, axis=-3) - if self._density is not None: - self._density = tf.expand_dims(self._density, axis=-2) - if self._phase is not None: - self._phase = tf.expand_dims(self._phase, axis=-(self._rank + 1)) - - # Save some tensors for later use during computation. - if self._mask is not None: - self._mask_linop_dtype = tf.cast(self._mask, dtype) - if self._density is not None: - self._dens_weights_sqrt = tf.cast( - tf.math.sqrt(tf.math.reciprocal_no_nan(self._density)), dtype) - if self._phase is not None: - self._phase_rotator = tf.math.exp( - tf.complex(tf.constant(0.0, dtype=phase.dtype), phase)) - - # Set normalization. - self._fft_norm = check_util.validate_enum( - fft_norm, {None, 'ortho'}, 'fft_norm') - if self._fft_norm == 'ortho': # Compute normalization factors. - self._fft_norm_factor = tf.math.reciprocal( - tf.math.sqrt(tf.cast(self._image_shape.num_elements(), dtype))) - - # Normalize coil sensitivities. - self._sens_norm = sens_norm - if self._sensitivities is not None and self._sens_norm: - self._sensitivities = math_ops.normalize_no_nan( - self._sensitivities, axis=-(self._rank + 1)) - - # Set dynamic domain. - if dynamic_domain is not None and self._extra_shape.rank == 0: - raise ValueError( - "Argument `dynamic_domain` requires a non-scalar `extra_shape`.") - if dynamic_domain is not None: - self._dynamic_domain = check_util.validate_enum( - dynamic_domain, {'time', 'frequency'}, name='dynamic_domain') - else: - self._dynamic_domain = None - - # This variable is used by `LinearOperatorGramMRI` to disable the NUFFT. - self._skip_nufft = False - - super().__init__(dtype, name=name, parameters=parameters) - - def _transform(self, x, adjoint=False): - """Transform [batch] input `x`. - - Args: - x: A `tf.Tensor` of type `self.dtype` and shape - `[..., *self.domain_shape]` containing images, if `adjoint` is `False`, - or a `tf.Tensor` of type `self.dtype` and shape - `[..., *self.range_shape]` containing *k*-space data, if `adjoint` is - `True`. - adjoint: A `boolean` indicating whether to apply the adjoint of the - operator. - - Returns: - A `tf.Tensor` of type `self.dtype` and shape `[..., *self.range_shape]` - containing *k*-space data, if `adjoint` is `False`, or a `tf.Tensor` of - type `self.dtype` and shape `[..., *self.domain_shape]` containing - images, if `adjoint` is `True`. - """ - if adjoint: - # Apply density compensation. - if self._density is not None and not self._skip_nufft: - x *= self._dens_weights_sqrt - - # Apply adjoint Fourier operator. - if self.is_non_cartesian: # Non-Cartesian imaging, use NUFFT. - if not self._skip_nufft: - x = tfft.nufft(x, self._trajectory, - grid_shape=self._image_shape, - transform_type='type_1', - fft_direction='backward') - if self._fft_norm is not None: - x *= self._fft_norm_factor - - else: # Cartesian imaging, use FFT. - if self._mask is not None: - x *= self._mask_linop_dtype # Undersampling. - x = fft_ops.ifftn(x, axes=self._image_axes, - norm=self._fft_norm or 'forward', shift=True) - - # Apply coil combination. - if self.is_multicoil: - x *= tf.math.conj(self._sensitivities) - x = tf.math.reduce_sum(x, axis=-(self._rank + 1)) - - # Maybe remove phase from image. - if self.is_phase_constrained: - x *= tf.math.conj(self._phase_rotator) - x = tf.cast(tf.math.real(x), self.dtype) - - # Apply FFT along dynamic axis, if necessary. - if self.is_dynamic and self.dynamic_domain == 'frequency': - x = fft_ops.fftn(x, axes=[self.dynamic_axis], - norm='ortho', shift=True) - - else: # Forward operator. - - # Apply FFT along dynamic axis, if necessary. - if self.is_dynamic and self.dynamic_domain == 'frequency': - x = fft_ops.ifftn(x, axes=[self.dynamic_axis], - norm='ortho', shift=True) - - # Add phase to real-valued image if reconstruction is phase-constrained. - if self.is_phase_constrained: - x = tf.cast(tf.math.real(x), self.dtype) - x *= self._phase_rotator - - # Apply sensitivity modulation. - if self.is_multicoil: - x = tf.expand_dims(x, axis=-(self._rank + 1)) - x *= self._sensitivities - - # Apply Fourier operator. - if self.is_non_cartesian: # Non-Cartesian imaging, use NUFFT. - if not self._skip_nufft: - x = tfft.nufft(x, self._trajectory, - transform_type='type_2', - fft_direction='forward') - if self._fft_norm is not None: - x *= self._fft_norm_factor - - else: # Cartesian imaging, use FFT. - x = fft_ops.fftn(x, axes=self._image_axes, - norm=self._fft_norm or 'backward', shift=True) - if self._mask is not None: - x *= self._mask_linop_dtype # Undersampling. - - # Apply density compensation. - if self._density is not None and not self._skip_nufft: - x *= self._dens_weights_sqrt - - return x - - def _domain_shape(self): - """Returns the shape of the domain space of this operator.""" - return self._extra_shape.concatenate(self._image_shape) - - def _range_shape(self): - """Returns the shape of the range space of this operator.""" - if self.is_cartesian: - range_shape = self._image_shape.as_list() - else: - range_shape = [self._trajectory.shape[-2]] - if self.is_multicoil: - range_shape = [self.num_coils] + range_shape - return self._extra_shape.concatenate(range_shape) - - def _batch_shape(self): - """Returns the static batch shape of this operator.""" - return self._batch_shape_value[:-self._extra_shape.rank or None] # pylint: disable=invalid-unary-operand-type - - def _batch_shape_tensor(self): - """Returns the dynamic batch shape of this operator.""" - return self._batch_shape_tensor_value[:-self._extra_shape.rank or None] # pylint: disable=invalid-unary-operand-type - - @property - def image_shape(self): - """The image shape.""" - return self._image_shape - - @property - def rank(self): - """The number of spatial dimensions.""" - return self._rank - - @property - def is_cartesian(self): - """Whether this is a Cartesian MRI operator.""" - return self._trajectory is None - - @property - def is_non_cartesian(self): - """Whether this is a non-Cartesian MRI operator.""" - return self._trajectory is not None - - @property - def is_multicoil(self): - """Whether this is a multicoil MRI operator.""" - return self._sensitivities is not None - - @property - def is_phase_constrained(self): - """Whether this is a phase-constrained MRI operator.""" - return self._phase is not None - - @property - def is_dynamic(self): - """Whether this is a dynamic MRI operator.""" - return self._dynamic_domain is not None - - @property - def dynamic_domain(self): - """The dynamic domain of this operator.""" - return self._dynamic_domain - - @property - def dynamic_axis(self): - """The dynamic axis of this operator.""" - return -(self._rank + 1) if self.is_dynamic else None - - @property - def num_coils(self): - """The number of coils.""" - if self._sensitivities is None: - return None - return self._sensitivities.shape[-(self._rank + 1)] - - @property - def _composite_tensor_fields(self): - return ("image_shape", "mask", "trajectory", "density", "sensitivities", - "fft_norm") - - -@api_util.export("linalg.LinearOperatorGramMRI") -class LinearOperatorGramMRI(LinearOperatorMRI): # pylint: disable=abstract-method - """Linear operator representing an MRI encoding matrix. - - If :math:`A` is a `tfmri.linalg.LinearOperatorMRI`, then this ooperator - represents the matrix :math:`G = A^H A`. - - In certain circumstances, this operator may be able to apply the matrix - :math:`G` more efficiently than the composition :math:`G = A^H A` using - `tfmri.linalg.LinearOperatorMRI` objects. - - Args: - image_shape: A `tf.TensorShape` or a list of `ints`. The shape of the images - that this operator acts on. Must have length 2 or 3. - extra_shape: An optional `tf.TensorShape` or list of `ints`. Additional - dimensions that should be included within the operator domain. Note that - `extra_shape` is not needed to reconstruct independent batches of images. - However, it is useful when this operator is used as part of a - reconstruction that performs computation along non-spatial dimensions, - e.g. for temporal regularization. Defaults to `None`. - mask: An optional `tf.Tensor` of type `tf.bool`. The sampling mask. Must - have shape `[..., *S]`, where `S` is the `image_shape` and `...` is - the batch shape, which can have any number of dimensions. If `mask` is - passed, this operator represents an undersampled MRI operator. - trajectory: An optional `tf.Tensor` of type `float32` or `float64`. Must - have shape `[..., M, N]`, where `N` is the rank (number of spatial - dimensions), `M` is the number of samples in the encoded space and `...` - is the batch shape, which can have any number of dimensions. If - `trajectory` is passed, this operator represents a non-Cartesian MRI - operator. - density: An optional `tf.Tensor` of type `float32` or `float64`. The - sampling densities. Must have shape `[..., M]`, where `M` is the number of - samples and `...` is the batch shape, which can have any number of - dimensions. This input is only relevant for non-Cartesian MRI operators. - If passed, the non-Cartesian operator will include sampling density - compensation. If `None`, the operator will not perform sampling density - compensation. - sensitivities: An optional `tf.Tensor` of type `complex64` or `complex128`. - The coil sensitivity maps. Must have shape `[..., C, *S]`, where `S` - is the `image_shape`, `C` is the number of coils and `...` is the batch - shape, which can have any number of dimensions. - phase: An optional `tf.Tensor` of type `float32` or `float64`. A phase - estimate for the image. If provided, this operator will be - phase-constrained. - fft_norm: FFT normalization mode. Must be `None` (no normalization) - or `'ortho'`. Defaults to `'ortho'`. - sens_norm: A `boolean`. Whether to normalize coil sensitivities. Defaults to - `True`. - dynamic_domain: A `str`. The domain of the dynamic dimension, if present. - Must be one of `'time'` or `'frequency'`. May only be provided together - with a non-scalar `extra_shape`. The dynamic dimension is the last - dimension of `extra_shape`. The `'time'` mode (default) should be - used for regular dynamic reconstruction. The `'frequency'` mode should be - used for reconstruction in x-f space. - toeplitz_nufft: A `boolean`. If `True`, uses the Toeplitz approach [5] - to compute :math:`F^H F x`, where :math:`F` is the non-uniform Fourier - operator. If `False`, the same operation is performed using the standard - NUFFT operation. The Toeplitz approach might be faster than the direct - approach but is slightly less accurate. This argument is only relevant - for non-Cartesian reconstruction and will be ignored for Cartesian - problems. - dtype: A `tf.dtypes.DType`. The dtype of this operator. Must be `complex64` - or `complex128`. Defaults to `complex64`. - name: An optional `str`. The name of this operator. - """ - def __init__(self, - image_shape, - extra_shape=None, - mask=None, - trajectory=None, - density=None, - sensitivities=None, - phase=None, - fft_norm='ortho', - sens_norm=True, - dynamic_domain=None, - toeplitz_nufft=False, - dtype=tf.complex64, - name="LinearOperatorGramMRI"): - super().__init__( - image_shape, - extra_shape=extra_shape, - mask=mask, - trajectory=trajectory, - density=density, - sensitivities=sensitivities, - phase=phase, - fft_norm=fft_norm, - sens_norm=sens_norm, - dynamic_domain=dynamic_domain, - dtype=dtype, - name=name - ) - - self.toeplitz_nufft = toeplitz_nufft - if self.toeplitz_nufft and self.is_non_cartesian: - # Create a Gram NUFFT operator with Toeplitz embedding. - self._linop_gram_nufft = LinearOperatorGramNUFFT( - image_shape, trajectory=self._trajectory, density=self._density, - norm=fft_norm, toeplitz=True) - # Disable NUFFT computation on base class. The NUFFT will instead be - # performed by the Gram NUFFT operator. - self._skip_nufft = True - - def _transform(self, x, adjoint=False): - x = super()._transform(x) - if self.toeplitz_nufft: - x = self._linop_gram_nufft.transform(x) - x = super()._transform(x, adjoint=True) - return x - - def _range_shape(self): - return self._domain_shape() - - def _range_shape_tensor(self): - return self._domain_shape_tensor() - - -# Copyright 2019 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. -# ============================================================================== - -@api_util.export("linalg.conjugate_gradient") -def conjugate_gradient(operator, - rhs, - preconditioner=None, - x=None, - tol=1e-5, - max_iterations=20, - bypass_gradient=False, - name=None): - r"""Conjugate gradient solver. - - Solves a linear system of equations :math:`Ax = b` for self-adjoint, positive - definite matrix :math:`A` and right-hand side vector :math:`b`, using an - iterative, matrix-free algorithm where the action of the matrix :math:`A` is - represented by `operator`. The iteration terminates when either the number of - iterations exceeds `max_iterations` or when the residual norm has been reduced - to `tol` times its initial value, i.e. - :math:`(\left\| b - A x_k \right\| <= \mathrm{tol} \left\| b \right\|\\)`. - - .. note:: - This function is similar to - `tf.linalg.experimental.conjugate_gradient`, except it adds support for - complex-valued linear systems and for imaging operators. - - Args: - operator: A `LinearOperator` that is self-adjoint and positive definite. - rhs: A `tf.Tensor` of shape `[..., N]`. The right hand-side of the linear - system. - preconditioner: A `LinearOperator` that approximates the inverse of `A`. - An efficient preconditioner could dramatically improve the rate of - convergence. If `preconditioner` represents matrix `M`(`M` approximates - `A^{-1}`), the algorithm uses `preconditioner.apply(x)` to estimate - `A^{-1}x`. For this to be useful, the cost of applying `M` should be - much lower than computing `A^{-1}` directly. - x: A `tf.Tensor` of shape `[..., N]`. The initial guess for the solution. - tol: A float scalar convergence tolerance. - max_iterations: An `int` giving the maximum number of iterations. - bypass_gradient: A `boolean`. If `True`, the gradient with respect to `rhs` - will be computed by applying the inverse of `operator` to the upstream - gradient with respect to `x` (through CG iteration), instead of relying - on TensorFlow's automatic differentiation. This may reduce memory usage - when training neural networks, but `operator` must not have any trainable - parameters. If `False`, gradients are computed normally. For more details, - see ref. [1]. - name: A name scope for the operation. - - Returns: - A `namedtuple` representing the final state with fields - - - i: A scalar `int32` `tf.Tensor`. Number of iterations executed. - - x: A rank-1 `tf.Tensor` of shape `[..., N]` containing the computed - solution. - - r: A rank-1 `tf.Tensor` of shape `[.., M]` containing the residual vector. - - p: A rank-1 `tf.Tensor` of shape `[..., N]`. `A`-conjugate basis vector. - - gamma: \\(r \dot M \dot r\\), equivalent to \\(||r||_2^2\\) when - `preconditioner=None`. - - Raises: - ValueError: If `operator` is not self-adjoint and positive definite. - - References: - .. [1] Aggarwal, H. K., Mani, M. P., & Jacob, M. (2018). MoDL: Model-based - deep learning architecture for inverse problems. IEEE transactions on - medical imaging, 38(2), 394-405. - """ - if bypass_gradient: - if preconditioner is not None: - raise ValueError( - "preconditioner is not supported when bypass_gradient is True.") - if x is not None: - raise ValueError("x is not supported when bypass_gradient is True.") - - def _conjugate_gradient_simple(rhs): - return _conjugate_gradient_internal(operator, rhs, - tol=tol, - max_iterations=max_iterations, - name=name) - - @tf.custom_gradient - def _conjugate_gradient_internal_grad(rhs): - result = _conjugate_gradient_simple(rhs) - - def grad(*upstream_grads): - # upstream_grads has the upstream gradient for each element of the - # output tuple (i, x, r, p, gamma). - _, dx, _, _, _ = upstream_grads - return _conjugate_gradient_simple(dx).x - - return result, grad - - return _conjugate_gradient_internal_grad(rhs) - - return _conjugate_gradient_internal(operator, rhs, - preconditioner=preconditioner, - x=x, - tol=tol, - max_iterations=max_iterations, - name=name) - - -def _conjugate_gradient_internal(operator, - rhs, - preconditioner=None, - x=None, - tol=1e-5, - max_iterations=20, - name=None): - """Implementation of `conjugate_gradient`. - - For the parameters, see `conjugate_gradient`. - """ - if isinstance(operator, linalg_imaging.LinalgImagingMixin): - rhs = operator.flatten_domain_shape(rhs) - - if not (operator.is_self_adjoint and operator.is_positive_definite): - raise ValueError('Expected a self-adjoint, positive definite operator.') - - cg_state = collections.namedtuple('CGState', ['i', 'x', 'r', 'p', 'gamma']) - - def stopping_criterion(i, state): - return tf.math.logical_and( - i < max_iterations, - tf.math.reduce_any( - tf.math.real(tf.norm(state.r, axis=-1)) > tf.math.real(tol))) - - def dot(x, y): - return tf.squeeze( - tf.linalg.matvec( - x[..., tf.newaxis], - y, adjoint_a=True), axis=-1) - - def cg_step(i, state): # pylint: disable=missing-docstring - z = tf.linalg.matvec(operator, state.p) - alpha = state.gamma / dot(state.p, z) - x = state.x + alpha[..., tf.newaxis] * state.p - r = state.r - alpha[..., tf.newaxis] * z - if preconditioner is None: - q = r - else: - q = preconditioner.matvec(r) - gamma = dot(r, q) - beta = gamma / state.gamma - p = q + beta[..., tf.newaxis] * state.p - return i + 1, cg_state(i + 1, x, r, p, gamma) - - # We now broadcast initial shapes so that we have fixed shapes per iteration. - - with tf.name_scope(name or 'conjugate_gradient'): - broadcast_shape = tf.broadcast_dynamic_shape( - tf.shape(rhs)[:-1], - operator.batch_shape_tensor()) - static_broadcast_shape = tf.broadcast_static_shape( - rhs.shape[:-1], - operator.batch_shape) - if preconditioner is not None: - broadcast_shape = tf.broadcast_dynamic_shape( - broadcast_shape, - preconditioner.batch_shape_tensor()) - static_broadcast_shape = tf.broadcast_static_shape( - static_broadcast_shape, - preconditioner.batch_shape) - broadcast_rhs_shape = tf.concat([broadcast_shape, [tf.shape(rhs)[-1]]], -1) - static_broadcast_rhs_shape = static_broadcast_shape.concatenate( - [rhs.shape[-1]]) - r0 = tf.broadcast_to(rhs, broadcast_rhs_shape) - tol *= tf.norm(r0, axis=-1) - - if x is None: - x = tf.zeros( - broadcast_rhs_shape, dtype=rhs.dtype.base_dtype) - x = tf.ensure_shape(x, static_broadcast_rhs_shape) - else: - r0 = rhs - tf.linalg.matvec(operator, x) - if preconditioner is None: - p0 = r0 - else: - p0 = tf.linalg.matvec(preconditioner, r0) - gamma0 = dot(r0, p0) - i = tf.constant(0, dtype=tf.int32) - state = cg_state(i=i, x=x, r=r0, p=p0, gamma=gamma0) - _, state = tf.while_loop( - stopping_criterion, cg_step, [i, state]) - - if isinstance(operator, linalg_imaging.LinalgImagingMixin): - x = operator.expand_range_dimension(state.x) - else: - x = state.x - - return cg_state( - state.i, - x=x, - r=state.r, - p=state.p, - gamma=state.gamma) diff --git a/tensorflow_mri/python/ops/linalg_ops_test.py b/tensorflow_mri/python/ops/linalg_ops_test.py deleted file mode 100755 index 6dabf224..00000000 --- a/tensorflow_mri/python/ops/linalg_ops_test.py +++ /dev/null @@ -1,686 +0,0 @@ -# Copyright 2021 University College London. 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. -# ============================================================================== -"""Tests for module `linalg_ops`.""" -# pylint: disable=missing-class-docstring,missing-function-docstring - -from absl.testing import parameterized -import numpy as np -import tensorflow as tf - -from tensorflow_mri.python.ops import fft_ops -from tensorflow_mri.python.ops import geom_ops -from tensorflow_mri.python.ops import image_ops -from tensorflow_mri.python.ops import linalg_ops -from tensorflow_mri.python.ops import traj_ops -from tensorflow_mri.python.ops import wavelet_ops -from tensorflow_mri.python.util import test_util - - -class LinearOperatorNUFFTTest(test_util.TestCase): - @parameterized.named_parameters( - ("normalized", "ortho"), - ("unnormalized", None) - ) - def test_general(self, norm): - shape = [8, 12] - n_points = 100 - rank = 2 - rng = np.random.default_rng() - traj = rng.uniform(low=-np.pi, high=np.pi, size=(n_points, rank)) - traj = traj.astype(np.float32) - linop = linalg_ops.LinearOperatorNUFFT(shape, traj, norm=norm) - - self.assertIsInstance(linop.domain_shape, tf.TensorShape) - self.assertIsInstance(linop.domain_shape_tensor(), tf.Tensor) - self.assertIsInstance(linop.range_shape, tf.TensorShape) - self.assertIsInstance(linop.range_shape_tensor(), tf.Tensor) - self.assertIsInstance(linop.batch_shape, tf.TensorShape) - self.assertIsInstance(linop.batch_shape_tensor(), tf.Tensor) - self.assertAllClose(shape, linop.domain_shape) - self.assertAllClose(shape, linop.domain_shape_tensor()) - self.assertAllClose([n_points], linop.range_shape) - self.assertAllClose([n_points], linop.range_shape_tensor()) - self.assertAllClose([], linop.batch_shape) - self.assertAllClose([], linop.batch_shape_tensor()) - - # Check forward. - x = (rng.uniform(size=shape).astype(np.float32) + - rng.uniform(size=shape).astype(np.float32) * 1j) - expected_forward = fft_ops.nufft(x, traj) - if norm: - expected_forward /= np.sqrt(np.prod(shape)) - result_forward = linop.transform(x) - self.assertAllClose(expected_forward, result_forward, rtol=1e-5, atol=1e-5) - - # Check adjoint. - expected_adjoint = fft_ops.nufft(result_forward, traj, grid_shape=shape, - transform_type="type_1", - fft_direction="backward") - if norm: - expected_adjoint /= np.sqrt(np.prod(shape)) - result_adjoint = linop.transform(result_forward, adjoint=True) - self.assertAllClose(expected_adjoint, result_adjoint, rtol=1e-5, atol=1e-5) - - - @parameterized.named_parameters( - ("normalized", "ortho"), - ("unnormalized", None) - ) - def test_with_batch_dim(self, norm): - shape = [8, 12] - n_points = 100 - batch_size = 4 - traj_shape = [batch_size, n_points] - rank = 2 - rng = np.random.default_rng() - traj = rng.uniform(low=-np.pi, high=np.pi, size=(*traj_shape, rank)) - traj = traj.astype(np.float32) - linop = linalg_ops.LinearOperatorNUFFT(shape, traj, norm=norm) - - self.assertIsInstance(linop.domain_shape, tf.TensorShape) - self.assertIsInstance(linop.domain_shape_tensor(), tf.Tensor) - self.assertIsInstance(linop.range_shape, tf.TensorShape) - self.assertIsInstance(linop.range_shape_tensor(), tf.Tensor) - self.assertIsInstance(linop.batch_shape, tf.TensorShape) - self.assertIsInstance(linop.batch_shape_tensor(), tf.Tensor) - self.assertAllClose(shape, linop.domain_shape) - self.assertAllClose(shape, linop.domain_shape_tensor()) - self.assertAllClose([n_points], linop.range_shape) - self.assertAllClose([n_points], linop.range_shape_tensor()) - self.assertAllClose([batch_size], linop.batch_shape) - self.assertAllClose([batch_size], linop.batch_shape_tensor()) - - # Check forward. - x = (rng.uniform(size=shape).astype(np.float32) + - rng.uniform(size=shape).astype(np.float32) * 1j) - expected_forward = fft_ops.nufft(x, traj) - if norm: - expected_forward /= np.sqrt(np.prod(shape)) - result_forward = linop.transform(x) - self.assertAllClose(expected_forward, result_forward, rtol=1e-5, atol=1e-5) - - # Check adjoint. - expected_adjoint = fft_ops.nufft(result_forward, traj, grid_shape=shape, - transform_type="type_1", - fft_direction="backward") - if norm: - expected_adjoint /= np.sqrt(np.prod(shape)) - result_adjoint = linop.transform(result_forward, adjoint=True) - self.assertAllClose(expected_adjoint, result_adjoint, rtol=1e-5, atol=1e-5) - - - @parameterized.named_parameters( - ("normalized", "ortho"), - ("unnormalized", None) - ) - def test_with_extra_dim(self, norm): - shape = [8, 12] - n_points = 100 - batch_size = 4 - traj_shape = [batch_size, n_points] - rank = 2 - rng = np.random.default_rng() - traj = rng.uniform(low=-np.pi, high=np.pi, size=(*traj_shape, rank)) - traj = traj.astype(np.float32) - linop = linalg_ops.LinearOperatorNUFFT( - [batch_size, *shape], traj, norm=norm) - - self.assertIsInstance(linop.domain_shape, tf.TensorShape) - self.assertIsInstance(linop.domain_shape_tensor(), tf.Tensor) - self.assertIsInstance(linop.range_shape, tf.TensorShape) - self.assertIsInstance(linop.range_shape_tensor(), tf.Tensor) - self.assertIsInstance(linop.batch_shape, tf.TensorShape) - self.assertIsInstance(linop.batch_shape_tensor(), tf.Tensor) - self.assertAllClose([batch_size, *shape], linop.domain_shape) - self.assertAllClose([batch_size, *shape], linop.domain_shape_tensor()) - self.assertAllClose([batch_size, n_points], linop.range_shape) - self.assertAllClose([batch_size, n_points], linop.range_shape_tensor()) - self.assertAllClose([], linop.batch_shape) - self.assertAllClose([], linop.batch_shape_tensor()) - - # Check forward. - x = (rng.uniform(size=[batch_size, *shape]).astype(np.float32) + - rng.uniform(size=[batch_size, *shape]).astype(np.float32) * 1j) - expected_forward = fft_ops.nufft(x, traj) - if norm: - expected_forward /= np.sqrt(np.prod(shape)) - result_forward = linop.transform(x) - self.assertAllClose(expected_forward, result_forward, rtol=1e-5, atol=1e-5) - - # Check adjoint. - expected_adjoint = fft_ops.nufft(result_forward, traj, grid_shape=shape, - transform_type="type_1", - fft_direction="backward") - if norm: - expected_adjoint /= np.sqrt(np.prod(shape)) - result_adjoint = linop.transform(result_forward, adjoint=True) - self.assertAllClose(expected_adjoint, result_adjoint, rtol=1e-5, atol=1e-5) - - - def test_with_density(self): - image_shape = (128, 128) - image = image_ops.phantom(shape=image_shape, dtype=tf.complex64) - trajectory = traj_ops.radial_trajectory( - 128, 128, flatten_encoding_dims=True) - density = traj_ops.radial_density( - 128, 128, flatten_encoding_dims=True) - weights = tf.cast(tf.math.sqrt(tf.math.reciprocal_no_nan(density)), - tf.complex64) - - linop = linalg_ops.LinearOperatorNUFFT( - image_shape, trajectory=trajectory) - linop_d = linalg_ops.LinearOperatorNUFFT( - image_shape, trajectory=trajectory, density=density) - - # Test forward. - kspace = linop.transform(image) - kspace_d = linop_d.transform(image) - self.assertAllClose(kspace * weights, kspace_d) - - # Test adjoint and precompensate function. - recon = linop.transform(linop.precompensate(kspace) * weights * weights, - adjoint=True) - recon_d1 = linop_d.transform(kspace_d, adjoint=True) - recon_d2 = linop_d.transform(linop_d.precompensate(kspace), adjoint=True) - self.assertAllClose(recon, recon_d1) - self.assertAllClose(recon, recon_d2) - - -class LinearOperatorGramNUFFTTest(test_util.TestCase): - @parameterized.product( - density=[False, True], - norm=[None, 'ortho'], - toeplitz=[False, True], - batch=[False, True] - ) - def test_general(self, density, norm, toeplitz, batch): - with tf.device('/cpu:0'): - image_shape = (128, 128) - image = image_ops.phantom(shape=image_shape, dtype=tf.complex64) - trajectory = traj_ops.radial_trajectory( - 128, 129, flatten_encoding_dims=True) - if density is True: - density = traj_ops.radial_density( - 128, 129, flatten_encoding_dims=True) - else: - density = None - - # If testing batches, create new inputs to generate a batch. - if batch: - image = tf.stack([image, image * 0.5]) - trajectory = tf.stack([ - trajectory, geom_ops.rotate_2d(trajectory, [np.pi / 2])]) - if density is not None: - density = tf.stack([density, density]) - - linop = linalg_ops.LinearOperatorNUFFT( - image_shape, trajectory=trajectory, density=density, norm=norm) - linop_gram = linalg_ops.LinearOperatorGramNUFFT( - image_shape, trajectory=trajectory, density=density, norm=norm, - toeplitz=toeplitz) - - recon = linop.transform(linop.transform(image), adjoint=True) - recon_gram = linop_gram.transform(image) - - if norm is None: - # Reduce the magnitude of these values to avoid the need to use a large - # tolerance. - recon /= tf.cast(tf.math.reduce_prod(image_shape), tf.complex64) - recon_gram /= tf.cast(tf.math.reduce_prod(image_shape), tf.complex64) - - self.assertAllClose(recon, recon_gram, rtol=1e-4, atol=1e-4) - - -class LinearOperatorFiniteDifferenceTest(test_util.TestCase): - """Tests for difference linear operator.""" - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.linop1 = linalg_ops.LinearOperatorFiniteDifference([4]) - cls.linop2 = linalg_ops.LinearOperatorFiniteDifference([4, 4], axis=-2) - cls.matrix1 = tf.convert_to_tensor([[-1, 1, 0, 0], - [0, -1, 1, 0], - [0, 0, -1, 1]], dtype=tf.float32) - - def test_transform(self): - """Test transform method.""" - signal = tf.random.normal([4, 4]) - result = self.linop2.transform(signal) - self.assertAllClose(result, np.diff(signal, axis=-2)) - - def test_matvec(self): - """Test matvec method.""" - signal = tf.constant([1, 2, 4, 8], dtype=tf.float32) - result = tf.linalg.matvec(self.linop1, signal) - self.assertAllClose(result, [1, 2, 4]) - self.assertAllClose(result, np.diff(signal)) - self.assertAllClose(result, tf.linalg.matvec(self.matrix1, signal)) - - signal2 = tf.range(16, dtype=tf.float32) - result = tf.linalg.matvec(self.linop2, signal2) - self.assertAllClose(result, [4] * 12) - - def test_matvec_adjoint(self): - """Test matvec with adjoint.""" - signal = tf.constant([1, 2, 4], dtype=tf.float32) - result = tf.linalg.matvec(self.linop1, signal, adjoint_a=True) - self.assertAllClose(result, - tf.linalg.matvec(tf.transpose(self.matrix1), signal)) - - def test_shapes(self): - """Test shapes.""" - self._test_all_shapes(self.linop1, [4], [3]) - self._test_all_shapes(self.linop2, [4, 4], [3, 4]) - - def _test_all_shapes(self, linop, domain_shape, range_shape): - """Test shapes.""" - self.assertIsInstance(linop.domain_shape, tf.TensorShape) - self.assertAllEqual(linop.domain_shape, domain_shape) - self.assertAllEqual(linop.domain_shape_tensor(), domain_shape) - - self.assertIsInstance(linop.range_shape, tf.TensorShape) - self.assertAllEqual(linop.range_shape, range_shape) - self.assertAllEqual(linop.range_shape_tensor(), range_shape) - - -class LinearOperatorWaveletTest(test_util.TestCase): - @parameterized.named_parameters( - # name, wavelet, level, axes, domain_shape, range_shape - ("test0", "haar", None, None, [6, 6], [7, 7]), - ("test1", "haar", 1, None, [6, 6], [6, 6]), - ("test2", "haar", None, -1, [6, 6], [6, 7]), - ("test3", "haar", None, [-1], [6, 6], [6, 7]) - ) - def test_general(self, wavelet, level, axes, domain_shape, range_shape): - # Instantiate. - linop = linalg_ops.LinearOperatorWavelet( - domain_shape, wavelet=wavelet, level=level, axes=axes) - - # Example data. - data = np.arange(np.prod(domain_shape)).reshape(domain_shape) - data = data.astype("float32") - - # Forward and adjoint. - expected_forward, coeff_slices = wavelet_ops.coeffs_to_tensor( - wavelet_ops.wavedec(data, wavelet=wavelet, level=level, axes=axes), - axes=axes) - expected_adjoint = wavelet_ops.waverec( - wavelet_ops.tensor_to_coeffs(expected_forward, coeff_slices), - wavelet=wavelet, axes=axes) - - # Test shapes. - self.assertAllClose(domain_shape, linop.domain_shape) - self.assertAllClose(domain_shape, linop.domain_shape_tensor()) - self.assertAllClose(range_shape, linop.range_shape) - self.assertAllClose(range_shape, linop.range_shape_tensor()) - - # Test transform. - result_forward = linop.transform(data) - result_adjoint = linop.transform(result_forward, adjoint=True) - self.assertAllClose(expected_forward, result_forward) - self.assertAllClose(expected_adjoint, result_adjoint) - - def test_with_batch_inputs(self): - """Test batch shape.""" - axes = [-2, -1] - data = np.arange(4 * 8 * 8).reshape(4, 8, 8).astype("float32") - linop = linalg_ops.LinearOperatorWavelet((8, 8), wavelet="haar", level=1) - - # Forward and adjoint. - expected_forward, coeff_slices = wavelet_ops.coeffs_to_tensor( - wavelet_ops.wavedec(data, wavelet='haar', level=1, axes=axes), - axes=axes) - expected_adjoint = wavelet_ops.waverec( - wavelet_ops.tensor_to_coeffs(expected_forward, coeff_slices), - wavelet='haar', axes=axes) - - result_forward = linop.transform(data) - self.assertAllClose(expected_forward, result_forward) - - result_adjoint = linop.transform(result_forward, adjoint=True) - self.assertAllClose(expected_adjoint, result_adjoint) - - -class LinearOperatorMRITest(test_util.TestCase): - """Tests for MRI linear operator.""" - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.linop1 = linalg_ops.LinearOperatorMRI([2, 2], fft_norm=None) - cls.linop2 = linalg_ops.LinearOperatorMRI( - [2, 2], mask=[[False, False], [True, True]], fft_norm=None) - cls.linop3 = linalg_ops.LinearOperatorMRI( - [2, 2], mask=[[[True, True], [False, False]], - [[False, False], [True, True]], - [[False, True], [True, False]]], fft_norm=None) - - def test_fft(self): - """Test FFT operator.""" - # Test init. - linop = linalg_ops.LinearOperatorMRI([2, 2], fft_norm=None) - - # Test matvec. - signal = tf.constant([1, 2, 4, 4], dtype=tf.complex64) - expected = [-1, 5, 1, 11] - result = tf.linalg.matvec(linop, signal) - self.assertAllClose(expected, result) - - # Test domain shape. - self.assertIsInstance(linop.domain_shape, tf.TensorShape) - self.assertAllEqual([2, 2], linop.domain_shape) - self.assertAllEqual([2, 2], linop.domain_shape_tensor()) - - # Test range shape. - self.assertIsInstance(linop.range_shape, tf.TensorShape) - self.assertAllEqual([2, 2], linop.range_shape) - self.assertAllEqual([2, 2], linop.range_shape_tensor()) - - # Test batch shape. - self.assertIsInstance(linop.batch_shape, tf.TensorShape) - self.assertAllEqual([], linop.batch_shape) - self.assertAllEqual([], linop.batch_shape_tensor()) - - def test_fft_with_mask(self): - """Test FFT operator with mask.""" - # Test init. - linop = linalg_ops.LinearOperatorMRI( - [2, 2], mask=[[False, False], [True, True]], fft_norm=None) - - # Test matvec. - signal = tf.constant([1, 2, 4, 4], dtype=tf.complex64) - expected = [0, 0, 1, 11] - result = tf.linalg.matvec(linop, signal) - self.assertAllClose(expected, result) - - # Test domain shape. - self.assertIsInstance(linop.domain_shape, tf.TensorShape) - self.assertAllEqual([2, 2], linop.domain_shape) - self.assertAllEqual([2, 2], linop.domain_shape_tensor()) - - # Test range shape. - self.assertIsInstance(linop.range_shape, tf.TensorShape) - self.assertAllEqual([2, 2], linop.range_shape) - self.assertAllEqual([2, 2], linop.range_shape_tensor()) - - # Test batch shape. - self.assertIsInstance(linop.batch_shape, tf.TensorShape) - self.assertAllEqual([], linop.batch_shape) - self.assertAllEqual([], linop.batch_shape_tensor()) - - def test_fft_with_batch_mask(self): - """Test FFT operator with batch mask.""" - # Test init. - linop = linalg_ops.LinearOperatorMRI( - [2, 2], mask=[[[True, True], [False, False]], - [[False, False], [True, True]], - [[False, True], [True, False]]], fft_norm=None) - - # Test matvec. - signal = tf.constant([1, 2, 4, 4], dtype=tf.complex64) - expected = [[-1, 5, 0, 0], [0, 0, 1, 11], [0, 5, 1, 0]] - result = tf.linalg.matvec(linop, signal) - self.assertAllClose(expected, result) - - # Test domain shape. - self.assertIsInstance(linop.domain_shape, tf.TensorShape) - self.assertAllEqual([2, 2], linop.domain_shape) - self.assertAllEqual([2, 2], linop.domain_shape_tensor()) - - # Test range shape. - self.assertIsInstance(linop.range_shape, tf.TensorShape) - self.assertAllEqual([2, 2], linop.range_shape) - self.assertAllEqual([2, 2], linop.range_shape_tensor()) - - # Test batch shape. - self.assertIsInstance(linop.batch_shape, tf.TensorShape) - self.assertAllEqual([3], linop.batch_shape) - self.assertAllEqual([3], linop.batch_shape_tensor()) - - def test_fft_norm(self): - """Test FFT normalization.""" - linop = linalg_ops.LinearOperatorMRI([2, 2], fft_norm='ortho') - x = tf.constant([1 + 2j, 2 - 2j, -1 - 6j, 3 + 4j], dtype=tf.complex64) - # With norm='ortho', subsequent application of the operator and its adjoint - # should not scale the input. - y = tf.linalg.matvec(linop.H, tf.linalg.matvec(linop, x)) - self.assertAllClose(x, y) - - def test_nufft_with_sensitivities(self): - resolution = 128 - image_shape = [resolution, resolution] - num_coils = 4 - image, sensitivities = image_ops.phantom( - shape=image_shape, num_coils=num_coils, dtype=tf.complex64, - return_sensitivities=True) - image = image_ops.phantom(shape=image_shape, dtype=tf.complex64) - trajectory = traj_ops.radial_trajectory(resolution, resolution // 2 + 1, - flatten_encoding_dims=True) - density = traj_ops.radial_density(resolution, resolution // 2 + 1, - flatten_encoding_dims=True) - - linop = linalg_ops.LinearOperatorMRI( - image_shape, trajectory=trajectory, density=density, - sensitivities=sensitivities) - - # Test shapes. - expected_domain_shape = image_shape - self.assertAllClose(expected_domain_shape, linop.domain_shape) - self.assertAllClose(expected_domain_shape, linop.domain_shape_tensor()) - expected_range_shape = [num_coils, (2 * resolution) * (resolution // 2 + 1)] - self.assertAllClose(expected_range_shape, linop.range_shape) - self.assertAllClose(expected_range_shape, linop.range_shape_tensor()) - - # Test forward. - weights = tf.cast(tf.math.sqrt(tf.math.reciprocal_no_nan(density)), - tf.complex64) - norm = tf.math.sqrt(tf.cast(tf.math.reduce_prod(image_shape), tf.complex64)) - expected = fft_ops.nufft(image * sensitivities, trajectory) * weights / norm - kspace = linop.transform(image) - self.assertAllClose(expected, kspace) - - # Test adjoint. - expected = tf.math.reduce_sum( - fft_ops.nufft( - kspace * weights, trajectory, grid_shape=image_shape, - transform_type='type_1', fft_direction='backward') / norm * - tf.math.conj(sensitivities), axis=-3) - recon = linop.transform(kspace, adjoint=True) - self.assertAllClose(expected, recon) - - -class LinearOperatorGramMRITest(test_util.TestCase): - @parameterized.product(batch=[False, True], extra=[False, True], - toeplitz_nufft=[False, True]) - def test_general(self, batch, extra, toeplitz_nufft): - resolution = 128 - image_shape = [resolution, resolution] - num_coils = 4 - image, sensitivities = image_ops.phantom( - shape=image_shape, num_coils=num_coils, dtype=tf.complex64, - return_sensitivities=True) - image = image_ops.phantom(shape=image_shape, dtype=tf.complex64) - trajectory = traj_ops.radial_trajectory(resolution, resolution // 2 + 1, - flatten_encoding_dims=True) - density = traj_ops.radial_density(resolution, resolution // 2 + 1, - flatten_encoding_dims=True) - if batch: - image = tf.stack([image, image * 2]) - if extra: - extra_shape = [2] - else: - extra_shape = None - else: - extra_shape = None - - linop = linalg_ops.LinearOperatorMRI( - image_shape, extra_shape=extra_shape, - trajectory=trajectory, density=density, - sensitivities=sensitivities) - linop_gram = linalg_ops.LinearOperatorGramMRI( - image_shape, extra_shape=extra_shape, - trajectory=trajectory, density=density, - sensitivities=sensitivities, toeplitz_nufft=toeplitz_nufft) - - # Test shapes. - expected_domain_shape = image_shape - if extra_shape is not None: - expected_domain_shape = extra_shape + image_shape - self.assertAllClose(expected_domain_shape, linop_gram.domain_shape) - self.assertAllClose(expected_domain_shape, linop_gram.domain_shape_tensor()) - self.assertAllClose(expected_domain_shape, linop_gram.range_shape) - self.assertAllClose(expected_domain_shape, linop_gram.range_shape_tensor()) - - # Test transform. - expected = linop.transform(linop.transform(image), adjoint=True) - self.assertAllClose(expected, linop_gram.transform(image), - rtol=1e-4, atol=1e-4) - - -# Copyright 2019 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. -# ============================================================================== - -@test_util.run_all_in_graph_and_eager_modes -class ConjugateGradientTest(test_util.TestCase): - """Tests for op `conjugate_gradient`.""" - @parameterized.product(dtype=[np.float32, np.float64], - shape=[[1, 1], [4, 4], [10, 10]], - use_static_shape=[True, False]) - def test_conjugate_gradient(self, dtype, shape, use_static_shape): # pylint: disable=missing-param-doc - """Test CG method.""" - np.random.seed(1) - a_np = np.random.uniform( - low=-1.0, high=1.0, size=np.prod(shape)).reshape(shape).astype(dtype) - # Make a self-adjoint, positive definite. - a_np = np.dot(a_np.T, a_np) - # jacobi preconditioner - jacobi_np = np.zeros_like(a_np) - jacobi_np[range(a_np.shape[0]), range(a_np.shape[1])] = ( - 1.0 / a_np.diagonal()) - rhs_np = np.random.uniform( - low=-1.0, high=1.0, size=shape[0]).astype(dtype) - x_np = np.zeros_like(rhs_np) - tol = 1e-6 if dtype == np.float64 else 1e-3 - max_iterations = 20 - - if use_static_shape: - a = tf.constant(a_np) - rhs = tf.constant(rhs_np) - x = tf.constant(x_np) - jacobi = tf.constant(jacobi_np) - else: - a = tf.compat.v1.placeholder_with_default(a_np, shape=None) - rhs = tf.compat.v1.placeholder_with_default(rhs_np, shape=None) - x = tf.compat.v1.placeholder_with_default(x_np, shape=None) - jacobi = tf.compat.v1.placeholder_with_default(jacobi_np, shape=None) - - operator = tf.linalg.LinearOperatorFullMatrix( - a, is_positive_definite=True, is_self_adjoint=True) - preconditioners = [ - None, - # Preconditioner that does nothing beyond change shape. - tf.linalg.LinearOperatorIdentity( - a_np.shape[-1], - dtype=a_np.dtype, - is_positive_definite=True, - is_self_adjoint=True), - # Jacobi preconditioner. - tf.linalg.LinearOperatorFullMatrix( - jacobi, - is_positive_definite=True, - is_self_adjoint=True), - ] - cg_results = [] - for preconditioner in preconditioners: - cg_graph = linalg_ops.conjugate_gradient( - operator, - rhs, - preconditioner=preconditioner, - x=x, - tol=tol, - max_iterations=max_iterations) - cg_val = self.evaluate(cg_graph) - norm_r0 = np.linalg.norm(rhs_np) - norm_r = np.linalg.norm(cg_val.r) - self.assertLessEqual(norm_r, tol * norm_r0) - # Validate that we get an equally small residual norm with numpy - # using the computed solution. - r_np = rhs_np - np.dot(a_np, cg_val.x) - norm_r_np = np.linalg.norm(r_np) - self.assertLessEqual(norm_r_np, tol * norm_r0) - cg_results.append(cg_val) - - # Validate that we get same results using identity_preconditioner - # and None - self.assertEqual(cg_results[0].i, cg_results[1].i) - self.assertAlmostEqual(cg_results[0].gamma, cg_results[1].gamma) - self.assertAllClose(cg_results[0].r, cg_results[1].r, rtol=tol) - self.assertAllClose(cg_results[0].x, cg_results[1].x, rtol=tol) - self.assertAllClose(cg_results[0].p, cg_results[1].p, rtol=tol) - - def test_bypass_gradient(self): - """Tests the `bypass_gradient` argument.""" - dtype = np.float32 - shape = [4, 4] - np.random.seed(1) - a_np = np.random.uniform( - low=-1.0, high=1.0, size=np.prod(shape)).reshape(shape).astype(dtype) - # Make a self-adjoint, positive definite. - a_np = np.dot(a_np.T, a_np) - - rhs_np = np.random.uniform( - low=-1.0, high=1.0, size=shape[0]).astype(dtype) - - tol = 1e-3 - max_iterations = 20 - - a = tf.constant(a_np) - rhs = tf.constant(rhs_np) - operator = tf.linalg.LinearOperatorFullMatrix( - a, is_positive_definite=True, is_self_adjoint=True) - - with tf.GradientTape(persistent=True) as tape: - tape.watch(rhs) - result = linalg_ops.conjugate_gradient( - operator, - rhs, - tol=tol, - max_iterations=max_iterations) - result_bypass = linalg_ops.conjugate_gradient( - operator, - rhs, - tol=tol, - max_iterations=max_iterations, - bypass_gradient=True) - - grad = tape.gradient(result.x, rhs) - grad_bypass = tape.gradient(result_bypass.x, rhs) - self.assertAllClose(result, result_bypass) - self.assertAllClose(grad, grad_bypass, rtol=tol) - - -if __name__ == '__main__': - tf.test.main() diff --git a/tensorflow_mri/python/ops/optimizer_ops.py b/tensorflow_mri/python/ops/optimizer_ops.py index 05367749..5430c73c 100644 --- a/tensorflow_mri/python/ops/optimizer_ops.py +++ b/tensorflow_mri/python/ops/optimizer_ops.py @@ -23,8 +23,8 @@ import tensorflow as tf import tensorflow_probability as tfp +from tensorflow_mri.python.linalg import conjugate_gradient from tensorflow_mri.python.ops import convex_ops -from tensorflow_mri.python.ops import linalg_ops from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import linalg_ext from tensorflow_mri.python.util import prefer_static @@ -508,7 +508,7 @@ def _update_fn(v, rho): # pylint: disable=function-redefined rhs = (rho * tf.linalg.matvec(operator, v, adjoint_a=True) - function.linear_coefficient) # Solve the linear system using CG (see ref [1], section 4.3.4). - return linalg_ops.conjugate_gradient(ls_operator, rhs, **solver_kwargs).x + return conjugate_gradient.conjugate_gradient(ls_operator, rhs, **solver_kwargs).x return _update_fn diff --git a/tensorflow_mri/python/ops/recon_ops.py b/tensorflow_mri/python/ops/recon_ops.py index 7209e557..3f8b8140 100644 --- a/tensorflow_mri/python/ops/recon_ops.py +++ b/tensorflow_mri/python/ops/recon_ops.py @@ -22,19 +22,21 @@ import tensorflow as tf +from tensorflow_mri.python.linalg import conjugate_gradient +from tensorflow_mri.python.linalg import linear_operator_gram_matrix +from tensorflow_mri.python.linalg import linear_operator_gram_mri +from tensorflow_mri.python.linalg import linear_operator_mri from tensorflow_mri.python.ops import array_ops from tensorflow_mri.python.ops import coil_ops from tensorflow_mri.python.ops import convex_ops from tensorflow_mri.python.ops import fft_ops from tensorflow_mri.python.ops import image_ops -from tensorflow_mri.python.ops import linalg_ops from tensorflow_mri.python.ops import math_ops from tensorflow_mri.python.ops import optimizer_ops from tensorflow_mri.python.ops import signal_ops from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util from tensorflow_mri.python.util import deprecation -from tensorflow_mri.python.util import linalg_imaging @api_util.export("recon.adjoint", "recon.adj") @@ -118,14 +120,14 @@ def reconstruct_adj(kspace, kspace = tf.convert_to_tensor(kspace) # Create the linear operator. - operator = linalg_ops.LinearOperatorMRI(image_shape, - mask=mask, - trajectory=trajectory, - density=density, - sensitivities=sensitivities, - phase=phase, - fft_norm='ortho', - sens_norm=sens_norm) + operator = linear_operator_mri.LinearOperatorMRI(image_shape, + mask=mask, + trajectory=trajectory, + density=density, + sensitivities=sensitivities, + phase=phase, + fft_norm='ortho', + sens_norm=sens_norm) rank = operator.rank # Apply density compensation, if provided. @@ -321,21 +323,21 @@ def reconstruct_lstsq(kspace, kspace = tf.convert_to_tensor(kspace) # Create the linear operator. - operator = linalg_ops.LinearOperatorMRI(image_shape, - extra_shape=extra_shape, - mask=mask, - trajectory=trajectory, - density=density, - sensitivities=sensitivities, - phase=phase, - fft_norm='ortho', - sens_norm=sens_norm, - dynamic_domain=dynamic_domain) + operator = linear_operator_mri.LinearOperatorMRI(image_shape, + extra_shape=extra_shape, + mask=mask, + trajectory=trajectory, + density=density, + sensitivities=sensitivities, + phase=phase, + fft_norm='ortho', + sens_norm=sens_norm, + dynamic_domain=dynamic_domain) rank = operator.rank # If using Toeplitz NUFFT, we need to use the specialized Gram MRI operator. if toeplitz_nufft and operator.is_non_cartesian: - gram_operator = linalg_ops.LinearOperatorGramMRI( + gram_operator = linear_operator_gram_mri.LinearOperatorGramMRI( image_shape, extra_shape=extra_shape, mask=mask, @@ -372,7 +374,7 @@ def reconstruct_lstsq(kspace, reg_operator = None reg_prior = None - operator_gm = linalg_imaging.LinearOperatorGramMatrix( + operator_gm = linear_operator_gram_matrix.LinearOperatorGramMatrix( operator, reg_parameter=reg_parameter, reg_operator=reg_operator, gram_operator=gram_operator) rhs = initial_image @@ -383,7 +385,8 @@ def reconstruct_lstsq(kspace, reg_operator.transform(reg_prior), adjoint=True) rhs += tf.cast(reg_parameter, reg_prior.dtype) * reg_prior # Solve the (maybe regularized) linear system. - result = linalg_ops.conjugate_gradient(operator_gm, rhs, **optimizer_kwargs) + result = conjugate_gradient.conjugate_gradient( + operator_gm, rhs, **optimizer_kwargs) image = result.x elif optimizer == 'admm': diff --git a/tensorflow_mri/python/util/__init__.py b/tensorflow_mri/python/util/__init__.py index 94afc4c7..9a30f059 100644 --- a/tensorflow_mri/python/util/__init__.py +++ b/tensorflow_mri/python/util/__init__.py @@ -22,7 +22,6 @@ from tensorflow_mri.python.util import keras_util from tensorflow_mri.python.util import layer_util from tensorflow_mri.python.util import linalg_ext -from tensorflow_mri.python.util import linalg_imaging from tensorflow_mri.python.util import math_util from tensorflow_mri.python.util import model_util from tensorflow_mri.python.util import nest_util diff --git a/tools/build/create_api.py b/tools/build/create_api.py index a8cebd76..cdc3082b 100644 --- a/tools/build/create_api.py +++ b/tools/build/create_api.py @@ -44,7 +44,6 @@ from tensorflow_mri.python.ops.fft_ops import * from tensorflow_mri.python.ops.geom_ops import * from tensorflow_mri.python.ops.image_ops import * -from tensorflow_mri.python.ops.linalg_ops import * from tensorflow_mri.python.ops.math_ops import * from tensorflow_mri.python.ops.optimizer_ops import * from tensorflow_mri.python.ops.recon_ops import * diff --git a/tools/docs/tutorials/recon/unet_fastmri.ipynb b/tools/docs/tutorials/recon/unet_fastmri.ipynb new file mode 100644 index 00000000..bf3bd783 --- /dev/null +++ b/tools/docs/tutorials/recon/unet_fastmri.ipynb @@ -0,0 +1,130 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train a baseline U-Net on the fastMRI dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import functools\n", + "import glob\n", + "\n", + "import tensorflow as tf\n", + "import tensorflow_io as tfio" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# If necessary, change the path names here.\n", + "data_path_train = \"fastmri/brain_multicoil_train\"\n", + "data_path_val = \"fastmri/brain_multicoil_val\"\n", + "data_path_test = \"fastmri/brain_multicoil_test\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "files_train = glob.glob(\"*.h5\", root_dir=data_path_train)\n", + "files_val = glob.glob(\"*.h5\", root_dir=data_path_val)\n", + "files_test = glob.glob(\"*.h5\", root_dir=data_path_test)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def read_hdf5(filename, spec=None):\n", + " \"\"\"Reads an HDF file into a `dict` of `tf.Tensor`s.\n", + "\n", + " Args:\n", + " filename: A string, the filename of an HDF5 file.\n", + " spec: A dict of `dataset:tf.TensorSpec` or `dataset:dtype`\n", + " pairs that specify the HDF5 dataset selected and the `tf.TensorSpec`\n", + " or dtype of the dataset. In eager mode the spec is probed\n", + " automatically. In graph mode `spec` has to be specified.\n", + " \"\"\"\n", + " io_tensor = tfio.IOTensor.from_hdf5(filename, spec=spec)\n", + " tensors = {k: io_tensor(k).to_tensor() for k in io_tensor.keys}\n", + " return {k: tf.ensure_shape(v, spec[k].shape) for k, v in tensors.items()}\n", + "\n", + "def create_fastmri_dataset(files,\n", + " element_spec=None,\n", + " batch_size=1,\n", + " shuffle=False):\n", + " \"\"\"Creates a `tf.data.Dataset` from a list of fastMRI HDF5 files.\n", + " \n", + " Args:\n", + " files: A list of strings, the filenames of the HDF5 files.\n", + " element_spec: The spec of an element of the dataset. See `read_hdf5` for\n", + " more details.\n", + " batch_size: An int, the batch size.\n", + " shuffle: A boolean, whether to shuffle the dataset.\n", + " \"\"\"\n", + " # Make a `tf.data.Dataset` from the list of files.\n", + " ds = tf.data.Dataset.from_tensor_slices(files)\n", + " # Read the k-space data from the file.\n", + " ds = ds.map(functools.partial(read_hdf5, spec=element_spec))\n", + " # The first dimension of the inputs is the slice dimension. Split each\n", + " # multi-slice element into multiple single-slice elements, as the\n", + " # reconstruction is performed on a slice-by-slice basis.\n", + " split_slices = lambda x: tf.data.Dataset.from_tensor_slices(x)\n", + " ds = ds.flat_map(split_slices)\n", + " # TODO: create mask.\n", + "\n", + " # TODO: create labels.\n", + " if shuffle:\n", + " ds = ds.shuffle(buffer_size=100)\n", + " # Batch the elements.\n", + " ds = ds.batch(batch_size)\n", + " ds = ds.prefetch(buffer_size=tf.data.AUTOTUNE)\n", + " return ds" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model = tf.keras.Sequential([\n", + " \n", + "])" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.2 64-bit", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.8.2" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "0adcc2737ebf6a4a119f135174df96668767fca1ef1112612db5ecadf2b6d608" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tools/docs/tutorials/recon/varnet.ipynb b/tools/docs/tutorials/recon/varnet.ipynb new file mode 100644 index 00000000..babe3233 --- /dev/null +++ b/tools/docs/tutorials/recon/varnet.ipynb @@ -0,0 +1,37 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Image reconstruction with variational network (VarNet)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.2 64-bit", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.8.2" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "0adcc2737ebf6a4a119f135174df96668767fca1ef1112612db5ecadf2b6d608" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 6a08ec33405b0180474598ed84b325b423b7752f Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Mon, 1 Aug 2022 11:47:17 +0000 Subject: [PATCH 006/101] Tests for LeastSquaresGradientDescent layer --- RELEASE.rst | 41 +----- tensorflow_mri/__about__.py | 2 +- .../python/layers/data_consistency.py | 120 +++++++-------- .../python/layers/data_consistency_test.py | 137 ++++++++++++++---- .../python/linalg/linear_operator.py | 6 + tensorflow_mri/python/ops/traj_ops.py | 6 +- tools/docs/guide/fft.ipynb | 10 +- 7 files changed, 187 insertions(+), 135 deletions(-) diff --git a/RELEASE.rst b/RELEASE.rst index ce299918..9b89b8dd 100644 --- a/RELEASE.rst +++ b/RELEASE.rst @@ -1,56 +1,21 @@ -Release 0.21.0 +Release 0.22.0 ============== -This release contains new functionality for wavelet decomposition and -reconstruction and optimized Gram matrices for some linear operators. It also -redesigns the convex optimization module and contains some improvements to the -documentation. + Breaking Changes ---------------- -* ``tfmri.convex``: - * Argument ``ndim`` has been removed from all functions. - * All functions will now require the domain dimension to be - specified. Therefore, `domain_dimension` is now the first positional - argument in several functions including ``ConvexFunctionIndicatorBall``, - ``ConvexFunctionNorm`` and ``ConvexFunctionTotalVariation``. However, while - this parameter is no longer optional, it is now possible to pass dynamic - or static information as opposed to static only (at least in the general - case, but specific operators may have additional restrictions). - * For consistency and accuracy, argument ``axis`` of - ``ConvexFunctionTotalVariation`` has been renamed to ``axes``. Major Features and Improvements ------------------------------- -* ``tfmri.convex``: - - * Added new class ``ConvexFunctionL1Wavelet``, which enables image/signal - reconstruction with L1-wavelet regularization. - * Added new argument ``gram_operator`` to ``ConvexFunctionLeastSquares``, - which allows the user to specify a custom, potentially more efficient Gram - matrix. - -* ``tfmri.linalg``: - - * Added new classes ``LinearOperatorNUFFT`` and ``LinearOperatorGramNUFFT`` - to enable the use of NUFFT as a linear operator. - * Added new class ``LinearOperatorWavelet`` to enable the use of wavelets - as a linear operator. - * ``tfmri.sampling``: - * Added new ordering type ``sorted_half`` to ``radial_trajectory``. - -* ``tfmri.signal``: - - * Added new functions ``wavedec`` and ``waverec`` for wavelet decomposition - and reconstruction, as well as utilities ``wavelet_coeffs_to_tensor``, - ``tensor_to_wavelet_coeffs``, and ``max_wavelet_level``. + * Added operator ``spiral_waveform`` to public API. Bug Fixes and Other Changes diff --git a/tensorflow_mri/__about__.py b/tensorflow_mri/__about__.py index c60e01a2..10384209 100644 --- a/tensorflow_mri/__about__.py +++ b/tensorflow_mri/__about__.py @@ -29,7 +29,7 @@ __summary__ = "A collection of TensorFlow add-ons for computational MRI." __uri__ = "https://github.com/mrphys/tensorflow-mri" -__version__ = "0.21.0" +__version__ = "0.22.0" __author__ = "Javier Montalt Tordera" __email__ = "javier.montalt@outlook.com" diff --git a/tensorflow_mri/python/layers/data_consistency.py b/tensorflow_mri/python/layers/data_consistency.py index 60c96536..111924f0 100644 --- a/tensorflow_mri/python/layers/data_consistency.py +++ b/tensorflow_mri/python/layers/data_consistency.py @@ -14,114 +14,106 @@ # ============================================================================== """Data consistency layers.""" +import inspect + import tensorflow as tf from tensorflow_mri.python.linalg import linear_operator -class LeastSquaresGradientDescentStep(tf.keras.layers.Layer): - +class LeastSquaresGradientDescent(tf.keras.layers.Layer): + """Least squares gradient descent layer. + """ def __init__(self, operator, scale_initializer=1.0, dtype=None, **kwargs): - - if not isinstance(operator, linear_operator.LinearOperator): + if isinstance(operator, linear_operator.LinearOperator): + # operator is a class instance. + self.operator = operator + self._operator_is_class = False + self._operator_is_instance = True + elif (inspect.isclass(operator) and + issubclass(operator, linear_operator.LinearOperator)): + # operator is a class. + self.operator = operator + self._operator_is_class = True + self._operator_is_instance = False + else: raise TypeError( - f"operator must be a `tfmri.linalg.LinearOperator` or a subclass " - f"thereof, but got type: {type(operator)}") - self.operator = operator + f"operator must be a subclass of `tfmri.linalg.LinearOperator` " + f"or an instance thereof, but got type: {type(operator)}") + if isinstance(scale_initializer, (float, int)): self.scale_initializer = tf.keras.initializers.Constant(scale_initializer) else: self.scale_initializer = tf.keras.initializers.get(scale_initializer) - if dtype is not None: - if tf.as_dtype(dtype) != self.operator.dtype: - raise ValueError( - f"dtype must be the same as the operator's dtype, but got " - f"dtype: {dtype} and operator's dtype: {self.operator.dtype}") - else: - dtype = self.operator.dtype + + if self._operator_is_instance: + if dtype is not None: + if tf.as_dtype(dtype) != self.operator.dtype: + raise ValueError( + f"dtype must be the same as the operator's dtype, but got " + f"dtype: {dtype} and operator's dtype: {self.operator.dtype}") + else: + dtype = self.operator.dtype + super().__init__(dtype=dtype, **kwargs) def build(self, input_shape): self.scale = self.add_weight( name='scale', shape=(), - dtype=self.dtype.real_dtype, + dtype=tf.as_dtype(self.dtype).real_dtype, initializer=self.scale_initializer, trainable=self.trainable, constraint=tf.keras.constraints.NonNeg()) super().build(input_shape) def call(self, inputs): - x, y, args, kwargs = self._parse_inputs(inputs) - if args or kwargs: - raise ValueError( - f"unexpected arguments in call when GradientDescentStep has a " - f"predefined operator: {args}, {kwargs}") - operator = self.operator - return x - self.scale * operator.transform( - operator.transform(x) - y, adjoint=True) + x, b, args, kwargs = self._parse_inputs(inputs) + if self._operator_is_class: + # operator is a class. Instantiate using any additional arguments. + operator = self.operator(*args, **kwargs) + else: + # operator is an instance, so we can use it directly. + if args or kwargs: + raise ValueError( + f"unexpected arguments in call when linear operator is a class " + f"instance: {args}, {kwargs}") + operator = self.operator + return x - tf.cast(self.scale, self.dtype) * operator.transform( + operator.transform(x) - b, adjoint=True) def _parse_inputs(self, inputs): + """Parses the inputs to the call method.""" if isinstance(inputs, dict): - if 'x' not in inputs or 'y' not in inputs: + if 'x' not in inputs or 'b' not in inputs: raise ValueError( f"inputs dictionary must at least contain the keys 'x' and " - f"'y', but got keys: {inputs.keys()}") - x = inputs.pop('x') - y = inputs.pop('y') - args, kwargs = (), inputs + f"'b', but got keys: {inputs.keys()}") + x = inputs['x'] + b = inputs['b'] + args, kwargs = (), {k: v for k, v in inputs.items() + if k not in {'x', 'b'}} elif isinstance(inputs, tuple): if len(inputs) < 2: raise ValueError( f"inputs tuple must contain at least two elements, " - f"x and y, but got tuple with length: {len(inputs)}") + f"x and b, but got tuple with length: {len(inputs)}") x = inputs[0] - y = inputs[1] + b = inputs[1] args, kwargs = inputs[2:], {} else: raise TypeError("inputs must be a tuple or a dictionary.") - return x, y, args, kwargs + return x, b, args, kwargs def get_config(self): config = { 'operator': self.operator, - 'scale_initializer': tf.keras.initializers.serialize(self.scale_initializer) + 'scale_initializer': tf.keras.initializers.serialize( + self.scale_initializer) } base_config = super().get_config() return {**config, **base_config} - - # @classmethod - # def from_config(cls, config): - # config = config.copy() - # operator = deserialize_linear_operator(config.pop('operator')) - # return cls(operator, **config) - - - -# def serialize_linear_operator(operator): -# if isinstance(operator, linear_operator.LinearOperator): -# return { -# 'class_name': operator.__class__.__name__, -# 'config': operator.parameters -# } -# raise TypeError( -# f"operator must be a `tfmri.linalg.LinearOperator` or a subclass " -# f"thereof, but got type: {type(operator)}") - - -# def deserialize_linear_operator(config): -# if (not isinstance(config, dict) or -# set(config.keys()) != {'class_name', 'config'}): -# raise ValueError( -# f"config must be a dictionary with keys 'class_name' and 'config', " -# f"but got: {config}") -# class_name = config['class_name'] -# config = config['config'] -# if class_name == 'LinearOperator': -# return linear_operator.LinearOperator(**config) -# raise ValueError( -# f"unexpected class name in serialized linear operator: {class_name}") diff --git a/tensorflow_mri/python/layers/data_consistency_test.py b/tensorflow_mri/python/layers/data_consistency_test.py index cbf4c544..d0e3135f 100644 --- a/tensorflow_mri/python/layers/data_consistency_test.py +++ b/tensorflow_mri/python/layers/data_consistency_test.py @@ -14,38 +14,119 @@ # ============================================================================== """Tests for data consistency layers.""" +import tempfile + +from absl.testing import parameterized import tensorflow as tf -from tensorflow.python.ops.linalg import linear_operator from tensorflow_mri.python.layers import data_consistency from tensorflow_mri.python.linalg import linear_operator from tensorflow_mri.python.util import test_util -class LeastSquaresGradientDescentStepTest(test_util.TestCase): - def test_general(self): - @linear_operator.make_composite_tensor - class LinearOperatorScalarMultiply(linear_operator.LinearOperator): - def __init__(self, scale): - parameters = {'scale': scale} - self.scale = tf.convert_to_tensor(scale) - super().__init__(dtype=self.scale.dtype, parameters=parameters) - - def _transform(self, x, adjoint=False): - if adjoint: - return x * tf.math.conj(self.scale) - else: - return x * self.scale - - def _domain_shape(self): - return tf.TensorShape([2]) - - def _range_shape(self): - return self._domain_shape() - - operator = LinearOperatorScalarMultiply(2.0 + 1.0j) - layer = data_consistency.LeastSquaresGradientDescentStep(operator) - - inputs = [3, 3], [1, 1] - result = layer(inputs) - print(result) +class LeastSquaresGradientDescentTest(test_util.TestCase): + @parameterized.product(operator_type=['class', 'instance'], + input_type=['dict', 'tuple']) + def test_general(self, operator_type, input_type): + scale = tf.constant(2.0, dtype=tf.float32) + dtype = tf.complex64 + if operator_type == 'class': + # Operator is a class. + class LinearOperatorScalarMultiplyComplex64(LinearOperatorScalarMultiply): + # Same as `LinearOperatorScalarMultiply` but dtype is tf.complex64. + def __init__(self, *args, **kwargs): + if 'dtype' in kwargs: + raise ValueError('dtype is not allowed in this class.') + kwargs['dtype'] = tf.complex64 + super().__init__(*args, **kwargs) + + operator = LinearOperatorScalarMultiplyComplex64 + args = (tf.expand_dims(scale, axis=0),) + kwargs = {'scale': tf.expand_dims(scale, axis=0)} + else: + # Operator is an instance. + operator = LinearOperatorScalarMultiply(scale, dtype=dtype) + args, kwargs = (), {} + + # Initialize layer. + layer = data_consistency.LeastSquaresGradientDescent( + operator, scale_initializer=0.5, dtype=dtype) + + # All variables have a batch dimension. + x = tf.constant([[3, 3]], dtype=dtype) + b = tf.constant([[1, 1]], dtype=dtype) + expected_output = tf.constant([[-2.0 + 0.0j, -2.0 + 0.0j]], dtype=dtype) + + # Create input data. + if input_type == 'dict': + input_data = {'x': x, 'b': b} + input_data.update(kwargs) + else: + input_data = (x, b) + input_data += args + + # Test layer. + output = layer(input_data) + self.assertAllClose(expected_output, output) + + # Test serialization. + layer_config = layer.get_config() + layer = data_consistency.LeastSquaresGradientDescent.from_config( + layer_config) + + # Test layer with tuple inputs. + output = layer(input_data) + self.assertAllClose(expected_output, output) + + # Test layer in a model. + inputs = tf.nest.map_structure( + lambda x: tf.keras.Input(shape=x.shape[1:], dtype=x.dtype), + input_data) + model = tf.keras.Model(inputs=inputs, outputs=layer(inputs)) + output = model(input_data) + self.assertAllClose(expected_output, output) + + # Test training. + model.compile(optimizer='sgd', loss='mse') + model.fit(input_data, expected_output * 2) + expected_weights = [0.9] + expected_output = tf.constant([[-6.0 + 0.0j, -6.0 + 0.0j]], + dtype=tf.complex64) + self.assertAllClose(expected_weights, model.get_weights()) + self.assertAllClose(expected_output, model(input_data)) + + # Test model saving. + with tempfile.TemporaryDirectory() as tmpdir: + model.save(tmpdir + '/model') + model = tf.keras.models.load_model(tmpdir + '/model') + output = model(input_data) + self.assertAllClose(expected_output, output) + + +@linear_operator.make_composite_tensor +class LinearOperatorScalarMultiply(linear_operator.LinearOperator): + def __init__(self, scale, dtype=None, **kwargs): + parameters = {'scale': scale} + self.scale = tf.convert_to_tensor(scale) + super().__init__(dtype=dtype or self.scale.dtype, + parameters=parameters, + **kwargs) + + def _transform(self, x, adjoint=False): + if adjoint: + return x * tf.math.conj(tf.cast(self.scale, x.dtype)) + else: + return x * tf.cast(self.scale, x.dtype) + + def _domain_shape(self): + return tf.TensorShape([2]) + + def _range_shape(self): + return self._domain_shape() + + def _batch_shape(self): + return self.scale.shape[:-1] + + @property + def _composite_tensor_fields(self): + return ('scale',) diff --git a/tensorflow_mri/python/linalg/linear_operator.py b/tensorflow_mri/python/linalg/linear_operator.py index b5853e35..a2e6ed09 100644 --- a/tensorflow_mri/python/linalg/linear_operator.py +++ b/tensorflow_mri/python/linalg/linear_operator.py @@ -15,8 +15,10 @@ """Base linear operator.""" import abc +import functools import tensorflow as tf +from tensorflow.python.ops.linalg import linear_operator from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import tensor_util @@ -409,3 +411,7 @@ def _range_shape_tensor(self): def _batch_shape_tensor(self): return self.operator.batch_shape_tensor() + + +make_composite_tensor = functools.partial( + linear_operator.make_composite_tensor, module_name="tfmri.linalg") diff --git a/tensorflow_mri/python/ops/traj_ops.py b/tensorflow_mri/python/ops/traj_ops.py index 59cd3ccc..ce224cb4 100755 --- a/tensorflow_mri/python/ops/traj_ops.py +++ b/tensorflow_mri/python/ops/traj_ops.py @@ -660,7 +660,11 @@ def radial_waveform(base_resolution, readout_os=2.0, rank=2): if sys_util.is_op_library_enabled(): - spiral_waveform = _mri_ops.spiral_waveform + spiral_waveform = api_util.export("sampling.spiral_waveform")( + _mri_ops.spiral_waveform) +else: + # Stub to prevent import errors when the op is not available. + spiral_waveform = None def _trajectory_angles(views, diff --git a/tools/docs/guide/fft.ipynb b/tools/docs/guide/fft.ipynb index f8608e63..311da510 100644 --- a/tools/docs/guide/fft.ipynb +++ b/tools/docs/guide/fft.ipynb @@ -8,6 +8,10 @@ "\n", "TensorFlow MRI uses the built-in FFT ops in core TensorFlow. These are [`tf.signal.fft`](https://www.tensorflow.org/api_docs/python/tf/signal/fft), [`tf.signal.fft2d`](https://www.tensorflow.org/api_docs/python/tf/signal/fft2d) and [`tf.signal.fft3d`](https://www.tensorflow.org/api_docs/python/tf/signal/fft3d).\n", "\n", + "## N-dimensional FFT\n", + "\n", + "For convenience, TensorFlow MRI also provides [`tfmri.signal.fft`](https://mrphys.github.io/tensorflow-mri/api_docs/tfmri/signal/fft/), which can be used for N-dimensional FFT calculations and provides convenient access to commonly used functionality such as padding/cropping, normalization and shifting of the zero-frequency component within the same function call.\n", + "\n", "## Custom FFT kernels for CPU\n", "\n", "Unfortunately, TensorFlow's FFT ops are [known to be slow](https://github.com/tensorflow/tensorflow/issues/6541) on CPU. As a result, the FFT can become a significant bottleneck on MRI processing pipelines, especially on iterative reconstructions where the FFT is called repeatedly.\n", @@ -38,18 +42,18 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.10 64-bit", + "display_name": "Python 3.8.2 64-bit", "language": "python", "name": "python3" }, "language_info": { "name": "python", - "version": "3.8.10" + "version": "3.8.2" }, "orig_nbformat": 4, "vscode": { "interpreter": { - "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1" + "hash": "0adcc2737ebf6a4a119f135174df96668767fca1ef1112612db5ecadf2b6d608" } } }, From 924add9104f65949c689ef3af9f9bebae2d4b694 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Tue, 2 Aug 2022 09:46:34 +0000 Subject: [PATCH 007/101] FFT multi-threading --- tensorflow_mri/cc/kernels/fft_kernels.cc | 38 ++++++++++++--- tools/docs/tutorials/recon/unet_fastmri.ipynb | 46 +++++++++++++++++-- 2 files changed, 74 insertions(+), 10 deletions(-) diff --git a/tensorflow_mri/cc/kernels/fft_kernels.cc b/tensorflow_mri/cc/kernels/fft_kernels.cc index 373835e3..05c89afd 100644 --- a/tensorflow_mri/cc/kernels/fft_kernels.cc +++ b/tensorflow_mri/cc/kernels/fft_kernels.cc @@ -185,7 +185,7 @@ class FFTCPU : public FFTBase { const Tensor& in, Tensor* out) { auto device = ctx->eigen_device(); auto worker_threads = ctx->device()->tensorflow_cpu_worker_threads(); - auto num_threads = worker_threads->num_threads; + auto num_threads = worker_threads->num_threads; const bool is_complex128 = in.dtype() == DT_COMPLEX128 || out->dtype() == DT_COMPLEX128; @@ -216,11 +216,22 @@ class FFTCPU : public FFTBase { constexpr auto fft_sign = Forward ? FFTW_FORWARD : FFTW_BACKWARD; constexpr auto fft_flags = FFTW_ESTIMATE; + #pragma omp critical + { + static bool is_fftw_initialized = false; + if (!is_fftw_initialized) { + // Set up threading for FFTW. Should be done only once. + #ifdef _OPENMP + fftw::init_threads(); + fftw::plan_with_nthreads(num_threads); + #endif + is_fftw_initialized = true; + } + } + fftw::plan fft_plan; + #pragma omp critical { - mutex_lock l(mu_); - fftw::init_threads(); - fftw::plan_with_nthreads(num_threads); fft_plan = fftw::plan_many_dft( FFTRank, dim_sizes, batch_size, reinterpret_cast*>(input.data()), @@ -229,13 +240,28 @@ class FFTCPU : public FFTBase { nullptr, 1, output_distance, fft_sign, fft_flags); } + fftw::execute(fft_plan); + + #pragma omp critical { - mutex_lock l(mu_); fftw::destroy_plan(fft_plan); - fftw::cleanup_threads(); } + // Wait until all threads are done using FFTW, then clean up the FFTW state, + // which only needs to be done once. + #ifdef _OPENMP + #pragma omp barrier + #pragma omp critical + { + static bool is_fftw_finalized = false; + if (!is_fftw_finalized) { + fftw::cleanup_threads(); + is_fftw_finalized = true; + } + } + #endif // _OPENMP + // FFT normalization. if (fft_sign == FFTW_BACKWARD) { output.device(device) = output / output.constant(num_points); diff --git a/tools/docs/tutorials/recon/unet_fastmri.ipynb b/tools/docs/tutorials/recon/unet_fastmri.ipynb index bf3bd783..134aed12 100644 --- a/tools/docs/tutorials/recon/unet_fastmri.ipynb +++ b/tools/docs/tutorials/recon/unet_fastmri.ipynb @@ -17,7 +17,8 @@ "import glob\n", "\n", "import tensorflow as tf\n", - "import tensorflow_io as tfio" + "import tensorflow_io as tfio\n", + "import tensorflow_mri as tfmri" ] }, { @@ -102,9 +103,46 @@ "metadata": {}, "outputs": [], "source": [ - "model = tf.keras.Sequential([\n", - " \n", - "])" + "element_spec = None\n", + "batch_size = 1\n", + "\n", + "ds_train = create_fastmri_dataset(files_train,\n", + " element_spec=element_spec,\n", + " batch_size=batch_size,\n", + " shuffle=True)\n", + "\n", + "ds_val = create_fastmri_dataset(files_val,\n", + " element_spec=element_spec,\n", + " batch_size=batch_size,\n", + " shuffle=False)\n", + "\n", + "ds_test = create_fastmri_dataset(files_test,\n", + " element_spec=element_spec,\n", + " batch_size=batch_size,\n", + " shuffle=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model = tfmri.models.UNet2D(filters=[32, 64, 128], kernel_size=3)\n", + "\n", + "model.compile(optimizer='rmsprop',\n", + " loss='mse',\n", + " metrics=[tfmri.metrics.PSNR(),\n", + " tfmri.metrics.SSIM()])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model.fit(ds_train, epochs=1, validation_data=ds_val)" ] } ], From 651c108d470fcbc342c89898ddee87a6dd3404d5 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Tue, 2 Aug 2022 17:42:33 +0000 Subject: [PATCH 008/101] Enable reconstruction with dynamic image shape --- .devcontainer/devcontainer.json | 3 +- .../python/linalg/linear_operator_mri.py | 142 +++++--- .../python/linalg/linear_operator_mri_test.py | 23 +- tensorflow_mri/python/ops/array_ops.py | 60 ++++ tensorflow_mri/python/ops/array_ops_test.py | 23 ++ tensorflow_mri/python/ops/recon_ops.py | 4 +- tensorflow_mri/python/ops/signal_ops.py | 14 +- tensorflow_mri/python/util/tensor_util.py | 10 +- tools/docs/tutorials/recon/unet_fastmri.ipynb | 326 ++++++++++++++++-- 9 files changed, 501 insertions(+), 104 deletions(-) diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index f813b572..3bb3a01a 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -14,7 +14,8 @@ ], // Enable plotting. "mounts": [ - "type=bind,source=/tmp/.X11-unix,target=/tmp/.X11-unix" + "type=bind,source=/tmp/.X11-unix,target=/tmp/.X11-unix", + "type=bind,source=/media/storage,target=/media/storage" ], // Enable plotting. "containerEnv": { diff --git a/tensorflow_mri/python/linalg/linear_operator_mri.py b/tensorflow_mri/python/linalg/linear_operator_mri.py index d77d91f2..0b1b8df2 100644 --- a/tensorflow_mri/python/linalg/linear_operator_mri.py +++ b/tensorflow_mri/python/linalg/linear_operator_mri.py @@ -52,9 +52,9 @@ class LinearOperatorMRI(linear_operator.LinearOperator): # pylint: disable=abst vectorize operations when possible. Args: - image_shape: A `tf.TensorShape` or a list of `ints`. The shape of the images + image_shape: A 1D integer `tf.Tensor`. The shape of the images that this operator acts on. Must have length 2 or 3. - extra_shape: An optional `tf.TensorShape` or list of `ints`. Additional + extra_shape: An optional 1D integer `tf.Tensor`. Additional dimensions that should be included within the operator domain. Note that `extra_shape` is not needed to reconstruct independent batches of images. However, it is useful when this operator is used as part of a @@ -133,22 +133,22 @@ def __init__(self, f"`dtype` must be `complex64` or `complex128`, but got: {str(dtype)}") # Set image shape, rank and extra shape. - image_shape = tf.TensorShape(image_shape) - rank = image_shape.rank - if rank not in (2, 3): - raise ValueError( - f"Rank must be 2 or 3, but got: {rank}") - if not image_shape.is_fully_defined(): - raise ValueError( - f"`image_shape` must be fully defined, but got {image_shape}") - self._rank = rank - self._image_shape = image_shape + self._image_shape_static, self._image_shape_dynamic = ( + tensor_util.static_and_dynamic_shapes_from_shape(image_shape)) + self._rank = self._image_shape_static.rank + if self._rank not in (2, 3): + raise ValueError(f"Rank must be 2 or 3, but got: {self._rank}") self._image_axes = list(range(-self._rank, 0)) # pylint: disable=invalid-unary-operand-type - self._extra_shape = tf.TensorShape(extra_shape or []) + self._extra_shape_static, self._extra_shape_dynamic = ( + tensor_util.static_and_dynamic_shapes_from_shape(extra_shape or [])) # Set initial batch shape, then update according to inputs. - batch_shape = self._extra_shape - batch_shape_tensor = tensor_util.convert_shape_to_tensor(batch_shape) + # We include the "extra" dimensions in the batch shape for now, so that + # they are also included in the broadcasting operations below. However, + # note that the "extra" dimensions are not in fact part of the batch shape + # and they will be removed later. + self._batch_shape_static = self._extra_shape_static + self._batch_shape_dynamic = self._extra_shape_dynamic # Set sampling mask after checking dtype and static shape. if mask is not None: @@ -156,14 +156,15 @@ def __init__(self, if mask.dtype != tf.bool: raise TypeError( f"`mask` must have dtype `bool`, but got: {str(mask.dtype)}") - if not mask.shape[-self._rank:].is_compatible_with(self._image_shape): + if not mask.shape[-self._rank:].is_compatible_with( + self._image_shape_static): raise ValueError( f"Expected the last dimensions of `mask` to be compatible with " - f"{self._image_shape}], but got: {mask.shape[-self._rank:]}") - batch_shape = tf.broadcast_static_shape( - batch_shape, mask.shape[:-self._rank]) - batch_shape_tensor = tf.broadcast_dynamic_shape( - batch_shape_tensor, tf.shape(mask)[:-self._rank]) + f"{self._image_shape_static}], but got: {mask.shape[-self._rank:]}") + self._batch_shape_static = tf.broadcast_static_shape( + self._batch_shape_static, mask.shape[:-self._rank]) + self._batch_shape_dynamic = tf.broadcast_dynamic_shape( + self._batch_shape_dynamic, tf.shape(mask)[:-self._rank]) self._mask = mask # Set sampling trajectory after checking dtype and static shape. @@ -179,10 +180,10 @@ def __init__(self, raise ValueError( f"Expected the last dimension of `trajectory` to be " f"{self._rank}, but got {trajectory.shape[-1]}") - batch_shape = tf.broadcast_static_shape( - batch_shape, trajectory.shape[:-2]) - batch_shape_tensor = tf.broadcast_dynamic_shape( - batch_shape_tensor, tf.shape(trajectory)[:-2]) + self._batch_shape_static = tf.broadcast_static_shape( + self._batch_shape_static, trajectory.shape[:-2]) + self._batch_shape_dynamic = tf.broadcast_dynamic_shape( + self._batch_shape_dynamic, tf.shape(trajectory)[:-2]) self._trajectory = trajectory # Set sampling density after checking dtype and static shape. @@ -198,10 +199,10 @@ def __init__(self, raise ValueError( f"Expected the last dimension of `density` to be " f"{self._trajectory.shape[-2]}, but got {density.shape[-1]}") - batch_shape = tf.broadcast_static_shape( - batch_shape, density.shape[:-1]) - batch_shape_tensor = tf.broadcast_dynamic_shape( - batch_shape_tensor, tf.shape(density)[:-1]) + self._batch_shape_static = tf.broadcast_static_shape( + self._batch_shape_static, density.shape[:-1]) + self._batch_shape_dynamic = tf.broadcast_dynamic_shape( + self._batch_shape_dynamic, tf.shape(density)[:-1]) self._density = density # Set sensitivity maps after checking dtype and static shape. @@ -212,15 +213,15 @@ def __init__(self, f"Expected `sensitivities` to have dtype `{str(dtype)}`, but got: " f"{str(sensitivities.dtype)}") if not sensitivities.shape[-self._rank:].is_compatible_with( - self._image_shape): + self._image_shape_static): raise ValueError( f"Expected the last dimensions of `sensitivities` to be " - f"compatible with {self._image_shape}, but got: " + f"compatible with {self._image_shape_static}, but got: " f"{sensitivities.shape[-self._rank:]}") - batch_shape = tf.broadcast_static_shape( - batch_shape, sensitivities.shape[:-(self._rank + 1)]) - batch_shape_tensor = tf.broadcast_dynamic_shape( - batch_shape_tensor, tf.shape(sensitivities)[:-(self._rank + 1)]) + self._batch_shape_static = tf.broadcast_static_shape( + self._batch_shape_static, sensitivities.shape[:-(self._rank + 1)]) + self._batch_shape_dynamic = tf.broadcast_dynamic_shape( + self._batch_shape_dynamic, tf.shape(sensitivities)[:-(self._rank + 1)]) self._sensitivities = sensitivities if phase is not None: @@ -230,20 +231,24 @@ def __init__(self, f"Expected `phase` to have dtype `{str(dtype.real_dtype)}`, " f"but got: {str(phase.dtype)}") if not phase.shape[-self._rank:].is_compatible_with( - self._image_shape): + self._image_shape_static): raise ValueError( f"Expected the last dimensions of `phase` to be " - f"compatible with {self._image_shape}, but got: " + f"compatible with {self._image_shape_static}, but got: " f"{phase.shape[-self._rank:]}") - batch_shape = tf.broadcast_static_shape( - batch_shape, phase.shape[:-self._rank]) - batch_shape_tensor = tf.broadcast_dynamic_shape( - batch_shape_tensor, tf.shape(phase)[:-self._rank]) + self._batch_shape_static = tf.broadcast_static_shape( + self._batch_shape_static, phase.shape[:-self._rank]) + self._batch_shape_dynamic = tf.broadcast_dynamic_shape( + self._batch_shape_dynamic, tf.shape(phase)[:-self._rank]) self._phase = phase # Set batch shapes. - self._batch_shape_value = batch_shape - self._batch_shape_tensor_value = batch_shape_tensor + extra_dims = self._extra_shape_static.rank + if extra_dims is None: + raise ValueError("rank of `extra_shape` must be known statically.") + if extra_dims > 0: + self._batch_shape_static = self._batch_shape_static[:-extra_dims] + self._batch_shape_dynamic = self._batch_shape_dynamic[:-extra_dims] # If multicoil, add coil dimension to mask, trajectory and density. if self._sensitivities is not None: @@ -271,7 +276,8 @@ def __init__(self, fft_norm, {None, 'ortho'}, 'fft_norm') if self._fft_norm == 'ortho': # Compute normalization factors. self._fft_norm_factor = tf.math.reciprocal( - tf.math.sqrt(tf.cast(self._image_shape.num_elements(), dtype))) + tf.math.sqrt(tf.cast( + tf.math.reduce_prod(self._image_shape_dynamic), dtype))) # Normalize coil sensitivities. self._sens_norm = sens_norm @@ -321,7 +327,7 @@ def _transform(self, x, adjoint=False): if self.is_non_cartesian: # Non-Cartesian imaging, use NUFFT. if not self._skip_nufft: x = fft_ops.nufft(x, self._trajectory, - grid_shape=self._image_shape, + grid_shape=self._image_shape_dynamic, transform_type='type_1', fft_direction='backward') if self._fft_norm is not None: @@ -387,31 +393,48 @@ def _transform(self, x, adjoint=False): return x def _domain_shape(self): - """Returns the shape of the domain space of this operator.""" - return self._extra_shape.concatenate(self._image_shape) + """Returns the static shape of the domain space of this operator.""" + return self._extra_shape_static.concatenate(self._image_shape_static) + + def _domain_shape_tensor(self): + """Returns the dynamic shape of the domain space of this operator.""" + return tf.concat([self._extra_shape_dynamic, self._image_shape_dynamic], 0) def _range_shape(self): """Returns the shape of the range space of this operator.""" if self.is_cartesian: - range_shape = self._image_shape.as_list() + range_shape = self._image_shape_static.as_list() else: range_shape = [self._trajectory.shape[-2]] if self.is_multicoil: range_shape = [self.num_coils] + range_shape - return self._extra_shape.concatenate(range_shape) + return self._extra_shape_static.concatenate(range_shape) + + def _range_shape_tensor(self): + if self.is_cartesian: + range_shape = self._image_shape_dynamic + else: + range_shape = [tf.shape(self._trajectory)[-2]] + if self.is_multicoil: + range_shape = tf.concat([[self.num_coils_tensor()], range_shape], 0) + return tf.concat([self._extra_shape_dynamic, range_shape], 0) def _batch_shape(self): """Returns the static batch shape of this operator.""" - return self._batch_shape_value[:-self._extra_shape.rank or None] # pylint: disable=invalid-unary-operand-type + return self._batch_shape_static def _batch_shape_tensor(self): """Returns the dynamic batch shape of this operator.""" - return self._batch_shape_tensor_value[:-self._extra_shape.rank or None] # pylint: disable=invalid-unary-operand-type + return self._batch_shape_dynamic @property def image_shape(self): """The image shape.""" - return self._image_shape + return self._image_shape_static + + def image_shape_tensor(self): + """The image shape as a tensor.""" + return self._image_shape_dynamic @property def rank(self): @@ -455,12 +478,23 @@ def dynamic_axis(self): @property def num_coils(self): - """The number of coils.""" + """The number of coils, computed statically.""" if self._sensitivities is None: return None return self._sensitivities.shape[-(self._rank + 1)] + def num_coils_tensor(self): + """The number of coils, computed dynamically.""" + if self._sensitivities is None: + return tf.convert_to_tensor(-1, dtype=tf.int32) + return tf.shape(self._sensitivities)[-(self._rank + 1)] + @property def _composite_tensor_fields(self): - return ("image_shape", "mask", "trajectory", "density", "sensitivities", + return ("image_shape", + "extra_shape", + "mask", + "trajectory", + "density", + "sensitivities", "fft_norm") diff --git a/tensorflow_mri/python/linalg/linear_operator_mri_test.py b/tensorflow_mri/python/linalg/linear_operator_mri_test.py index b86d2bd0..92618154 100755 --- a/tensorflow_mri/python/linalg/linear_operator_mri_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_mri_test.py @@ -17,30 +17,19 @@ import tensorflow as tf +from tensorflow_mri.python.linalg import linear_operator_mri from tensorflow_mri.python.ops import fft_ops from tensorflow_mri.python.ops import image_ops -from tensorflow_mri.python.ops import linalg_ops from tensorflow_mri.python.ops import traj_ops from tensorflow_mri.python.util import test_util class LinearOperatorMRITest(test_util.TestCase): """Tests for MRI linear operator.""" - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.linop1 = linalg_ops.LinearOperatorMRI([2, 2], fft_norm=None) - cls.linop2 = linalg_ops.LinearOperatorMRI( - [2, 2], mask=[[False, False], [True, True]], fft_norm=None) - cls.linop3 = linalg_ops.LinearOperatorMRI( - [2, 2], mask=[[[True, True], [False, False]], - [[False, False], [True, True]], - [[False, True], [True, False]]], fft_norm=None) - def test_fft(self): """Test FFT operator.""" # Test init. - linop = linalg_ops.LinearOperatorMRI([2, 2], fft_norm=None) + linop = linear_operator_mri.LinearOperatorMRI([2, 2], fft_norm=None) # Test matvec. signal = tf.constant([1, 2, 4, 4], dtype=tf.complex64) @@ -66,7 +55,7 @@ def test_fft(self): def test_fft_with_mask(self): """Test FFT operator with mask.""" # Test init. - linop = linalg_ops.LinearOperatorMRI( + linop = linear_operator_mri.LinearOperatorMRI( [2, 2], mask=[[False, False], [True, True]], fft_norm=None) # Test matvec. @@ -93,7 +82,7 @@ def test_fft_with_mask(self): def test_fft_with_batch_mask(self): """Test FFT operator with batch mask.""" # Test init. - linop = linalg_ops.LinearOperatorMRI( + linop = linear_operator_mri.LinearOperatorMRI( [2, 2], mask=[[[True, True], [False, False]], [[False, False], [True, True]], [[False, True], [True, False]]], fft_norm=None) @@ -121,7 +110,7 @@ def test_fft_with_batch_mask(self): def test_fft_norm(self): """Test FFT normalization.""" - linop = linalg_ops.LinearOperatorMRI([2, 2], fft_norm='ortho') + linop = linear_operator_mri.LinearOperatorMRI([2, 2], fft_norm='ortho') x = tf.constant([1 + 2j, 2 - 2j, -1 - 6j, 3 + 4j], dtype=tf.complex64) # With norm='ortho', subsequent application of the operator and its adjoint # should not scale the input. @@ -141,7 +130,7 @@ def test_nufft_with_sensitivities(self): density = traj_ops.radial_density(resolution, resolution // 2 + 1, flatten_encoding_dims=True) - linop = linalg_ops.LinearOperatorMRI( + linop = linear_operator_mri.LinearOperatorMRI( image_shape, trajectory=trajectory, density=density, sensitivities=sensitivities) diff --git a/tensorflow_mri/python/ops/array_ops.py b/tensorflow_mri/python/ops/array_ops.py index 370018e4..c0d2f28e 100644 --- a/tensorflow_mri/python/ops/array_ops.py +++ b/tensorflow_mri/python/ops/array_ops.py @@ -90,6 +90,66 @@ def meshgrid(*args): return tf.stack(tf.meshgrid(*args, indexing='ij'), axis=-1) +@api_util.export("array.meshgrid") +def dynamic_meshgrid(vecs): + """Return coordinate matrices from coordinate vectors. + + Make N-D coordinate arrays for vectorized evaluations of N-D scalar/vector + fields over N-D grids, given one-dimensional coordinate arrays + `x1, x2, ..., xn`. + + .. note:: + Similar to `tf.meshgrid`, but uses matrix indexing, supports dynamic tensor + arrays and returns a stacked tensor (along axis -1) instead of a list of + tensors. + + Args: + vecs: A `tf.TensorArray` containing the coordinate vectors. + + Returns: + A `Tensor` of shape `[M1, M2, ..., Mn, N]`, where `N` is the number of + tensors in `vecs` and `Mi = tf.size(args[i])`. + """ + if not isinstance(vecs, tf.TensorArray): + # Fall back to static implementation. + return meshgrid(*vecs) + + # Compute shape of the output grid. + output_shape = tf.TensorArray( + dtype=tf.int32, size=vecs.size(), element_shape=()) + + def _cond(i, vecs, shape): # pylint:disable=unused-argument + return i < vecs.size() + def _body(i, vecs, shape): + vec = vecs.read(i) + shape = shape.write(i, tf.shape(vec)[0]) + return i + 1, vecs, shape + + _, _, output_shape = tf.while_loop(_cond, _body, [0, vecs, output_shape]) + output_shape = output_shape.stack() + + # Compute output grid. + output_grid = tf.TensorArray(dtype=vecs.dtype, size=vecs.size()) + + def _cond(i, vecs, grid): # pylint:disable=unused-argument + return i < vecs.size() + def _body(i, vecs, grid): + vec = vecs.read(i) + vec_shape = tf.ones(shape=[vecs.size()], dtype=tf.int32) + vec_shape = tf.tensor_scatter_nd_update(vec_shape, [[i]], [-1]) + vec = tf.reshape(vec, vec_shape) + grid = grid.write(i, tf.broadcast_to(vec, output_shape)) + return i + 1, vecs, grid + + _, _, output_grid = tf.while_loop(_cond, _body, [0, vecs, output_grid]) + output_grid = output_grid.stack() + + perm = tf.concat([tf.range(1, vecs.size() + 1), [0]], 0) + output_grid = tf.transpose(output_grid, perm) + + return output_grid + + def ravel_multi_index(multi_indices, dims): """Converts an array of multi-indices into an array of flat indices. diff --git a/tensorflow_mri/python/ops/array_ops_test.py b/tensorflow_mri/python/ops/array_ops_test.py index a1b2f81f..dc4d6034 100755 --- a/tensorflow_mri/python/ops/array_ops_test.py +++ b/tensorflow_mri/python/ops/array_ops_test.py @@ -60,6 +60,29 @@ def test_meshgrid(self): self.assertAllEqual(result, ref) +class DynamicMeshgridTest(test_util.TestCase): + @test_util.run_in_graph_and_eager_modes + @parameterized.product(static=[False, True]) + def test_dynamic_meshgrid_static(self, static): + vec1 = [1, 2, 3] + vec2 = [4, 5] + + ref = [[[1, 4], [1, 5]], + [[2, 4], [2, 5]], + [[3, 4], [3, 5]]] + + if static: + vecs = [vec1, vec2] + else: + vecs = tf.TensorArray(tf.int32, size=2, infer_shape=False, + clear_after_read=False) + vecs = vecs.write(0, vec1) + vecs = vecs.write(1, vec2) + + result = array_ops.dynamic_meshgrid(vecs) + self.assertAllEqual(result, ref) + + class RavelMultiIndexTest(test_util.TestCase): """Tests for the `ravel_multi_index` op.""" diff --git a/tensorflow_mri/python/ops/recon_ops.py b/tensorflow_mri/python/ops/recon_ops.py index 3f8b8140..436f0f53 100644 --- a/tensorflow_mri/python/ops/recon_ops.py +++ b/tensorflow_mri/python/ops/recon_ops.py @@ -75,10 +75,10 @@ def reconstruct_adj(kspace, non-Cartesian `kspace` must have shape `[..., num_coils, num_samples]`. If not multicoil (`sensitivities` is `None`), then the `num_coils` axis must be omitted. - image_shape: A `TensorShape` or a list of `ints`. Must have length 2 or 3. + image_shape: A 1D integer `tf.Tensor`. Must have length 2 or 3. The shape of the reconstructed image[s]. mask: An optional `Tensor` of type `bool`. The sampling mask. Must have - shape `[..., image_shape]`. `mask` should be passed for reconstruction + shape `[..., *image_shape]`. `mask` should be passed for reconstruction from undersampled Cartesian *k*-space. For each point, `mask` should be `True` if the corresponding *k*-space sample was measured and `False` otherwise. diff --git a/tensorflow_mri/python/ops/signal_ops.py b/tensorflow_mri/python/ops/signal_ops.py index 2cfb63c5..eddc9a68 100644 --- a/tensorflow_mri/python/ops/signal_ops.py +++ b/tensorflow_mri/python/ops/signal_ops.py @@ -134,9 +134,17 @@ def filter_kspace(kspace, is_cartesian = trajectory is None if is_cartesian: filter_rank = filter_rank or kspace.shape.rank - vecs = [tf.linspace(-np.pi, np.pi - (2.0 * np.pi / s), s) - for s in kspace.shape[-filter_rank:]] # pylint: disable=invalid-unary-operand-type - trajectory = array_ops.meshgrid(*vecs) + vecs = tf.TensorArray(dtype=kspace.dtype.real_dtype, + size=filter_rank, + infer_shape=False, + clear_after_read=False) + for i in range(-filter_rank, 0): + size = tf.shape(kspace)[i] + pi = tf.cast(np.pi, kspace.dtype.real_dtype) + low = -pi + high = pi - (2.0 * pi / tf.cast(size, kspace.dtype.real_dtype)) + vecs = vecs.write(i + filter_rank, tf.linspace(low, high, size)) + trajectory = array_ops.dynamic_meshgrid(vecs) if not callable(filter_fn): # filter_fn not a callable, so should be an enum value. Get the diff --git a/tensorflow_mri/python/util/tensor_util.py b/tensorflow_mri/python/util/tensor_util.py index d765d82a..0d2dfbf7 100644 --- a/tensorflow_mri/python/util/tensor_util.py +++ b/tensorflow_mri/python/util/tensor_util.py @@ -130,7 +130,15 @@ def static_and_dynamic_shapes_from_shape(shape): Raises: ValueError: If `shape` is not 1D. """ - static = tf.TensorShape(tf.get_static_value(shape, partial=True)) + static = tf.get_static_value(shape, partial=True) + if (static is None and + isinstance(shape, tf.Tensor) and + shape.shape.is_fully_defined()): + # This is a special case in which `shape` is a `tf.Tensor` with unknown + # values but known shape. In this case `tf.get_static_value` will simply + # return None, but we can still infer the rank if we're a bit smarter. + static = [None] * shape.shape[0] + static = tf.TensorShape(static) dynamic = tf.convert_to_tensor(shape, tf.int32) if dynamic.shape.rank != 1: raise ValueError(f"Expected shape to be 1D, got {dynamic}.") diff --git a/tools/docs/tutorials/recon/unet_fastmri.ipynb b/tools/docs/tutorials/recon/unet_fastmri.ipynb index 134aed12..45faf64b 100644 --- a/tools/docs/tutorials/recon/unet_fastmri.ipynb +++ b/tools/docs/tutorials/recon/unet_fastmri.ipynb @@ -9,13 +9,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2022-08-02 17:29:22.299119: I tensorflow/core/util/util.cc:169] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n" + ] + } + ], "source": [ "import functools\n", - "import glob\n", + "import pathlib\n", "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", "import tensorflow as tf\n", "import tensorflow_io as tfio\n", "import tensorflow_mri as tfmri" @@ -23,33 +33,56 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Proportion of k-space lines in fully-sampled central region.\n", + "fully_sampled_region = 0.08" + ] + }, + { + "cell_type": "code", + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# If necessary, change the path names here.\n", - "data_path_train = \"fastmri/brain_multicoil_train\"\n", - "data_path_val = \"fastmri/brain_multicoil_val\"\n", - "data_path_test = \"fastmri/brain_multicoil_test\"" + "fastmri_path = pathlib.Path(\"/media/storage/fastmri\")\n", + "\n", + "data_path_train = fastmri_path / \"knee_multicoil_train_temp\"\n", + "data_path_val = fastmri_path / \"knee_multicoil_val_temp\"\n", + "data_path_test = fastmri_path / \"knee_multicoil_test_temp\"" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "files_train = glob.glob(\"*.h5\", root_dir=data_path_train)\n", - "files_val = glob.glob(\"*.h5\", root_dir=data_path_val)\n", - "files_test = glob.glob(\"*.h5\", root_dir=data_path_test)" + "files_train = data_path_train.glob(\"*.h5\")\n", + "files_val = data_path_val.glob(\"*.h5\")\n", + "files_test = data_path_test.glob(\"*.h5\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ + "# Spec for an element of the fastMRI dataset (the contents of one file).\n", + "element_spec = {\n", + " # kspace shape is `[slices, coils, height, width]` as described in\n", + " # https://fastmri.org/dataset/.\n", + " '/kspace': tf.TensorSpec(shape=[None, None, None, None], dtype=tf.complex64),\n", + " # the dataset also contains the root sum-of-squares reconstruction of the\n", + " # multicoil k-space data, with shape `[slices, height, width]` and where\n", + " # `height` and `width` are cropped to 320.\n", + " '/reconstruction_rss': tf.TensorSpec(shape=[None, 320, 320], dtype=tf.float32)\n", + "}\n", + "\n", "def read_hdf5(filename, spec=None):\n", " \"\"\"Reads an HDF file into a `dict` of `tf.Tensor`s.\n", "\n", @@ -77,33 +110,52 @@ " batch_size: An int, the batch size.\n", " shuffle: A boolean, whether to shuffle the dataset.\n", " \"\"\"\n", + " # Canonicalize `files` as a list of strings.\n", + " files = list(map(str, files))\n", + " if len(files) == 0:\n", + " raise ValueError(\"no files found\")\n", " # Make a `tf.data.Dataset` from the list of files.\n", " ds = tf.data.Dataset.from_tensor_slices(files)\n", - " # Read the k-space data from the file.\n", + " # Read the data in the file.\n", " ds = ds.map(functools.partial(read_hdf5, spec=element_spec))\n", + " # print(ds)\n", " # The first dimension of the inputs is the slice dimension. Split each\n", " # multi-slice element into multiple single-slice elements, as the\n", " # reconstruction is performed on a slice-by-slice basis.\n", " split_slices = lambda x: tf.data.Dataset.from_tensor_slices(x)\n", " ds = ds.flat_map(split_slices)\n", + " # Remove slashes.\n", + " ds = ds.map(lambda x: {k[1:]: v for k, v in x.items()})\n", " # TODO: create mask.\n", "\n", - " # TODO: create labels.\n", - " if shuffle:\n", - " ds = ds.shuffle(buffer_size=100)\n", - " # Batch the elements.\n", - " ds = ds.batch(batch_size)\n", - " ds = ds.prefetch(buffer_size=tf.data.AUTOTUNE)\n", + " # # TODO: create labels.\n", + " # if shuffle:\n", + " # ds = ds.shuffle(buffer_size=100)\n", + " # # Batch the elements.\n", + " # ds = ds.batch(batch_size)\n", + " # ds = ds.prefetch(buffer_size=tf.data.AUTOTUNE)\n", " return ds" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2022-08-02 17:29:36.908974: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 AVX512F AVX512_VNNI FMA\n", + "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2022-08-02 17:29:37.798985: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1532] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 22290 MB memory: -> device: 0, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:65:00.0, compute capability: 8.6\n", + "2022-08-02 17:29:37.799498: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1532] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 22304 MB memory: -> device: 1, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:b3:00.0, compute capability: 8.6\n", + "2022-08-02 17:29:38.076969: I tensorflow_io/core/kernels/cpu_check.cc:128] Your CPU supports instructions that this TensorFlow IO binary was not compiled to use: AVX2 AVX512F FMA\n" + ] + } + ], "source": [ - "element_spec = None\n", + "\n", "batch_size = 1\n", "\n", "ds_train = create_fastmri_dataset(files_train,\n", @@ -116,10 +168,184 @@ " batch_size=batch_size,\n", " shuffle=False)\n", "\n", - "ds_test = create_fastmri_dataset(files_test,\n", - " element_spec=element_spec,\n", - " batch_size=batch_size,\n", - " shuffle=False)" + "# ds_test = create_fastmri_dataset(files_test,\n", + "# element_spec=element_spec,\n", + "# batch_size=batch_size,\n", + "# shuffle=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(15, 640, 372)\n", + "(15, 640, 372)\n", + "(15, 640, 372)\n", + "(15, 640, 372)\n", + "(15, 640, 372)\n", + "(15, 640, 372)\n", + "(15, 640, 372)\n", + "(15, 640, 372)\n", + "(15, 640, 372)\n", + "(15, 640, 372)\n", + "(15, 640, 372)\n", + "(15, 640, 372)\n", + "(15, 640, 372)\n", + "(15, 640, 372)\n", + "(15, 640, 372)\n", + "(15, 640, 372)\n" + ] + } + ], + "source": [ + "for example in ds_train.take(16):\n", + " print(example['kspace'].shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def show_examples(ds, fn):\n", + " _, axs = plt.subplots(4, 4, figsize=(12, 12))\n", + " for index, example in enumerate(ds.take(16)):\n", + " i, j = index // 4, index % 4\n", + " axs[i, j].imshow(fn(example), cmap='gray')\n", + " axs[i, j].axis('off')\n", + " plt.show()\n", + "\n", + "display_fn = lambda example: example['reconstruction_rss'].numpy()\n", + "show_examples(ds_train, display_fn)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def reconstruct_zerofilled(kspace):\n", + " image_shape = tf.shape(kspace)[-2:]\n", + " image = tfmri.recon.adjoint(kspace, image_shape)\n", + " return image\n", + "\n", + "def compute_sensitivities(kspace):\n", + " def box(freq):\n", + " cutoff = fully_sampled_region * np.pi\n", + " result = tf.where(tf.math.abs(freq) < cutoff, 1, 0)\n", + " return result\n", + " filt_kspace = tfmri.signal.filter_kspace(kspace,\n", + " filter_fn=box,\n", + " filter_rank=1)\n", + " filt_image = reconstruct_zerofilled(filt_kspace)\n", + " sensitivities = tfmri.coils.estimate_sensitivities(filt_image, coil_axis=-3)\n", + " return sensitivities" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tensor(\"args_0:0\", shape=(None, None, None), dtype=complex64)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def insert_sensitivities(example):\n", + " example['sensitivities'] = compute_sensitivities(example['kspace'])\n", + " return example\n", + "\n", + "ds_temp = ds_train.map(insert_sensitivities)\n", + "\n", + "display_fn = lambda example: np.abs(example['sensitivities'].numpy())[0, ...]\n", + "show_examples(ds_temp, display_fn)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "Invalid shape (15, 640, 372) for image data", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/workspaces/tensorflow-mri/tools/docs/tutorials/recon/unet_fastmri.ipynb Cell 13\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 3\u001b[0m image \u001b[39m=\u001b[39m tf\u001b[39m.\u001b[39mmath\u001b[39m.\u001b[39mabs(image)\n\u001b[1;32m 4\u001b[0m \u001b[39mreturn\u001b[39;00m image\n\u001b[0;32m----> 6\u001b[0m show_examples(ds_train, display_fn)\n", + "\u001b[1;32m/workspaces/tensorflow-mri/tools/docs/tutorials/recon/unet_fastmri.ipynb Cell 13\u001b[0m in \u001b[0;36mshow_examples\u001b[0;34m(ds, fn)\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[39mfor\u001b[39;00m index, example \u001b[39min\u001b[39;00m \u001b[39menumerate\u001b[39m(ds\u001b[39m.\u001b[39mtake(\u001b[39m16\u001b[39m)):\n\u001b[1;32m 4\u001b[0m i, j \u001b[39m=\u001b[39m index \u001b[39m/\u001b[39m\u001b[39m/\u001b[39m \u001b[39m4\u001b[39m, index \u001b[39m%\u001b[39m \u001b[39m4\u001b[39m\n\u001b[0;32m----> 5\u001b[0m axs[i, j]\u001b[39m.\u001b[39;49mimshow(fn(example), cmap\u001b[39m=\u001b[39;49m\u001b[39m'\u001b[39;49m\u001b[39mgray\u001b[39;49m\u001b[39m'\u001b[39;49m)\n\u001b[1;32m 6\u001b[0m axs[i, j]\u001b[39m.\u001b[39maxis(\u001b[39m'\u001b[39m\u001b[39moff\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m 7\u001b[0m plt\u001b[39m.\u001b[39mshow()\n", + "File \u001b[0;32m/usr/local/lib/python3.8/site-packages/matplotlib/_api/deprecation.py:459\u001b[0m, in \u001b[0;36mmake_keyword_only..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 453\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mlen\u001b[39m(args) \u001b[39m>\u001b[39m name_idx:\n\u001b[1;32m 454\u001b[0m warn_deprecated(\n\u001b[1;32m 455\u001b[0m since, message\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mPassing the \u001b[39m\u001b[39m%(name)s\u001b[39;00m\u001b[39m \u001b[39m\u001b[39m%(obj_type)s\u001b[39;00m\u001b[39m \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 456\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mpositionally is deprecated since Matplotlib \u001b[39m\u001b[39m%(since)s\u001b[39;00m\u001b[39m; the \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 457\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mparameter will become keyword-only \u001b[39m\u001b[39m%(removal)s\u001b[39;00m\u001b[39m.\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[1;32m 458\u001b[0m name\u001b[39m=\u001b[39mname, obj_type\u001b[39m=\u001b[39m\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mparameter of \u001b[39m\u001b[39m{\u001b[39;00mfunc\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m\u001b[39m}\u001b[39;00m\u001b[39m()\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m--> 459\u001b[0m \u001b[39mreturn\u001b[39;00m func(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", + "File \u001b[0;32m/usr/local/lib/python3.8/site-packages/matplotlib/__init__.py:1412\u001b[0m, in \u001b[0;36m_preprocess_data..inner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1409\u001b[0m \u001b[39m@functools\u001b[39m\u001b[39m.\u001b[39mwraps(func)\n\u001b[1;32m 1410\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39minner\u001b[39m(ax, \u001b[39m*\u001b[39margs, data\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m 1411\u001b[0m \u001b[39mif\u001b[39;00m data \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m-> 1412\u001b[0m \u001b[39mreturn\u001b[39;00m func(ax, \u001b[39m*\u001b[39;49m\u001b[39mmap\u001b[39;49m(sanitize_sequence, args), \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 1414\u001b[0m bound \u001b[39m=\u001b[39m new_sig\u001b[39m.\u001b[39mbind(ax, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m 1415\u001b[0m auto_label \u001b[39m=\u001b[39m (bound\u001b[39m.\u001b[39marguments\u001b[39m.\u001b[39mget(label_namer)\n\u001b[1;32m 1416\u001b[0m \u001b[39mor\u001b[39;00m bound\u001b[39m.\u001b[39mkwargs\u001b[39m.\u001b[39mget(label_namer))\n", + "File \u001b[0;32m/usr/local/lib/python3.8/site-packages/matplotlib/axes/_axes.py:5481\u001b[0m, in \u001b[0;36mAxes.imshow\u001b[0;34m(self, X, cmap, norm, aspect, interpolation, alpha, vmin, vmax, origin, extent, interpolation_stage, filternorm, filterrad, resample, url, **kwargs)\u001b[0m\n\u001b[1;32m 5474\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mset_aspect(aspect)\n\u001b[1;32m 5475\u001b[0m im \u001b[39m=\u001b[39m mimage\u001b[39m.\u001b[39mAxesImage(\u001b[39mself\u001b[39m, cmap, norm, interpolation,\n\u001b[1;32m 5476\u001b[0m origin, extent, filternorm\u001b[39m=\u001b[39mfilternorm,\n\u001b[1;32m 5477\u001b[0m filterrad\u001b[39m=\u001b[39mfilterrad, resample\u001b[39m=\u001b[39mresample,\n\u001b[1;32m 5478\u001b[0m interpolation_stage\u001b[39m=\u001b[39minterpolation_stage,\n\u001b[1;32m 5479\u001b[0m \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[0;32m-> 5481\u001b[0m im\u001b[39m.\u001b[39;49mset_data(X)\n\u001b[1;32m 5482\u001b[0m im\u001b[39m.\u001b[39mset_alpha(alpha)\n\u001b[1;32m 5483\u001b[0m \u001b[39mif\u001b[39;00m im\u001b[39m.\u001b[39mget_clip_path() \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 5484\u001b[0m \u001b[39m# image does not already have clipping set, clip to axes patch\u001b[39;00m\n", + "File \u001b[0;32m/usr/local/lib/python3.8/site-packages/matplotlib/image.py:715\u001b[0m, in \u001b[0;36m_ImageBase.set_data\u001b[0;34m(self, A)\u001b[0m\n\u001b[1;32m 711\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_A \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_A[:, :, \u001b[39m0\u001b[39m]\n\u001b[1;32m 713\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m (\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_A\u001b[39m.\u001b[39mndim \u001b[39m==\u001b[39m \u001b[39m2\u001b[39m\n\u001b[1;32m 714\u001b[0m \u001b[39mor\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_A\u001b[39m.\u001b[39mndim \u001b[39m==\u001b[39m \u001b[39m3\u001b[39m \u001b[39mand\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_A\u001b[39m.\u001b[39mshape[\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m] \u001b[39min\u001b[39;00m [\u001b[39m3\u001b[39m, \u001b[39m4\u001b[39m]):\n\u001b[0;32m--> 715\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mTypeError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mInvalid shape \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m for image data\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 716\u001b[0m \u001b[39m.\u001b[39mformat(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_A\u001b[39m.\u001b[39mshape))\n\u001b[1;32m 718\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_A\u001b[39m.\u001b[39mndim \u001b[39m==\u001b[39m \u001b[39m3\u001b[39m:\n\u001b[1;32m 719\u001b[0m \u001b[39m# If the input data has values outside the valid range (after\u001b[39;00m\n\u001b[1;32m 720\u001b[0m \u001b[39m# normalisation), we issue a warning and then clip X to the bounds\u001b[39;00m\n\u001b[1;32m 721\u001b[0m \u001b[39m# - otherwise casting wraps extreme values, hiding outliers and\u001b[39;00m\n\u001b[1;32m 722\u001b[0m \u001b[39m# making reliable interpretation impossible.\u001b[39;00m\n\u001b[1;32m 723\u001b[0m high \u001b[39m=\u001b[39m \u001b[39m255\u001b[39m \u001b[39mif\u001b[39;00m np\u001b[39m.\u001b[39missubdtype(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_A\u001b[39m.\u001b[39mdtype, np\u001b[39m.\u001b[39minteger) \u001b[39melse\u001b[39;00m \u001b[39m1\u001b[39m\n", + "\u001b[0;31mTypeError\u001b[0m: Invalid shape (15, 640, 372) for image data" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def display_fn(example):\n", + " image = reconstruct_zerofilled(example['kspace'])\n", + " image = tf.math.abs(image)\n", + " return image\n", + "\n", + "show_examples(ds_train, display_fn)" ] }, { @@ -127,6 +353,46 @@ "execution_count": null, "metadata": {}, "outputs": [], + "source": [ + "def subsample(example):\n", + " \"\"\"Subsamples a fastMRI example (single slice).\n", + "\n", + " Args:\n", + " ds: A `tf.data.Dataset` object.\n", + " \"\"\"\n", + " kspace = example['kspace']\n", + " num_lines = tf.shape(kspace)[-1]\n", + " density_1d = tfmri.sampling.density_grid(shape=[num_lines],\n", + " inner_density=1.0,\n", + " inner_cutoff=0.08,\n", + " outer_cutoff=0.08,\n", + " outer_density=0.25)\n", + " mask_1d = tfmri.sampling.random_mask(shape=[num_lines], density=density_1d)\n", + " mask_2d = tf.tile(mask_1d, tf.shape(kspace)[-2:])\n", + " example['kspace'] *= mask_1d\n", + " example['mask'] = mask_2d\n", + " return example\n", + "\n", + "train_ds = ds_train.map(subsample)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'tfmri' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/workspaces/tensorflow-mri/tools/docs/tutorials/recon/unet_fastmri.ipynb Cell 7\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m model \u001b[39m=\u001b[39m tfmri\u001b[39m.\u001b[39mmodels\u001b[39m.\u001b[39mUNet2D(filters\u001b[39m=\u001b[39m[\u001b[39m32\u001b[39m, \u001b[39m64\u001b[39m, \u001b[39m128\u001b[39m], kernel_size\u001b[39m=\u001b[39m\u001b[39m3\u001b[39m)\n\u001b[1;32m 3\u001b[0m model\u001b[39m.\u001b[39mcompile(optimizer\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mrmsprop\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 4\u001b[0m loss\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mmse\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 5\u001b[0m metrics\u001b[39m=\u001b[39m[tfmri\u001b[39m.\u001b[39mmetrics\u001b[39m.\u001b[39mPSNR(),\n\u001b[1;32m 6\u001b[0m tfmri\u001b[39m.\u001b[39mmetrics\u001b[39m.\u001b[39mSSIM()])\n", + "\u001b[0;31mNameError\u001b[0m: name 'tfmri' is not defined" + ] + } + ], "source": [ "model = tfmri.models.UNet2D(filters=[32, 64, 128], kernel_size=3)\n", "\n", @@ -153,7 +419,15 @@ "name": "python3" }, "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", "version": "3.8.2" }, "orig_nbformat": 4, From f15304066632c836531d6125108b9b5fe0acca2d Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 3 Aug 2022 17:35:42 +0000 Subject: [PATCH 009/101] fastMRI tutorial --- tensorflow_mri/_api/array/__init__.py | 1 + tensorflow_mri/_api/sampling/__init__.py | 2 + tensorflow_mri/python/activations/__init__.py | 17 + .../python/activations/complex_activations.py | 46 ++ .../activations/complex_activations_test.py | 33 ++ tensorflow_mri/python/layers/__init__.py | 2 + .../python/layers/data_consistency.py | 2 + tensorflow_mri/python/layers/pooling.py | 2 +- tensorflow_mri/python/layers/reshaping.py | 98 ++++ .../python/layers/reshaping_test.py | 15 + tensorflow_mri/python/models/conv_blocks.py | 3 +- .../python/models/conv_blocks_test.py | 17 + tensorflow_mri/python/models/conv_endec.py | 9 +- .../python/models/conv_endec_test.py | 17 + tensorflow_mri/python/ops/traj_ops.py | 64 ++- tensorflow_mri/python/ops/traj_ops_test.py | 56 ++- tensorflow_mri/python/util/api_util.py | 2 + tensorflow_mri/python/util/layer_util.py | 20 +- tools/docs/tutorials/recon/unet_fastmri.ipynb | 454 ++++++++++++------ 19 files changed, 677 insertions(+), 183 deletions(-) create mode 100644 tensorflow_mri/python/activations/__init__.py create mode 100644 tensorflow_mri/python/activations/complex_activations.py create mode 100644 tensorflow_mri/python/activations/complex_activations_test.py create mode 100644 tensorflow_mri/python/layers/reshaping.py create mode 100644 tensorflow_mri/python/layers/reshaping_test.py diff --git a/tensorflow_mri/_api/array/__init__.py b/tensorflow_mri/_api/array/__init__.py index 11b5bcf7..eedb6aae 100644 --- a/tensorflow_mri/_api/array/__init__.py +++ b/tensorflow_mri/_api/array/__init__.py @@ -2,4 +2,5 @@ # Do not edit. """Array processing operations.""" +from tensorflow_mri.python.ops.array_ops import dynamic_meshgrid as meshgrid from tensorflow_mri.python.ops.array_ops import update_tensor as update_tensor diff --git a/tensorflow_mri/_api/sampling/__init__.py b/tensorflow_mri/_api/sampling/__init__.py index b5f337c8..ad5b3905 100644 --- a/tensorflow_mri/_api/sampling/__init__.py +++ b/tensorflow_mri/_api/sampling/__init__.py @@ -3,12 +3,14 @@ """k-space sampling operations.""" from tensorflow_mri.python.ops.traj_ops import density_grid as density_grid +from tensorflow_mri.python.ops.traj_ops import frequency_grid as frequency_grid from tensorflow_mri.python.ops.traj_ops import random_sampling_mask as random_mask from tensorflow_mri.python.ops.traj_ops import radial_trajectory as radial_trajectory from tensorflow_mri.python.ops.traj_ops import spiral_trajectory as spiral_trajectory from tensorflow_mri.python.ops.traj_ops import radial_density as radial_density from tensorflow_mri.python.ops.traj_ops import estimate_radial_density as estimate_radial_density from tensorflow_mri.python.ops.traj_ops import radial_waveform as radial_waveform +# from 1c67b1db4cb5c043d469006db82e3356e63fbfcc import spiral_waveform as spiral_waveform from tensorflow_mri.python.ops.traj_ops import estimate_density as estimate_density from tensorflow_mri.python.ops.traj_ops import flatten_trajectory as flatten_trajectory from tensorflow_mri.python.ops.traj_ops import flatten_density as flatten_density diff --git a/tensorflow_mri/python/activations/__init__.py b/tensorflow_mri/python/activations/__init__.py new file mode 100644 index 00000000..a76cebf6 --- /dev/null +++ b/tensorflow_mri/python/activations/__init__.py @@ -0,0 +1,17 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Keras activations.""" + +from tensorflow_mri.python.activations import complex_activations diff --git a/tensorflow_mri/python/activations/complex_activations.py b/tensorflow_mri/python/activations/complex_activations.py new file mode 100644 index 00000000..bb556446 --- /dev/null +++ b/tensorflow_mri/python/activations/complex_activations.py @@ -0,0 +1,46 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Complex-valued activations.""" + +import functools + +import tensorflow as tf + +from tensorflow_mri.python.util import api_util + + +def complexified(split='real_imag'): + """Returns a decorator to create complex-valued activations.""" + if split not in ('real_imag', 'abs_angle'): + raise ValueError( + f"split must be one of 'real_imag' or 'abs_angle', but got: {split}") + def decorator(func): + @functools.wraps(func) + def wrapper(x, *args, **kwargs): + x = tf.convert_to_tensor(x) + if x.dtype.is_complex: + if split == 'abs_angle': + return (tf.cast(func(tf.math.abs(x), *args, **kwargs), x.dtype) * + tf.math.exp(1j * tf.math.angle(x))) + if split == 'real_imag': + return tf.dtypes.complex(func(tf.math.real(x), *args, **kwargs), + func(tf.math.imag(x), *args, **kwargs)) + return func(x, *args, **kwargs) + return wrapper + return decorator + + +complex_relu = api_util.export("activations.complex_relu")( + complexified(split='real_imag')(tf.keras.activations.relu)) diff --git a/tensorflow_mri/python/activations/complex_activations_test.py b/tensorflow_mri/python/activations/complex_activations_test.py new file mode 100644 index 00000000..a6b55f9e --- /dev/null +++ b/tensorflow_mri/python/activations/complex_activations_test.py @@ -0,0 +1,33 @@ +# Copyright 2022 University College London. 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. +# ============================================================================== +"""Tests for module `complex_activations`.""" + +import tensorflow as tf + +from tensorflow_mri.python.activations import complex_activations +from tensorflow_mri.python.util import test_util + + +class ReluTest(test_util.TestCase): + @test_util.run_all_execution_modes + def test_complex_relu(self): + inputs = [1.0 - 2.0j, 1.0 + 3.0j, -2.0 + 1.0j, -3.0 - 4.0j] + expected = [1.0 + 0.0j, 1.0 + 3.0j, 0.0 + 1.0j, 0.0 + 0.0j] + result = complex_activations.complex_relu(inputs) + self.assertAllClose(expected, result) + + +if __name__ == '__main__': + tf.test.main() diff --git a/tensorflow_mri/python/layers/__init__.py b/tensorflow_mri/python/layers/__init__.py index 14bbaba9..4e1d41d0 100644 --- a/tensorflow_mri/python/layers/__init__.py +++ b/tensorflow_mri/python/layers/__init__.py @@ -17,6 +17,8 @@ from tensorflow_mri.python.layers import convolutional from tensorflow_mri.python.layers import conv_blocks from tensorflow_mri.python.layers import conv_endec +from tensorflow_mri.python.layers import data_consistency from tensorflow_mri.python.layers import pooling from tensorflow_mri.python.layers import preproc_layers +from tensorflow_mri.python.layers import reshaping from tensorflow_mri.python.layers import signal_layers diff --git a/tensorflow_mri/python/layers/data_consistency.py b/tensorflow_mri/python/layers/data_consistency.py index 111924f0..5b84c3d1 100644 --- a/tensorflow_mri/python/layers/data_consistency.py +++ b/tensorflow_mri/python/layers/data_consistency.py @@ -19,8 +19,10 @@ import tensorflow as tf from tensorflow_mri.python.linalg import linear_operator +from tensorflow_mri.python.util import api_util +@api_util.export("layers.LeastSquaresGradientDescent") class LeastSquaresGradientDescent(tf.keras.layers.Layer): """Least squares gradient descent layer. """ diff --git a/tensorflow_mri/python/layers/pooling.py b/tensorflow_mri/python/layers/pooling.py index de93a90d..e876953b 100644 --- a/tensorflow_mri/python/layers/pooling.py +++ b/tensorflow_mri/python/layers/pooling.py @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== -"""Convolutional layers.""" +"""Pooling layers.""" import string diff --git a/tensorflow_mri/python/layers/reshaping.py b/tensorflow_mri/python/layers/reshaping.py new file mode 100644 index 00000000..99452dd1 --- /dev/null +++ b/tensorflow_mri/python/layers/reshaping.py @@ -0,0 +1,98 @@ +# Copyright 2022 University College London. 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. +# ============================================================================== +"""Reshaping layers.""" + +import string + +import tensorflow as tf + +from tensorflow_mri.python.util import api_util + + +EXTENSION_NOTE = string.Template(""" + + .. note:: + This layer can be used as a drop-in replacement for + `tf.keras.layers.${name}`_. However, this one also supports complex-valued + operations. Simply pass `dtype='complex64'` or `dtype='complex128'` to the + layer constructor. + + .. _tf.keras.layers.${name}: https://www.tensorflow.org/api_docs/python/tf/keras/layers/${name} + +""") + + +def complex_reshape(base): + """Adds complex-valued support to a Keras reshaping layer. + + We need the init method in the pooling layer to replace the `pool_function` + attribute with a function that supports complex inputs. + + Args: + base: The base class to be extended. + + Returns: + A subclass of `base` that supports complex-valued pooling. + + Raises: + ValueError: If `base` is not one of the supported base classes. + """ + if issubclass(base, (tf.keras.layers.UpSampling1D, + tf.keras.layers.UpSampling2D, + tf.keras.layers.UpSampling3D)): + def call(self, inputs): + if tf.as_dtype(self.dtype).is_complex: + return tf.dtypes.complex( + base.call(self, tf.math.real(inputs)), + base.call(self, tf.math.imag(inputs))) + + # For real values, we can just use the regular reshape function. + return base.call(self, inputs) + + else: + raise ValueError(f'Unexpected base class: {base}') + + # Dynamically create a subclass of `base` with the same name as `base` and + # with the overriden `convolution_op` method. + subclass = type(base.__name__, (base,), {'call': call}) + + # Copy docs from the base class, adding the extra note. + docstring = base.__doc__ + doclines = docstring.split('\n') + doclines[1:1] = EXTENSION_NOTE.substitute(name=base.__name__).splitlines() + subclass.__doc__ = '\n'.join(doclines) + + return subclass + + +# Define the complex-valued pooling layers. We use a composition of three +# decorators: +# 1. `complex_reshape`: Adds complex-valued support to a Keras reshape layer. +# 2. `register_keras_serializable`: Registers the new layer with the Keras +# serialization framework. +# 3. `export`: Exports the new layer to the TFMRI API. +UpSampling1D = api_util.export("layers.UpSampling1D")( + tf.keras.utils.register_keras_serializable(package='MRI')( + complex_reshape(tf.keras.layers.UpSampling1D))) + + +UpSampling2D = api_util.export("layers.UpSampling2D")( + tf.keras.utils.register_keras_serializable(package='MRI')( + complex_reshape(tf.keras.layers.UpSampling2D))) + + +UpSampling3D = api_util.export("layers.UpSampling3D")( + tf.keras.utils.register_keras_serializable(package='MRI')( + complex_reshape(tf.keras.layers.UpSampling3D))) diff --git a/tensorflow_mri/python/layers/reshaping_test.py b/tensorflow_mri/python/layers/reshaping_test.py new file mode 100644 index 00000000..42b188d0 --- /dev/null +++ b/tensorflow_mri/python/layers/reshaping_test.py @@ -0,0 +1,15 @@ +# Copyright 2022 University College London. 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. +# ============================================================================== +"""Tests for reshaping layers.""" diff --git a/tensorflow_mri/python/models/conv_blocks.py b/tensorflow_mri/python/models/conv_blocks.py index 417fae7f..d92aa7f8 100644 --- a/tensorflow_mri/python/models/conv_blocks.py +++ b/tensorflow_mri/python/models/conv_blocks.py @@ -174,7 +174,8 @@ def __init__(self, kernel_initializer=self._kernel_initializer, bias_initializer=self._bias_initializer, kernel_regularizer=self._kernel_regularizer, - bias_regularizer=self._bias_regularizer)) + bias_regularizer=self._bias_regularizer, + dtype=self.dtype)) if self._use_batch_norm: self._norms.append( bn(axis=self._channel_axis, diff --git a/tensorflow_mri/python/models/conv_blocks_test.py b/tensorflow_mri/python/models/conv_blocks_test.py index 27942a5e..d4abf345 100644 --- a/tensorflow_mri/python/models/conv_blocks_test.py +++ b/tensorflow_mri/python/models/conv_blocks_test.py @@ -17,6 +17,7 @@ from absl.testing import parameterized import tensorflow as tf +from tensorflow_mri.python.activations import complex_activations from tensorflow_mri.python.models import conv_blocks from tensorflow_mri.python.util import model_util from tensorflow_mri.python.util import test_util @@ -41,6 +42,22 @@ def test_conv_block_creation(self, rank, filters, kernel_size): # pylint: disabl self.assertAllEqual(features.shape, [1] + [128] * rank + [filters]) + def test_complex_valued(self): + inputs = tf.dtypes.complex( + tf.random.stateless_normal(shape=(2, 32, 32, 4), seed=[12, 34]), + tf.random.stateless_normal(shape=(2, 32, 32, 4), seed=[56, 78])) + + block = conv_blocks.ConvBlock2D( + filters=[6, 6], + kernel_size=3, + activation=complex_activations.complex_relu, + dtype=tf.complex64) + + result = block(inputs) + self.assertAllClose((2, 32, 32, 6), result.shape) + self.assertDTypeEqual(result, tf.complex64) + + def test_serialize_deserialize(self): """Test de/serialization.""" config = dict( diff --git a/tensorflow_mri/python/models/conv_endec.py b/tensorflow_mri/python/models/conv_endec.py index 8e6dea07..5d814105 100644 --- a/tensorflow_mri/python/models/conv_endec.py +++ b/tensorflow_mri/python/models/conv_endec.py @@ -168,7 +168,8 @@ def __init__(self, bn_epsilon=self._bn_epsilon, use_dropout=self._use_dropout, dropout_rate=self._dropout_rate, - dropout_type=self._dropout_type) + dropout_type=self._dropout_type, + dtype=self.dtype) # Configure pooling layer. if self._use_tight_frame: @@ -179,7 +180,8 @@ def __init__(self, pool_config = dict( pool_size=self._pool_size, strides=self._pool_size, - padding='same') + padding='same', + dtype=self.dtype) pool_layer = layer_util.get_nd_layer(pool_name, self._rank) # Configure upsampling layer. @@ -199,7 +201,8 @@ def __init__(self, else: upsamp_name = 'UpSampling' upsamp_config = dict( - size=self._pool_size) + size=self._pool_size, + dtype=self.dtype) upsamp_layer = layer_util.get_nd_layer(upsamp_name, self._rank) if tf.keras.backend.image_data_format() == 'channels_last': diff --git a/tensorflow_mri/python/models/conv_endec_test.py b/tensorflow_mri/python/models/conv_endec_test.py index 0cfc0931..16be81cf 100644 --- a/tensorflow_mri/python/models/conv_endec_test.py +++ b/tensorflow_mri/python/models/conv_endec_test.py @@ -18,6 +18,7 @@ from absl.testing import parameterized import tensorflow as tf +from tensorflow_mri.python.activations import complex_activations from tensorflow_mri.python.models import conv_endec from tensorflow_mri.python.util import test_util @@ -85,6 +86,22 @@ def test_use_bias(self, use_bias): self.assertEqual(use_bias, layer.use_bias) + def test_complex_valued(self): + inputs = tf.dtypes.complex( + tf.random.stateless_normal(shape=(2, 32, 32, 4), seed=[12, 34]), + tf.random.stateless_normal(shape=(2, 32, 32, 4), seed=[56, 78])) + + block = conv_endec.UNet2D( + filters=[4, 8], + kernel_size=3, + activation=complex_activations.complex_relu, + dtype=tf.complex64) + + result = block(inputs) + self.assertAllClose((2, 32, 32, 4), result.shape) + self.assertDTypeEqual(result, tf.complex64) + + def test_serialize_deserialize(self): """Test de/serialization.""" config = dict( diff --git a/tensorflow_mri/python/ops/traj_ops.py b/tensorflow_mri/python/ops/traj_ops.py index ce224cb4..b74bf6cd 100755 --- a/tensorflow_mri/python/ops/traj_ops.py +++ b/tensorflow_mri/python/ops/traj_ops.py @@ -67,8 +67,7 @@ def density_grid(shape, generate a boolean sampling mask. Args: - shape: A `tf.TensorShape` or a list of `ints`. The shape of the output - density grid. + shape: A 1D integer `tf.Tensor`. The shape of the output density grid. inner_density: A `float` between 0.0 and 1.0. The density of the inner region. outer_density: A `float` between 0.0 and 1.0. The density of the outer @@ -85,13 +84,17 @@ def density_grid(shape, A tensor containing the density grid. """ with tf.name_scope(name or 'density_grid'): - shape = tf.TensorShape(shape).as_list() + shape = tf.convert_to_tensor(shape, dtype=tf.int32) + inner_density = tf.convert_to_tensor(inner_density) + outer_density = tf.convert_to_tensor(outer_density) + inner_cutoff = tf.convert_to_tensor(inner_cutoff) + outer_cutoff = tf.convert_to_tensor(outer_cutoff) transition_type = check_util.validate_enum( transition_type, ['linear', 'quadratic', 'hann'], name='transition_type') - vecs = [tf.linspace(-1.0, 1.0 - 2.0 / n, n) for n in shape] - grid = array_ops.meshgrid(*vecs) + grid = frequency_grid( + shape, max_val=tf.constant(1.0, dtype=inner_density.dtype)) radius = tf.norm(grid, axis=-1) scaled_radius = (outer_cutoff - radius) / (outer_cutoff - inner_cutoff) @@ -109,6 +112,44 @@ def density_grid(shape, return density +@api_util.export("sampling.frequency_grid") +def frequency_grid(shape, max_val=1.0): + """Returns a frequency grid. + + Creates a grid of frequencies between `-max_val` and `max_val` of the + specified shape. For even shapes, the output grid is asymmetric + with the zero-frequency component at `n // 2 + 1`. + + Args: + shape: A 1D integer `tf.Tensor`. The shape of the output frequency grid. + max_val: A `tf.Tensor`. The maximum frequency. Must be of floating point + dtype. + + Returns: + A tensor of shape [*shape, tf.size(shape)] such that `tensor[..., i]` + contains the frequencies along axis `i`. Has the same dtype as `max_val`. + """ + shape = tf.convert_to_tensor(shape, dtype=tf.int32) + max_val = tf.convert_to_tensor(max_val) + dtype = max_val.dtype + + vecs = tf.TensorArray(dtype=dtype, + size=tf.size(shape), + infer_shape=False, + clear_after_read=False) + + def _cond(i, vecs): + return tf.less(i, tf.size(shape)) + def _body(i, vecs): + step = (2.0 * max_val) / tf.cast(shape[i], dtype) + low = -max_val + high = tf.cond(shape[i] % 2 == 0, lambda: max_val - step, lambda: max_val) + return i + 1, vecs.write(i, tf.linspace(low, high, shape[i])) + _, vecs = tf.while_loop(_cond, _body, [0, vecs]) + + return array_ops.dynamic_meshgrid(vecs) + + @api_util.export("sampling.random_mask") def random_sampling_mask(shape, density=1.0, seed=None, rng=None, name=None): """Returns a random sampling mask with the given density. @@ -137,12 +178,18 @@ def random_sampling_mask(shape, density=1.0, seed=None, rng=None, name=None): with tf.name_scope(name or 'sampling_mask'): if seed is not None and rng is not None: raise ValueError("Cannot provide both `seed` and `rng`.") + density = tf.convert_to_tensor(density) counts = tf.ones(shape, dtype=density.dtype) if seed is not None: # Use stateless RNG. mask = tf.random.stateless_binomial(shape, seed, counts, density) else: # Use stateful RNG. - rng = rng or tf.random.get_global_generator() - mask = rng.binomial(shape, counts, density) + with tf.init_scope(): + rng = rng or tf.random.get_global_generator().split(1)[0] + # As of TF 2.9, `binomial` does not have a GPU implementation. + # mask = rng.binomial(shape, counts, density) + # Therefore, we use a uniform distribution instead. If the generated + # value is less than the density, the point is sampled. + mask = tf.math.less(rng.uniform(shape, dtype=density.dtype), density) return tf.cast(mask, tf.bool) @@ -660,8 +707,9 @@ def radial_waveform(base_resolution, readout_os=2.0, rank=2): if sys_util.is_op_library_enabled(): + spiral_waveform = _mri_ops.spiral_waveform spiral_waveform = api_util.export("sampling.spiral_waveform")( - _mri_ops.spiral_waveform) + spiral_waveform) else: # Stub to prevent import errors when the op is not available. spiral_waveform = None diff --git a/tensorflow_mri/python/ops/traj_ops_test.py b/tensorflow_mri/python/ops/traj_ops_test.py index 7dbab0e9..be595d76 100755 --- a/tensorflow_mri/python/ops/traj_ops_test.py +++ b/tensorflow_mri/python/ops/traj_ops_test.py @@ -26,7 +26,7 @@ from tensorflow_mri.python.util import test_util -class DensityGridTest(): +class DensityGridTest(test_util.TestCase): """Tests for `density_grid`.""" @parameterized.product(transition_type=['linear', 'quadratic', 'hann']) def test_density(self, transition_type): # pylint: disable=missing-function-docstring @@ -48,6 +48,60 @@ def test_density(self, transition_type): # pylint: disable=missing-function-doc self.assertAllClose(expected[transition_type], density) +class FrequencyGridTest(test_util.TestCase): + def test_frequency_grid_even(self): + result = traj_ops.frequency_grid([4]) + expected = [[-1.0], [-0.5], [0], [0.5]] + self.assertDTypeEqual(result, np.float32) + self.assertAllClose(expected, result) + + def test_frequency_grid_odd(self): + result = traj_ops.frequency_grid([5]) + expected = [[-1.0], [-0.5], [0], [0.5], [1.0]] + self.assertAllClose(expected, result) + + def test_frequency_grid_max_val(self): + result = traj_ops.frequency_grid([4], max_val=2.0) + expected = [[-2.0], [-1.0], [0], [1.0]] + self.assertAllClose(expected, result) + + def test_frequency_grid_2d(self): + result = traj_ops.frequency_grid([4, 8]) + expected = [[[-1. , -1. ], + [-1. , -0.75], + [-1. , -0.5 ], + [-1. , -0.25], + [-1. , 0. ], + [-1. , 0.25], + [-1. , 0.5 ], + [-1. , 0.75]], + [[-0.5 , -1. ], + [-0.5 , -0.75], + [-0.5 , -0.5 ], + [-0.5 , -0.25], + [-0.5 , 0. ], + [-0.5 , 0.25], + [-0.5 , 0.5 ], + [-0.5 , 0.75]], + [[ 0. , -1. ], + [ 0. , -0.75], + [ 0. , -0.5 ], + [ 0. , -0.25], + [ 0. , 0. ], + [ 0. , 0.25], + [ 0. , 0.5 ], + [ 0. , 0.75]], + [[ 0.5 , -1. ], + [ 0.5 , -0.75], + [ 0.5 , -0.5 ], + [ 0.5 , -0.25], + [ 0.5 , 0. ], + [ 0.5 , 0.25], + [ 0.5 , 0.5 ], + [ 0.5 , 0.75]]] + self.assertAllClose(expected, result) + + class RadialTrajectoryTest(test_util.TestCase): """Radial trajectory tests.""" @classmethod diff --git a/tensorflow_mri/python/util/api_util.py b/tensorflow_mri/python/util/api_util.py index 3a34af1c..c75afbf1 100644 --- a/tensorflow_mri/python/util/api_util.py +++ b/tensorflow_mri/python/util/api_util.py @@ -23,6 +23,7 @@ _API_ATTR = '_api_names' _SUBMODULE_NAMES = [ + 'activations', 'array', 'callbacks', 'coils', @@ -45,6 +46,7 @@ ] _SUBMODULE_DOCSTRINGS = { + 'activations': "Activation functions.", 'array': "Array processing operations.", 'callbacks': "Keras callbacks.", 'coils': "Parallel imaging operations.", diff --git a/tensorflow_mri/python/util/layer_util.py b/tensorflow_mri/python/util/layer_util.py index 880f7a40..40a68286 100644 --- a/tensorflow_mri/python/util/layer_util.py +++ b/tensorflow_mri/python/util/layer_util.py @@ -17,6 +17,8 @@ import tensorflow as tf from tensorflow_mri.python.layers import convolutional +from tensorflow_mri.python.layers import pooling +from tensorflow_mri.python.layers import reshaping from tensorflow_mri.python.layers import signal_layers @@ -41,9 +43,9 @@ def get_nd_layer(name, rank): _ND_LAYERS = { - ('AveragePooling', 1): tf.keras.layers.AveragePooling1D, - ('AveragePooling', 2): tf.keras.layers.AveragePooling2D, - ('AveragePooling', 3): tf.keras.layers.AveragePooling3D, + ('AveragePooling', 1): pooling.AveragePooling1D, + ('AveragePooling', 2): pooling.AveragePooling2D, + ('AveragePooling', 3): pooling.AveragePooling3D, ('Conv', 1): convolutional.Conv1D, ('Conv', 2): convolutional.Conv2D, ('Conv', 3): convolutional.Conv3D, @@ -72,17 +74,17 @@ def get_nd_layer(name, rank): ('IDWT', 3): signal_layers.IDWT3D, ('LocallyConnected', 1): tf.keras.layers.LocallyConnected1D, ('LocallyConnected', 2): tf.keras.layers.LocallyConnected2D, - ('MaxPool', 1): tf.keras.layers.MaxPool1D, - ('MaxPool', 2): tf.keras.layers.MaxPool2D, - ('MaxPool', 3): tf.keras.layers.MaxPool3D, + ('MaxPool', 1): pooling.MaxPooling1D, + ('MaxPool', 2): pooling.MaxPooling2D, + ('MaxPool', 3): pooling.MaxPooling3D, ('SeparableConv', 1): tf.keras.layers.SeparableConv1D, ('SeparableConv', 2): tf.keras.layers.SeparableConv2D, ('SpatialDropout', 1): tf.keras.layers.SpatialDropout1D, ('SpatialDropout', 2): tf.keras.layers.SpatialDropout2D, ('SpatialDropout', 3): tf.keras.layers.SpatialDropout3D, - ('UpSampling', 1): tf.keras.layers.UpSampling1D, - ('UpSampling', 2): tf.keras.layers.UpSampling2D, - ('UpSampling', 3): tf.keras.layers.UpSampling3D, + ('UpSampling', 1): reshaping.UpSampling1D, + ('UpSampling', 2): reshaping.UpSampling2D, + ('UpSampling', 3): reshaping.UpSampling3D, ('ZeroPadding', 1): tf.keras.layers.ZeroPadding1D, ('ZeroPadding', 2): tf.keras.layers.ZeroPadding2D, ('ZeroPadding', 3): tf.keras.layers.ZeroPadding3D diff --git a/tools/docs/tutorials/recon/unet_fastmri.ipynb b/tools/docs/tutorials/recon/unet_fastmri.ipynb index 45faf64b..35349ac9 100644 --- a/tools/docs/tutorials/recon/unet_fastmri.ipynb +++ b/tools/docs/tutorials/recon/unet_fastmri.ipynb @@ -16,7 +16,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "2022-08-02 17:29:22.299119: I tensorflow/core/util/util.cc:169] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n" + "2022-08-03 15:00:47.382162: I tensorflow/core/util/util.cc:169] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n" ] } ], @@ -50,9 +50,9 @@ "# If necessary, change the path names here.\n", "fastmri_path = pathlib.Path(\"/media/storage/fastmri\")\n", "\n", - "data_path_train = fastmri_path / \"knee_multicoil_train_temp\"\n", - "data_path_val = fastmri_path / \"knee_multicoil_val_temp\"\n", - "data_path_test = fastmri_path / \"knee_multicoil_test_temp\"" + "data_path_train = fastmri_path / \"knee_multicoil_train\"\n", + "data_path_val = fastmri_path / \"knee_multicoil_val\"\n", + "data_path_test = fastmri_path / \"knee_multicoil_test\"" ] }, { @@ -97,10 +97,7 @@ " tensors = {k: io_tensor(k).to_tensor() for k in io_tensor.keys}\n", " return {k: tf.ensure_shape(v, spec[k].shape) for k, v in tensors.items()}\n", "\n", - "def create_fastmri_dataset(files,\n", - " element_spec=None,\n", - " batch_size=1,\n", - " shuffle=False):\n", + "def initialize_fastmri_dataset(files):\n", " \"\"\"Creates a `tf.data.Dataset` from a list of fastMRI HDF5 files.\n", " \n", " Args:\n", @@ -118,7 +115,6 @@ " ds = tf.data.Dataset.from_tensor_slices(files)\n", " # Read the data in the file.\n", " ds = ds.map(functools.partial(read_hdf5, spec=element_spec))\n", - " # print(ds)\n", " # The first dimension of the inputs is the slice dimension. Split each\n", " # multi-slice element into multiple single-slice elements, as the\n", " # reconstruction is performed on a slice-by-slice basis.\n", @@ -126,14 +122,6 @@ " ds = ds.flat_map(split_slices)\n", " # Remove slashes.\n", " ds = ds.map(lambda x: {k[1:]: v for k, v in x.items()})\n", - " # TODO: create mask.\n", - "\n", - " # # TODO: create labels.\n", - " # if shuffle:\n", - " # ds = ds.shuffle(buffer_size=100)\n", - " # # Batch the elements.\n", - " # ds = ds.batch(batch_size)\n", - " # ds = ds.prefetch(buffer_size=tf.data.AUTOTUNE)\n", " return ds" ] }, @@ -146,65 +134,28 @@ "name": "stderr", "output_type": "stream", "text": [ - "2022-08-02 17:29:36.908974: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 AVX512F AVX512_VNNI FMA\n", + "2022-08-03 15:01:02.479368: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 AVX512F AVX512_VNNI FMA\n", "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", - "2022-08-02 17:29:37.798985: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1532] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 22290 MB memory: -> device: 0, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:65:00.0, compute capability: 8.6\n", - "2022-08-02 17:29:37.799498: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1532] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 22304 MB memory: -> device: 1, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:b3:00.0, compute capability: 8.6\n", - "2022-08-02 17:29:38.076969: I tensorflow_io/core/kernels/cpu_check.cc:128] Your CPU supports instructions that this TensorFlow IO binary was not compiled to use: AVX2 AVX512F FMA\n" + "2022-08-03 15:01:03.390115: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1532] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 22290 MB memory: -> device: 0, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:65:00.0, compute capability: 8.6\n", + "2022-08-03 15:01:03.390599: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1532] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 22304 MB memory: -> device: 1, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:b3:00.0, compute capability: 8.6\n", + "2022-08-03 15:01:03.677581: I tensorflow_io/core/kernels/cpu_check.cc:128] Your CPU supports instructions that this TensorFlow IO binary was not compiled to use: AVX2 AVX512F FMA\n" ] } ], "source": [ - "\n", - "batch_size = 1\n", - "\n", - "ds_train = create_fastmri_dataset(files_train,\n", - " element_spec=element_spec,\n", - " batch_size=batch_size,\n", - " shuffle=True)\n", - "\n", - "ds_val = create_fastmri_dataset(files_val,\n", - " element_spec=element_spec,\n", - " batch_size=batch_size,\n", - " shuffle=False)\n", - "\n", - "# ds_test = create_fastmri_dataset(files_test,\n", - "# element_spec=element_spec,\n", - "# batch_size=batch_size,\n", - "# shuffle=False)" + "ds_train = initialize_fastmri_dataset(files_train)\n", + "ds_val = initialize_fastmri_dataset(files_val)\n", + "# ds_test = initialize_fastmri_dataset(files_test)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(15, 640, 372)\n", - "(15, 640, 372)\n", - "(15, 640, 372)\n", - "(15, 640, 372)\n", - "(15, 640, 372)\n", - "(15, 640, 372)\n", - "(15, 640, 372)\n", - "(15, 640, 372)\n", - "(15, 640, 372)\n", - "(15, 640, 372)\n", - "(15, 640, 372)\n", - "(15, 640, 372)\n", - "(15, 640, 372)\n", - "(15, 640, 372)\n", - "(15, 640, 372)\n", - "(15, 640, 372)\n" - ] - } - ], + "outputs": [], "source": [ - "for example in ds_train.take(16):\n", - " print(example['kspace'].shape)" + "ds_train = ds_train.take(100)\n", + "ds_val = ds_val.take(100)" ] }, { @@ -214,7 +165,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -226,10 +177,12 @@ } ], "source": [ - "def show_examples(ds, fn):\n", - " _, axs = plt.subplots(4, 4, figsize=(12, 12))\n", - " for index, example in enumerate(ds.take(16)):\n", - " i, j = index // 4, index % 4\n", + "def show_examples(ds, fn, n=16):\n", + " cols = 4\n", + " rows = (n + cols - 1) // cols\n", + " _, axs = plt.subplots(rows, cols, figsize=(12, 3 * rows), squeeze=False)\n", + " for index, example in enumerate(ds.take(n)):\n", + " i, j = index // cols, index % cols\n", " axs[i, j].imshow(fn(example), cmap='gray')\n", " axs[i, j].axis('off')\n", " plt.show()\n", @@ -240,166 +193,349 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ - "def reconstruct_zerofilled(kspace):\n", + "def create_kspace_mask(kspace):\n", + " \"\"\"Subsamples a fastMRI example (single slice).\n", + "\n", + " Args:\n", + " ds: A `tf.data.Dataset` object.\n", + " \"\"\"\n", + " num_lines = tf.shape(kspace)[-1]\n", + " density_1d = tfmri.sampling.density_grid(shape=[num_lines],\n", + " inner_density=1.0,\n", + " inner_cutoff=0.08,\n", + " outer_cutoff=0.08,\n", + " outer_density=0.25)\n", + " mask_1d = tfmri.sampling.random_mask(\n", + " shape=[num_lines], density=density_1d)\n", + " mask_2d = tf.broadcast_to(mask_1d, tf.shape(kspace)[-2:])\n", + " return mask_2d\n", + " \n", + "def reconstruct_zerofilled(kspace, mask=None, sensitivities=None):\n", " image_shape = tf.shape(kspace)[-2:]\n", - " image = tfmri.recon.adjoint(kspace, image_shape)\n", + " image = tfmri.recon.adjoint(kspace, image_shape,\n", + " mask=mask, sensitivities=sensitivities)\n", + " if sensitivities is None:\n", + " image = tfmri.coils.combine_coils(image, coil_axis=-3)\n", " return image\n", "\n", - "def compute_sensitivities(kspace):\n", + "def filter_kspace_lowpass(kspace):\n", " def box(freq):\n", " cutoff = fully_sampled_region * np.pi\n", " result = tf.where(tf.math.abs(freq) < cutoff, 1, 0)\n", " return result\n", - " filt_kspace = tfmri.signal.filter_kspace(kspace,\n", - " filter_fn=box,\n", - " filter_rank=1)\n", + " return tfmri.signal.filter_kspace(kspace, filter_fn=box, filter_rank=1)\n", + "\n", + "def compute_sensitivities(kspace):\n", + " filt_kspace = filter_kspace_lowpass(kspace)\n", " filt_image = reconstruct_zerofilled(filt_kspace)\n", " sensitivities = tfmri.coils.estimate_sensitivities(filt_image, coil_axis=-3)\n", - " return sensitivities" + " return sensitivities\n", + "\n", + "def scale_kspace(kspace):\n", + " filt_kspace = filter_kspace_lowpass(kspace)\n", + " filt_image = reconstruct_zerofilled(filt_kspace)\n", + " scale = tf.math.reduce_max(tf.math.abs(filt_image))\n", + " return kspace / tf.cast(scale, kspace.dtype)" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def preprocess_fastmri_example(example, training=True):\n", + " # Drop the `reconstruction_rss` element. We will not be using that.\n", + " if 'reconstruction_rss' in example:\n", + " example.pop('reconstruction_rss')\n", + "\n", + " if training:\n", + " # Crop to 320x320.\n", + " image = tfmri.signal.ifft(example['kspace'], axes=[-2, -1], shift=True)\n", + " image = tfmri.resize_with_crop_or_pad(image, [320, 320])\n", + " example['kspace'] = tfmri.signal.fft(image, axes=[-2, -1], shift=True)\n", + "\n", + " # Create a subsampling mask.\n", + " example['mask'] = create_kspace_mask(example['kspace'])\n", + " full_kspace = example['kspace']\n", + " example['kspace'] = tf.where(example['mask'], example['kspace'], 0)\n", + "\n", + " # Create output image from fully sampled k-space.\n", + " full_kspace = scale_kspace(full_kspace)\n", + " image = reconstruct_zerofilled(full_kspace)\n", + " image = tf.expand_dims(image, -1)\n", + " image = tf.math.abs(image)\n", + " example = (example, image)\n", + " return example\n", + "\n", + "ds_train = ds_train.map(preprocess_fastmri_example)\n", + "ds_val = ds_val.map(preprocess_fastmri_example)\n", + "# ds_test = ds_test.map(functools.partial(preprocess_fastmri_example, training=False))\n", + "\n", + "# display_fn = lambda example: np.abs(example['image'].numpy()[5, ...])\n", + "# show_examples(ds_train, display_fn, n=16)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = 1\n", + "\n", + "ds_train = ds_train.shuffle(buffer_size=10)\n", + "\n", + "def finalize_fastmri_dataset(ds):\n", + " ds = ds.cache()\n", + " ds = ds.batch(batch_size)\n", + " ds = ds.prefetch(buffer_size=tf.data.AUTOTUNE)\n", + " return ds\n", + "\n", + "ds_train = finalize_fastmri_dataset(ds_train)\n", + "ds_val = finalize_fastmri_dataset(ds_val)\n", + "# ds_test = finalize_fastmri_dataset(ds_test, training=False) " + ] + }, + { + "cell_type": "code", + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Tensor(\"args_0:0\", shape=(None, None, None), dtype=complex64)\n" + "{'kspace': , 'mask': }\n" ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" } ], "source": [ - "def insert_sensitivities(example):\n", - " example['sensitivities'] = compute_sensitivities(example['kspace'])\n", - " return example\n", + "def create_keras_inputs(ds):\n", + " return tf.nest.map_structure(\n", + " lambda x, name: tf.keras.Input(shape=x.shape[1:], dtype=x.dtype, name=name),\n", + " ds.element_spec[0], {k: k for k in ds.element_spec[0].keys()})\n", "\n", - "ds_temp = ds_train.map(insert_sensitivities)\n", + "inputs = create_keras_inputs(ds_train)\n", "\n", - "display_fn = lambda example: np.abs(example['sensitivities'].numpy())[0, ...]\n", - "show_examples(ds_temp, display_fn)" + "print(inputs)" ] }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 13, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "class AdjointRecon(tf.keras.layers.Layer):\n", + " def __init__(self, **kwargs):\n", + " super().__init__(**kwargs)\n", + " \n", + " def call(self, inputs):\n", + " # Scale k-space signal.\n", + " kspace = scale_kspace(inputs['kspace'])\n", + " # Reconstruct image.\n", + " image = reconstruct_zerofilled(kspace, mask=inputs['mask'])\n", + " image = tf.expand_dims(image, -1)\n", + " image = tf.math.abs(image)\n", + " return image" + ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { - "ename": "TypeError", - "evalue": "Invalid shape (15, 640, 372) for image data", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/workspaces/tensorflow-mri/tools/docs/tutorials/recon/unet_fastmri.ipynb Cell 13\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 3\u001b[0m image \u001b[39m=\u001b[39m tf\u001b[39m.\u001b[39mmath\u001b[39m.\u001b[39mabs(image)\n\u001b[1;32m 4\u001b[0m \u001b[39mreturn\u001b[39;00m image\n\u001b[0;32m----> 6\u001b[0m show_examples(ds_train, display_fn)\n", - "\u001b[1;32m/workspaces/tensorflow-mri/tools/docs/tutorials/recon/unet_fastmri.ipynb Cell 13\u001b[0m in \u001b[0;36mshow_examples\u001b[0;34m(ds, fn)\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[39mfor\u001b[39;00m index, example \u001b[39min\u001b[39;00m \u001b[39menumerate\u001b[39m(ds\u001b[39m.\u001b[39mtake(\u001b[39m16\u001b[39m)):\n\u001b[1;32m 4\u001b[0m i, j \u001b[39m=\u001b[39m index \u001b[39m/\u001b[39m\u001b[39m/\u001b[39m \u001b[39m4\u001b[39m, index \u001b[39m%\u001b[39m \u001b[39m4\u001b[39m\n\u001b[0;32m----> 5\u001b[0m axs[i, j]\u001b[39m.\u001b[39;49mimshow(fn(example), cmap\u001b[39m=\u001b[39;49m\u001b[39m'\u001b[39;49m\u001b[39mgray\u001b[39;49m\u001b[39m'\u001b[39;49m)\n\u001b[1;32m 6\u001b[0m axs[i, j]\u001b[39m.\u001b[39maxis(\u001b[39m'\u001b[39m\u001b[39moff\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m 7\u001b[0m plt\u001b[39m.\u001b[39mshow()\n", - "File \u001b[0;32m/usr/local/lib/python3.8/site-packages/matplotlib/_api/deprecation.py:459\u001b[0m, in \u001b[0;36mmake_keyword_only..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 453\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mlen\u001b[39m(args) \u001b[39m>\u001b[39m name_idx:\n\u001b[1;32m 454\u001b[0m warn_deprecated(\n\u001b[1;32m 455\u001b[0m since, message\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mPassing the \u001b[39m\u001b[39m%(name)s\u001b[39;00m\u001b[39m \u001b[39m\u001b[39m%(obj_type)s\u001b[39;00m\u001b[39m \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 456\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mpositionally is deprecated since Matplotlib \u001b[39m\u001b[39m%(since)s\u001b[39;00m\u001b[39m; the \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 457\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mparameter will become keyword-only \u001b[39m\u001b[39m%(removal)s\u001b[39;00m\u001b[39m.\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[1;32m 458\u001b[0m name\u001b[39m=\u001b[39mname, obj_type\u001b[39m=\u001b[39m\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mparameter of \u001b[39m\u001b[39m{\u001b[39;00mfunc\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m\u001b[39m}\u001b[39;00m\u001b[39m()\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m--> 459\u001b[0m \u001b[39mreturn\u001b[39;00m func(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", - "File \u001b[0;32m/usr/local/lib/python3.8/site-packages/matplotlib/__init__.py:1412\u001b[0m, in \u001b[0;36m_preprocess_data..inner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1409\u001b[0m \u001b[39m@functools\u001b[39m\u001b[39m.\u001b[39mwraps(func)\n\u001b[1;32m 1410\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39minner\u001b[39m(ax, \u001b[39m*\u001b[39margs, data\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m 1411\u001b[0m \u001b[39mif\u001b[39;00m data \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m-> 1412\u001b[0m \u001b[39mreturn\u001b[39;00m func(ax, \u001b[39m*\u001b[39;49m\u001b[39mmap\u001b[39;49m(sanitize_sequence, args), \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 1414\u001b[0m bound \u001b[39m=\u001b[39m new_sig\u001b[39m.\u001b[39mbind(ax, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m 1415\u001b[0m auto_label \u001b[39m=\u001b[39m (bound\u001b[39m.\u001b[39marguments\u001b[39m.\u001b[39mget(label_namer)\n\u001b[1;32m 1416\u001b[0m \u001b[39mor\u001b[39;00m bound\u001b[39m.\u001b[39mkwargs\u001b[39m.\u001b[39mget(label_namer))\n", - "File \u001b[0;32m/usr/local/lib/python3.8/site-packages/matplotlib/axes/_axes.py:5481\u001b[0m, in \u001b[0;36mAxes.imshow\u001b[0;34m(self, X, cmap, norm, aspect, interpolation, alpha, vmin, vmax, origin, extent, interpolation_stage, filternorm, filterrad, resample, url, **kwargs)\u001b[0m\n\u001b[1;32m 5474\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mset_aspect(aspect)\n\u001b[1;32m 5475\u001b[0m im \u001b[39m=\u001b[39m mimage\u001b[39m.\u001b[39mAxesImage(\u001b[39mself\u001b[39m, cmap, norm, interpolation,\n\u001b[1;32m 5476\u001b[0m origin, extent, filternorm\u001b[39m=\u001b[39mfilternorm,\n\u001b[1;32m 5477\u001b[0m filterrad\u001b[39m=\u001b[39mfilterrad, resample\u001b[39m=\u001b[39mresample,\n\u001b[1;32m 5478\u001b[0m interpolation_stage\u001b[39m=\u001b[39minterpolation_stage,\n\u001b[1;32m 5479\u001b[0m \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[0;32m-> 5481\u001b[0m im\u001b[39m.\u001b[39;49mset_data(X)\n\u001b[1;32m 5482\u001b[0m im\u001b[39m.\u001b[39mset_alpha(alpha)\n\u001b[1;32m 5483\u001b[0m \u001b[39mif\u001b[39;00m im\u001b[39m.\u001b[39mget_clip_path() \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 5484\u001b[0m \u001b[39m# image does not already have clipping set, clip to axes patch\u001b[39;00m\n", - "File \u001b[0;32m/usr/local/lib/python3.8/site-packages/matplotlib/image.py:715\u001b[0m, in \u001b[0;36m_ImageBase.set_data\u001b[0;34m(self, A)\u001b[0m\n\u001b[1;32m 711\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_A \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_A[:, :, \u001b[39m0\u001b[39m]\n\u001b[1;32m 713\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m (\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_A\u001b[39m.\u001b[39mndim \u001b[39m==\u001b[39m \u001b[39m2\u001b[39m\n\u001b[1;32m 714\u001b[0m \u001b[39mor\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_A\u001b[39m.\u001b[39mndim \u001b[39m==\u001b[39m \u001b[39m3\u001b[39m \u001b[39mand\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_A\u001b[39m.\u001b[39mshape[\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m] \u001b[39min\u001b[39;00m [\u001b[39m3\u001b[39m, \u001b[39m4\u001b[39m]):\n\u001b[0;32m--> 715\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mTypeError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mInvalid shape \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m for image data\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 716\u001b[0m \u001b[39m.\u001b[39mformat(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_A\u001b[39m.\u001b[39mshape))\n\u001b[1;32m 718\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_A\u001b[39m.\u001b[39mndim \u001b[39m==\u001b[39m \u001b[39m3\u001b[39m:\n\u001b[1;32m 719\u001b[0m \u001b[39m# If the input data has values outside the valid range (after\u001b[39;00m\n\u001b[1;32m 720\u001b[0m \u001b[39m# normalisation), we issue a warning and then clip X to the bounds\u001b[39;00m\n\u001b[1;32m 721\u001b[0m \u001b[39m# - otherwise casting wraps extreme values, hiding outliers and\u001b[39;00m\n\u001b[1;32m 722\u001b[0m \u001b[39m# making reliable interpretation impossible.\u001b[39;00m\n\u001b[1;32m 723\u001b[0m high \u001b[39m=\u001b[39m \u001b[39m255\u001b[39m \u001b[39mif\u001b[39;00m np\u001b[39m.\u001b[39missubdtype(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_A\u001b[39m.\u001b[39mdtype, np\u001b[39m.\u001b[39minteger) \u001b[39melse\u001b[39;00m \u001b[39m1\u001b[39m\n", - "\u001b[0;31mTypeError\u001b[0m: Invalid shape (15, 640, 372) for image data" + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"model\"\n", + "__________________________________________________________________________________________________\n", + " Layer (type) Output Shape Param # Connected to \n", + "==================================================================================================\n", + " kspace (InputLayer) [(None, None, 320, 0 [] \n", + " 320)] \n", + " \n", + " mask (InputLayer) [(None, 320, 320)] 0 [] \n", + " \n", + " zfill (AdjointRecon) (None, 320, 320, 1) 0 ['kspace[0][0]', \n", + " 'mask[0][0]'] \n", + " \n", + " image (UNet2D) (None, 320, 320, 1) 471233 ['zfill[0][0]'] \n", + " \n", + "==================================================================================================\n", + "Total params: 471,233\n", + "Trainable params: 471,233\n", + "Non-trainable params: 0\n", + "__________________________________________________________________________________________________\n" + ] + } + ], + "source": [ + "zfill = AdjointRecon(name='zfill')(inputs)\n", + "image = tfmri.models.UNet2D(\n", + " filters=[32, 64, 128],\n", + " kernel_size=3,\n", + " out_channels=1,\n", + " name='image')(zfill)\n", + "outputs = {'zfill': zfill, 'image': image}\n", + "model = tf.keras.Model(inputs=inputs, outputs=outputs)\n", + "\n", + "model.compile(optimizer='adam',\n", + " loss='mse',\n", + " metrics=[tfmri.metrics.PSNR(), tfmri.metrics.SSIM()])\n", + "\n", + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n", + "10/10 [==============================] - 0s 32ms/step - loss: 0.0024 - image_loss: 0.0010 - zfill_loss: 0.0014 - image_psnr: 30.1323 - image_ssim: 0.8138 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0188 - val_image_loss: 0.0092 - val_zfill_loss: 0.0096 - val_image_psnr: 25.9510 - val_image_ssim: 0.6950 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n", + "Epoch 2/10\n", + "10/10 [==============================] - 0s 27ms/step - loss: 0.0023 - image_loss: 9.5412e-04 - zfill_loss: 0.0014 - image_psnr: 30.3361 - image_ssim: 0.8208 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0184 - val_image_loss: 0.0088 - val_zfill_loss: 0.0096 - val_image_psnr: 26.1827 - val_image_ssim: 0.7017 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n", + "Epoch 3/10\n", + "10/10 [==============================] - 0s 27ms/step - loss: 0.0023 - image_loss: 9.3707e-04 - zfill_loss: 0.0014 - image_psnr: 30.4387 - image_ssim: 0.8270 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0189 - val_image_loss: 0.0093 - val_zfill_loss: 0.0096 - val_image_psnr: 25.9678 - val_image_ssim: 0.7020 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n", + "Epoch 4/10\n", + "10/10 [==============================] - 0s 27ms/step - loss: 0.0023 - image_loss: 9.2630e-04 - zfill_loss: 0.0014 - image_psnr: 30.4900 - image_ssim: 0.8303 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0180 - val_image_loss: 0.0084 - val_zfill_loss: 0.0096 - val_image_psnr: 26.4080 - val_image_ssim: 0.7103 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n", + "Epoch 5/10\n", + "10/10 [==============================] - 0s 27ms/step - loss: 0.0022 - image_loss: 8.8115e-04 - zfill_loss: 0.0014 - image_psnr: 30.6902 - image_ssim: 0.8324 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0184 - val_image_loss: 0.0088 - val_zfill_loss: 0.0096 - val_image_psnr: 26.2524 - val_image_ssim: 0.7087 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n", + "Epoch 6/10\n", + "10/10 [==============================] - 0s 26ms/step - loss: 0.0022 - image_loss: 8.5386e-04 - zfill_loss: 0.0014 - image_psnr: 30.8466 - image_ssim: 0.8344 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0183 - val_image_loss: 0.0086 - val_zfill_loss: 0.0096 - val_image_psnr: 26.3446 - val_image_ssim: 0.7109 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n", + "Epoch 7/10\n", + "10/10 [==============================] - 0s 27ms/step - loss: 0.0022 - image_loss: 8.2480e-04 - zfill_loss: 0.0014 - image_psnr: 30.9937 - image_ssim: 0.8368 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0185 - val_image_loss: 0.0088 - val_zfill_loss: 0.0096 - val_image_psnr: 26.2712 - val_image_ssim: 0.7104 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n", + "Epoch 8/10\n", + "10/10 [==============================] - 0s 27ms/step - loss: 0.0022 - image_loss: 7.9195e-04 - zfill_loss: 0.0014 - image_psnr: 31.1618 - image_ssim: 0.8392 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0184 - val_image_loss: 0.0088 - val_zfill_loss: 0.0096 - val_image_psnr: 26.4792 - val_image_ssim: 0.7151 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n", + "Epoch 9/10\n", + "10/10 [==============================] - 0s 27ms/step - loss: 0.0021 - image_loss: 7.8288e-04 - zfill_loss: 0.0014 - image_psnr: 31.2020 - image_ssim: 0.8404 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0185 - val_image_loss: 0.0089 - val_zfill_loss: 0.0096 - val_image_psnr: 26.4445 - val_image_ssim: 0.7157 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n", + "Epoch 10/10\n", + "10/10 [==============================] - 0s 27ms/step - loss: 0.0021 - image_loss: 7.7723e-04 - zfill_loss: 0.0014 - image_psnr: 31.2320 - image_ssim: 0.8418 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0185 - val_image_loss: 0.0089 - val_zfill_loss: 0.0096 - val_image_psnr: 26.5072 - val_image_ssim: 0.7180 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n" ] }, { "data": { - "image/png": "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", "text/plain": [ - "
" + "" ] }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "def display_fn(example):\n", - " image = reconstruct_zerofilled(example['kspace'])\n", - " image = tf.math.abs(image)\n", - " return image\n", - "\n", - "show_examples(ds_train, display_fn)" + "model.fit(ds_train, epochs=10, validation_data=ds_val)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 114, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "30/30 [==============================] - 0s 8ms/step\n", + "(30, 320, 320, 1)\n" + ] + } + ], "source": [ - "def subsample(example):\n", - " \"\"\"Subsamples a fastMRI example (single slice).\n", - "\n", - " Args:\n", - " ds: A `tf.data.Dataset` object.\n", - " \"\"\"\n", - " kspace = example['kspace']\n", - " num_lines = tf.shape(kspace)[-1]\n", - " density_1d = tfmri.sampling.density_grid(shape=[num_lines],\n", - " inner_density=1.0,\n", - " inner_cutoff=0.08,\n", - " outer_cutoff=0.08,\n", - " outer_density=0.25)\n", - " mask_1d = tfmri.sampling.random_mask(shape=[num_lines], density=density_1d)\n", - " mask_2d = tf.tile(mask_1d, tf.shape(kspace)[-2:])\n", - " example['kspace'] *= mask_1d\n", - " example['mask'] = mask_2d\n", - " return example\n", - "\n", - "train_ds = ds_train.map(subsample)" + "result = model.predict(ds_train.take(30))\n", + "print(result['zfill'].shape)" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 116, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 116, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(result['image'][8, ...])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, "metadata": {}, "outputs": [ { - "ename": "NameError", - "evalue": "name 'tfmri' is not defined", + "ename": "AttributeError", + "evalue": "module 'tensorflow_mri._api.layers' has no attribute 'LeastSquaresGradientDescent'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/workspaces/tensorflow-mri/tools/docs/tutorials/recon/unet_fastmri.ipynb Cell 7\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m model \u001b[39m=\u001b[39m tfmri\u001b[39m.\u001b[39mmodels\u001b[39m.\u001b[39mUNet2D(filters\u001b[39m=\u001b[39m[\u001b[39m32\u001b[39m, \u001b[39m64\u001b[39m, \u001b[39m128\u001b[39m], kernel_size\u001b[39m=\u001b[39m\u001b[39m3\u001b[39m)\n\u001b[1;32m 3\u001b[0m model\u001b[39m.\u001b[39mcompile(optimizer\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mrmsprop\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 4\u001b[0m loss\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mmse\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 5\u001b[0m metrics\u001b[39m=\u001b[39m[tfmri\u001b[39m.\u001b[39mmetrics\u001b[39m.\u001b[39mPSNR(),\n\u001b[1;32m 6\u001b[0m tfmri\u001b[39m.\u001b[39mmetrics\u001b[39m.\u001b[39mSSIM()])\n", - "\u001b[0;31mNameError\u001b[0m: name 'tfmri' is not defined" + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/workspaces/tensorflow-mri/tools/docs/tutorials/recon/unet_fastmri.ipynb Cell 19\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 18\u001b[0m outputs \u001b[39m=\u001b[39m {\u001b[39m'\u001b[39m\u001b[39mzfill\u001b[39m\u001b[39m'\u001b[39m: zfill, \u001b[39m'\u001b[39m\u001b[39mimage\u001b[39m\u001b[39m'\u001b[39m: x}\n\u001b[1;32m 19\u001b[0m \u001b[39mreturn\u001b[39;00m tf\u001b[39m.\u001b[39mkeras\u001b[39m.\u001b[39mModel(inputs\u001b[39m=\u001b[39minputs, outputs\u001b[39m=\u001b[39moutputs)\n\u001b[0;32m---> 22\u001b[0m model \u001b[39m=\u001b[39m VarNet(inputs)\n\u001b[1;32m 24\u001b[0m model\u001b[39m.\u001b[39mcompile(optimizer\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39madam\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 25\u001b[0m loss\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mmse\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 26\u001b[0m metrics\u001b[39m=\u001b[39m[tfmri\u001b[39m.\u001b[39mmetrics\u001b[39m.\u001b[39mPSNR(), tfmri\u001b[39m.\u001b[39mmetrics\u001b[39m.\u001b[39mSSIM()])\n\u001b[1;32m 28\u001b[0m model\u001b[39m.\u001b[39msummary()\n", + "\u001b[1;32m/workspaces/tensorflow-mri/tools/docs/tutorials/recon/unet_fastmri.ipynb Cell 19\u001b[0m in \u001b[0;36mVarNet\u001b[0;34m(inputs, num_iterations)\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mVarNet\u001b[39m(inputs, num_iterations\u001b[39m=\u001b[39m\u001b[39m5\u001b[39m):\n\u001b[1;32m 2\u001b[0m zfill \u001b[39m=\u001b[39m AdjointRecon(name\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mzfill\u001b[39m\u001b[39m'\u001b[39m)(inputs)\n\u001b[0;32m----> 4\u001b[0m lsgd \u001b[39m=\u001b[39m tfmri\u001b[39m.\u001b[39;49mlayers\u001b[39m.\u001b[39;49mLeastSquaresGradientDescent(\n\u001b[1;32m 5\u001b[0m operator\u001b[39m=\u001b[39mtfmri\u001b[39m.\u001b[39mlinalg\u001b[39m.\u001b[39mLinearOperatorMRI)\n\u001b[1;32m 7\u001b[0m denoise \u001b[39m=\u001b[39m tfmri\u001b[39m.\u001b[39mmodels\u001b[39m.\u001b[39mUNet2D(\n\u001b[1;32m 8\u001b[0m filters\u001b[39m=\u001b[39m[\u001b[39m32\u001b[39m, \u001b[39m64\u001b[39m, \u001b[39m128\u001b[39m],\n\u001b[1;32m 9\u001b[0m kernel_size\u001b[39m=\u001b[39m\u001b[39m3\u001b[39m,\n\u001b[1;32m 10\u001b[0m out_channels\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m,\n\u001b[1;32m 11\u001b[0m name\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mprior\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m 13\u001b[0m x \u001b[39m=\u001b[39m zfill\n", + "\u001b[0;31mAttributeError\u001b[0m: module 'tensorflow_mri._api.layers' has no attribute 'LeastSquaresGradientDescent'" ] } ], "source": [ - "model = tfmri.models.UNet2D(filters=[32, 64, 128], kernel_size=3)\n", + "def VarNet(inputs, num_iterations=5):\n", + " zfill = AdjointRecon(name='zfill')(inputs)\n", + "\n", + " lsgd = tfmri.layers.LeastSquaresGradientDescent(\n", + " operator=tfmri.linalg.LinearOperatorMRI)\n", + "\n", + " denoise = tfmri.models.UNet2D(\n", + " filters=[32, 64, 128],\n", + " kernel_size=3,\n", + " out_channels=1,\n", + " name='prior')\n", + "\n", + " x = zfill\n", + " for i in range(num_iterations):\n", + " x = denoise(x)\n", + " x = lsgd(x)\n", + "\n", + " outputs = {'zfill': zfill, 'image': x}\n", + " return tf.keras.Model(inputs=inputs, outputs=outputs)\n", "\n", - "model.compile(optimizer='rmsprop',\n", + "model = VarNet(inputs)\n", + "\n", + "model.compile(optimizer='adam',\n", " loss='mse',\n", - " metrics=[tfmri.metrics.PSNR(),\n", - " tfmri.metrics.SSIM()])" + " metrics=[tfmri.metrics.PSNR(), tfmri.metrics.SSIM()])\n", + "\n", + "model.summary()" ] }, { @@ -407,9 +543,7 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "model.fit(ds_train, epochs=1, validation_data=ds_val)" - ] + "source": [] } ], "metadata": { From 2b5fcb022fad5e39cbe665923f7dc48a3d4a6baa Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 4 Aug 2022 10:00:30 +0000 Subject: [PATCH 010/101] Added ModReLU activation, some fixes to API exports --- tensorflow_mri/__init__.py | 1 + tensorflow_mri/_api/activations/__init__.py | 6 + tensorflow_mri/_api/layers/__init__.py | 4 + tensorflow_mri/_api/sampling/__init__.py | 2 +- tensorflow_mri/_api/signal/__init__.py | 16 +- tensorflow_mri/python/__init__.py | 1 + .../python/activations/complex_activations.py | 83 +- tensorflow_mri/python/ops/traj_ops.py | 5 +- tools/docs/tutorials/recon/unet_fastmri.ipynb | 792 +++++++++++++++--- 9 files changed, 789 insertions(+), 121 deletions(-) create mode 100644 tensorflow_mri/_api/activations/__init__.py diff --git a/tensorflow_mri/__init__.py b/tensorflow_mri/__init__.py index f28d39b6..b9d54286 100644 --- a/tensorflow_mri/__init__.py +++ b/tensorflow_mri/__init__.py @@ -22,6 +22,7 @@ from tensorflow_mri import python # Import submodules. +from tensorflow_mri._api import activations from tensorflow_mri._api import array from tensorflow_mri._api import callbacks from tensorflow_mri._api import coils diff --git a/tensorflow_mri/_api/activations/__init__.py b/tensorflow_mri/_api/activations/__init__.py new file mode 100644 index 00000000..cfee3523 --- /dev/null +++ b/tensorflow_mri/_api/activations/__init__.py @@ -0,0 +1,6 @@ +# This file was automatically generated by tools/build/create_api.py. +# Do not edit. +"""Activation functions.""" + +from tensorflow_mri.python.activations.complex_activations import wrapper as complex_relu +from tensorflow_mri.python.activations.complex_activations import wrapper as mod_relu diff --git a/tensorflow_mri/_api/layers/__init__.py b/tensorflow_mri/_api/layers/__init__.py index 09740d52..6e058d6f 100644 --- a/tensorflow_mri/_api/layers/__init__.py +++ b/tensorflow_mri/_api/layers/__init__.py @@ -10,6 +10,7 @@ from tensorflow_mri.python.layers.convolutional import Conv3D as Convolution3D from tensorflow_mri.python.layers.conv_blocks import ConvBlock as ConvBlock from tensorflow_mri.python.layers.conv_endec import UNet as UNet +from tensorflow_mri.python.layers.data_consistency import LeastSquaresGradientDescent as LeastSquaresGradientDescent from tensorflow_mri.python.layers.pooling import AveragePooling1D as AveragePooling1D from tensorflow_mri.python.layers.pooling import AveragePooling1D as AvgPool1D from tensorflow_mri.python.layers.pooling import AveragePooling2D as AveragePooling2D @@ -22,6 +23,9 @@ from tensorflow_mri.python.layers.pooling import MaxPooling2D as MaxPool2D from tensorflow_mri.python.layers.pooling import MaxPooling3D as MaxPooling3D from tensorflow_mri.python.layers.pooling import MaxPooling3D as MaxPool3D +from tensorflow_mri.python.layers.reshaping import UpSampling1D as UpSampling1D +from tensorflow_mri.python.layers.reshaping import UpSampling2D as UpSampling2D +from tensorflow_mri.python.layers.reshaping import UpSampling3D as UpSampling3D from tensorflow_mri.python.layers.signal_layers import DWT1D as DWT1D from tensorflow_mri.python.layers.signal_layers import DWT2D as DWT2D from tensorflow_mri.python.layers.signal_layers import DWT3D as DWT3D diff --git a/tensorflow_mri/_api/sampling/__init__.py b/tensorflow_mri/_api/sampling/__init__.py index ad5b3905..ad827d32 100644 --- a/tensorflow_mri/_api/sampling/__init__.py +++ b/tensorflow_mri/_api/sampling/__init__.py @@ -10,7 +10,7 @@ from tensorflow_mri.python.ops.traj_ops import radial_density as radial_density from tensorflow_mri.python.ops.traj_ops import estimate_radial_density as estimate_radial_density from tensorflow_mri.python.ops.traj_ops import radial_waveform as radial_waveform -# from 1c67b1db4cb5c043d469006db82e3356e63fbfcc import spiral_waveform as spiral_waveform +from tensorflow_mri.python.ops.traj_ops import spiral_waveform as spiral_waveform from tensorflow_mri.python.ops.traj_ops import estimate_density as estimate_density from tensorflow_mri.python.ops.traj_ops import flatten_trajectory as flatten_trajectory from tensorflow_mri.python.ops.traj_ops import flatten_density as flatten_density diff --git a/tensorflow_mri/_api/signal/__init__.py b/tensorflow_mri/_api/signal/__init__.py index b18f9761..b8e37ce3 100644 --- a/tensorflow_mri/_api/signal/__init__.py +++ b/tensorflow_mri/_api/signal/__init__.py @@ -2,14 +2,6 @@ # Do not edit. """Signal processing operations.""" -from tensorflow_mri.python.ops.signal_ops import hann as hann -from tensorflow_mri.python.ops.signal_ops import hamming as hamming -from tensorflow_mri.python.ops.signal_ops import atanfilt as atanfilt -from tensorflow_mri.python.ops.signal_ops import filter_kspace as filter_kspace -from tensorflow_mri.python.ops.signal_ops import crop_kspace as crop_kspace -from tensorflow_mri.python.ops.fft_ops import fftn as fft -from tensorflow_mri.python.ops.fft_ops import ifftn as ifft -from tensorflow_nufft.python.ops.nufft_ops import nufft as nufft from tensorflow_mri.python.ops.wavelet_ops import dwt as dwt from tensorflow_mri.python.ops.wavelet_ops import idwt as idwt from tensorflow_mri.python.ops.wavelet_ops import wavedec as wavedec @@ -17,3 +9,11 @@ from tensorflow_mri.python.ops.wavelet_ops import dwt_max_level as max_wavelet_level from tensorflow_mri.python.ops.wavelet_ops import coeffs_to_tensor as wavelet_coeffs_to_tensor from tensorflow_mri.python.ops.wavelet_ops import tensor_to_coeffs as tensor_to_wavelet_coeffs +from tensorflow_mri.python.ops.fft_ops import fftn as fft +from tensorflow_mri.python.ops.fft_ops import ifftn as ifft +from tensorflow_nufft.python.ops.nufft_ops import nufft as nufft +from tensorflow_mri.python.ops.signal_ops import hann as hann +from tensorflow_mri.python.ops.signal_ops import hamming as hamming +from tensorflow_mri.python.ops.signal_ops import atanfilt as atanfilt +from tensorflow_mri.python.ops.signal_ops import filter_kspace as filter_kspace +from tensorflow_mri.python.ops.signal_ops import crop_kspace as crop_kspace diff --git a/tensorflow_mri/python/__init__.py b/tensorflow_mri/python/__init__.py index a678124c..67e902f7 100644 --- a/tensorflow_mri/python/__init__.py +++ b/tensorflow_mri/python/__init__.py @@ -14,6 +14,7 @@ # ============================================================================== "TFMRI Python code." +from tensorflow_mri.python import activations from tensorflow_mri.python import callbacks from tensorflow_mri.python import initializers from tensorflow_mri.python import io diff --git a/tensorflow_mri/python/activations/complex_activations.py b/tensorflow_mri/python/activations/complex_activations.py index bb556446..df7804be 100644 --- a/tensorflow_mri/python/activations/complex_activations.py +++ b/tensorflow_mri/python/activations/complex_activations.py @@ -14,8 +14,6 @@ # ============================================================================== """Complex-valued activations.""" -import functools - import tensorflow as tf from tensorflow_mri.python.util import api_util @@ -27,7 +25,6 @@ def complexified(split='real_imag'): raise ValueError( f"split must be one of 'real_imag' or 'abs_angle', but got: {split}") def decorator(func): - @functools.wraps(func) def wrapper(x, *args, **kwargs): x = tf.convert_to_tensor(x) if x.dtype.is_complex: @@ -38,9 +35,89 @@ def wrapper(x, *args, **kwargs): return tf.dtypes.complex(func(tf.math.real(x), *args, **kwargs), func(tf.math.imag(x), *args, **kwargs)) return func(x, *args, **kwargs) + return wrapper return decorator + complex_relu = api_util.export("activations.complex_relu")( complexified(split='real_imag')(tf.keras.activations.relu)) +complex_relu.__doc__ = ( + """Applies the rectified linear unit activation function. + + With default values, this returns the standard ReLU activation: + `max(x, 0)`, the element-wise maximum of 0 and the input tensor. + + Modifying default parameters allows you to use non-zero thresholds, + change the max value of the activation, and to use a non-zero multiple of + the input for values below the threshold. + + If passed a complex-valued tensor, the ReLU activation is independently + applied to its real and imaginary parts, i.e., the function returns + `relu(real(x)) + 1j * relu(imag(x))`. + + .. note:: + This activation does not preserve the phase of complex inputs. + + If passed a real-valued tensor, this function falls back to the standard + `tf.keras.activations.relu`_. + + Args: + x: The input `tf.Tensor`. Can be real or complex. + alpha: A `float` that governs the slope for values lower than the + threshold. + max_value: A `float` that sets the saturation threshold (the largest value + the function will return). + threshold: A `float` giving the threshold value of the activation function + below which values will be damped or set to zero. + + Returns: + A `tf.Tensor` of the same shape and dtype of input `x`. + + .. _tf.keras.activations.relu: https://www.tensorflow.org/api_docs/python/tf/keras/activations/relu + """ +) + + +mod_relu = api_util.export("activations.mod_relu")( + complexified(split='abs_angle')(tf.keras.activations.relu)) +mod_relu.__doc__ = ( + """Applies the rectified linear unit activation function. + + With default values, this returns the standard ReLU activation: + `max(x, 0)`, the element-wise maximum of 0 and the input tensor. + + Modifying default parameters allows you to use non-zero thresholds, + change the max value of the activation, and to use a non-zero multiple of + the input for values below the threshold. + + If passed a complex-valued tensor, the ReLU activation is applied to its + magnitude, i.e., the function returns `relu(abs(x)) * exp(1j * angle(x))`. + + .. note:: + This activation preserves the phase of complex inputs. + + .. warning:: + With default parameters, this activation is linear, since the magnitude + of the input is never negative. Usually you will want to set one or more + of the provided parameters to non-default values. + + If passed a real-valued tensor, this function falls back to the standard + `tf.keras.activations.relu`_. + + Args: + x: The input `tf.Tensor`. Can be real or complex. + alpha: A `float` that governs the slope for values lower than the + threshold. + max_value: A `float` that sets the saturation threshold (the largest value + the function will return). + threshold: A `float` giving the threshold value of the activation function + below which values will be damped or set to zero. + + Returns: + A `tf.Tensor` of the same shape and dtype of input `x`. + + .. _tf.keras.activations.relu: https://www.tensorflow.org/api_docs/python/tf/keras/activations/relu + """ +) diff --git a/tensorflow_mri/python/ops/traj_ops.py b/tensorflow_mri/python/ops/traj_ops.py index b74bf6cd..21374506 100755 --- a/tensorflow_mri/python/ops/traj_ops.py +++ b/tensorflow_mri/python/ops/traj_ops.py @@ -707,9 +707,10 @@ def radial_waveform(base_resolution, readout_os=2.0, rank=2): if sys_util.is_op_library_enabled(): - spiral_waveform = _mri_ops.spiral_waveform spiral_waveform = api_util.export("sampling.spiral_waveform")( - spiral_waveform) + _mri_ops.spiral_waveform) + # Set the object's module to current module for correct API import. + spiral_waveform.__module__ = __name__ else: # Stub to prevent import errors when the op is not available. spiral_waveform = None diff --git a/tools/docs/tutorials/recon/unet_fastmri.ipynb b/tools/docs/tutorials/recon/unet_fastmri.ipynb index 35349ac9..ff3756de 100644 --- a/tools/docs/tutorials/recon/unet_fastmri.ipynb +++ b/tools/docs/tutorials/recon/unet_fastmri.ipynb @@ -9,19 +9,12 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 40, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2022-08-03 15:00:47.382162: I tensorflow/core/util/util.cc:169] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n" - ] - } - ], + "outputs": [], "source": [ "import functools\n", + "import itertools\n", "import pathlib\n", "\n", "import numpy as np\n", @@ -33,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 41, "metadata": {}, "outputs": [], "source": [ @@ -43,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 42, "metadata": {}, "outputs": [], "source": [ @@ -57,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 43, "metadata": {}, "outputs": [], "source": [ @@ -68,7 +61,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 44, "metadata": {}, "outputs": [], "source": [ @@ -127,21 +120,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 45, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2022-08-03 15:01:02.479368: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 AVX512F AVX512_VNNI FMA\n", - "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", - "2022-08-03 15:01:03.390115: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1532] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 22290 MB memory: -> device: 0, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:65:00.0, compute capability: 8.6\n", - "2022-08-03 15:01:03.390599: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1532] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 22304 MB memory: -> device: 1, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:b3:00.0, compute capability: 8.6\n", - "2022-08-03 15:01:03.677581: I tensorflow_io/core/kernels/cpu_check.cc:128] Your CPU supports instructions that this TensorFlow IO binary was not compiled to use: AVX2 AVX512F FMA\n" - ] - } - ], + "outputs": [], "source": [ "ds_train = initialize_fastmri_dataset(files_train)\n", "ds_val = initialize_fastmri_dataset(files_val)\n", @@ -150,7 +131,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 46, "metadata": {}, "outputs": [], "source": [ @@ -160,7 +141,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 47, "metadata": {}, "outputs": [ { @@ -181,7 +162,11 @@ " cols = 4\n", " rows = (n + cols - 1) // cols\n", " _, axs = plt.subplots(rows, cols, figsize=(12, 3 * rows), squeeze=False)\n", - " for index, example in enumerate(ds.take(n)):\n", + " if isinstance(ds, tf.data.Dataset):\n", + " ds = ds.take(n)\n", + " else:\n", + " ds = itertools.islice(ds, n)\n", + " for index, example in enumerate(ds):\n", " i, j = index // cols, index % cols\n", " axs[i, j].imshow(fn(example), cmap='gray')\n", " axs[i, j].axis('off')\n", @@ -193,7 +178,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -244,7 +229,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -282,7 +267,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -303,7 +288,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -327,13 +312,14 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "class AdjointRecon(tf.keras.layers.Layer):\n", - " def __init__(self, **kwargs):\n", + " def __init__(self, magnitude_only=False, **kwargs):\n", " super().__init__(**kwargs)\n", + " self.magnitude_only = magnitude_only\n", " \n", " def call(self, inputs):\n", " # Scale k-space signal.\n", @@ -341,20 +327,21 @@ " # Reconstruct image.\n", " image = reconstruct_zerofilled(kspace, mask=inputs['mask'])\n", " image = tf.expand_dims(image, -1)\n", - " image = tf.math.abs(image)\n", + " if self.magnitude_only:\n", + " image = tf.math.abs(image)\n", " return image" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Model: \"model\"\n", + "Model: \"model_1\"\n", "__________________________________________________________________________________________________\n", " Layer (type) Output Shape Param # Connected to \n", "==================================================================================================\n", @@ -377,14 +364,17 @@ } ], "source": [ - "zfill = AdjointRecon(name='zfill')(inputs)\n", - "image = tfmri.models.UNet2D(\n", - " filters=[32, 64, 128],\n", - " kernel_size=3,\n", - " out_channels=1,\n", - " name='image')(zfill)\n", - "outputs = {'zfill': zfill, 'image': image}\n", - "model = tf.keras.Model(inputs=inputs, outputs=outputs)\n", + "def BaselineUNet(inputs):\n", + " zfill = AdjointRecon(magnitude_only=True, name='zfill')(inputs)\n", + " image = tfmri.models.UNet2D(\n", + " filters=[32, 64, 128],\n", + " kernel_size=3,\n", + " out_channels=1,\n", + " name='image')(zfill)\n", + " outputs = {'zfill': zfill, 'image': image}\n", + " return tf.keras.Model(inputs=inputs, outputs=outputs)\n", + "\n", + "model = BaselineUNet(inputs)\n", "\n", "model.compile(optimizer='adam',\n", " loss='mse',\n", @@ -395,89 +385,676 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "# model.fit(ds_train, epochs=10, validation_data=ds_val)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 1/10\n", - "10/10 [==============================] - 0s 32ms/step - loss: 0.0024 - image_loss: 0.0010 - zfill_loss: 0.0014 - image_psnr: 30.1323 - image_ssim: 0.8138 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0188 - val_image_loss: 0.0092 - val_zfill_loss: 0.0096 - val_image_psnr: 25.9510 - val_image_ssim: 0.6950 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n", - "Epoch 2/10\n", - "10/10 [==============================] - 0s 27ms/step - loss: 0.0023 - image_loss: 9.5412e-04 - zfill_loss: 0.0014 - image_psnr: 30.3361 - image_ssim: 0.8208 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0184 - val_image_loss: 0.0088 - val_zfill_loss: 0.0096 - val_image_psnr: 26.1827 - val_image_ssim: 0.7017 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n", - "Epoch 3/10\n", - "10/10 [==============================] - 0s 27ms/step - loss: 0.0023 - image_loss: 9.3707e-04 - zfill_loss: 0.0014 - image_psnr: 30.4387 - image_ssim: 0.8270 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0189 - val_image_loss: 0.0093 - val_zfill_loss: 0.0096 - val_image_psnr: 25.9678 - val_image_ssim: 0.7020 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n", - "Epoch 4/10\n", - "10/10 [==============================] - 0s 27ms/step - loss: 0.0023 - image_loss: 9.2630e-04 - zfill_loss: 0.0014 - image_psnr: 30.4900 - image_ssim: 0.8303 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0180 - val_image_loss: 0.0084 - val_zfill_loss: 0.0096 - val_image_psnr: 26.4080 - val_image_ssim: 0.7103 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n", - "Epoch 5/10\n", - "10/10 [==============================] - 0s 27ms/step - loss: 0.0022 - image_loss: 8.8115e-04 - zfill_loss: 0.0014 - image_psnr: 30.6902 - image_ssim: 0.8324 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0184 - val_image_loss: 0.0088 - val_zfill_loss: 0.0096 - val_image_psnr: 26.2524 - val_image_ssim: 0.7087 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n", - "Epoch 6/10\n", - "10/10 [==============================] - 0s 26ms/step - loss: 0.0022 - image_loss: 8.5386e-04 - zfill_loss: 0.0014 - image_psnr: 30.8466 - image_ssim: 0.8344 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0183 - val_image_loss: 0.0086 - val_zfill_loss: 0.0096 - val_image_psnr: 26.3446 - val_image_ssim: 0.7109 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n", - "Epoch 7/10\n", - "10/10 [==============================] - 0s 27ms/step - loss: 0.0022 - image_loss: 8.2480e-04 - zfill_loss: 0.0014 - image_psnr: 30.9937 - image_ssim: 0.8368 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0185 - val_image_loss: 0.0088 - val_zfill_loss: 0.0096 - val_image_psnr: 26.2712 - val_image_ssim: 0.7104 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n", - "Epoch 8/10\n", - "10/10 [==============================] - 0s 27ms/step - loss: 0.0022 - image_loss: 7.9195e-04 - zfill_loss: 0.0014 - image_psnr: 31.1618 - image_ssim: 0.8392 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0184 - val_image_loss: 0.0088 - val_zfill_loss: 0.0096 - val_image_psnr: 26.4792 - val_image_ssim: 0.7151 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n", - "Epoch 9/10\n", - "10/10 [==============================] - 0s 27ms/step - loss: 0.0021 - image_loss: 7.8288e-04 - zfill_loss: 0.0014 - image_psnr: 31.2020 - image_ssim: 0.8404 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0185 - val_image_loss: 0.0089 - val_zfill_loss: 0.0096 - val_image_psnr: 26.4445 - val_image_ssim: 0.7157 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n", - "Epoch 10/10\n", - "10/10 [==============================] - 0s 27ms/step - loss: 0.0021 - image_loss: 7.7723e-04 - zfill_loss: 0.0014 - image_psnr: 31.2320 - image_ssim: 0.8418 - zfill_psnr: 28.8012 - zfill_ssim: 0.7830 - val_loss: 0.0185 - val_image_loss: 0.0089 - val_zfill_loss: 0.0096 - val_image_psnr: 26.5072 - val_image_ssim: 0.7180 - val_zfill_psnr: 24.2099 - val_zfill_ssim: 0.6666\n" + "{'zfill': array([[[[0.03730954],\n", + " [0.04248981],\n", + " [0.03511715],\n", + " ...,\n", + " [0.03627022],\n", + " [0.03310308],\n", + " [0.04002528]],\n", + "\n", + " [[0.04117708],\n", + " [0.02795216],\n", + " [0.03342503],\n", + " ...,\n", + " [0.03422057],\n", + " [0.0305617 ],\n", + " [0.03323219]],\n", + "\n", + " [[0.03162055],\n", + " [0.03424564],\n", + " [0.04071327],\n", + " ...,\n", + " [0.03863482],\n", + " [0.03950511],\n", + " [0.04508803]],\n", + "\n", + " ...,\n", + "\n", + " [[0.03643849],\n", + " [0.03413566],\n", + " [0.03994865],\n", + " ...,\n", + " [0.04486349],\n", + " [0.04716439],\n", + " [0.05293337]],\n", + "\n", + " [[0.04042355],\n", + " [0.04095628],\n", + " [0.05113396],\n", + " ...,\n", + " [0.03842064],\n", + " [0.05322709],\n", + " [0.04076931]],\n", + "\n", + " [[0.05052018],\n", + " [0.04702099],\n", + " [0.04676762],\n", + " ...,\n", + " [0.03381801],\n", + " [0.04896087],\n", + " [0.03535406]]],\n", + "\n", + "\n", + " [[[0.03114065],\n", + " [0.04702193],\n", + " [0.03025192],\n", + " ...,\n", + " [0.02723994],\n", + " [0.02741306],\n", + " [0.03783687]],\n", + "\n", + " [[0.03372868],\n", + " [0.03541645],\n", + " [0.03232943],\n", + " ...,\n", + " [0.04178388],\n", + " [0.03118657],\n", + " [0.03604896]],\n", + "\n", + " [[0.02559258],\n", + " [0.03752475],\n", + " [0.04094908],\n", + " ...,\n", + " [0.03027781],\n", + " [0.04414068],\n", + " [0.04159149]],\n", + "\n", + " ...,\n", + "\n", + " [[0.03962037],\n", + " [0.04539109],\n", + " [0.04313568],\n", + " ...,\n", + " [0.03776349],\n", + " [0.04792673],\n", + " [0.04799293]],\n", + "\n", + " [[0.02798527],\n", + " [0.03403655],\n", + " [0.03891989],\n", + " ...,\n", + " [0.05696635],\n", + " [0.0438323 ],\n", + " [0.04689693]],\n", + "\n", + " [[0.03729939],\n", + " [0.04697356],\n", + " [0.03774005],\n", + " ...,\n", + " [0.04366778],\n", + " [0.04349282],\n", + " [0.0391708 ]]],\n", + "\n", + "\n", + " [[[0.03696218],\n", + " [0.03955268],\n", + " [0.03244933],\n", + " ...,\n", + " [0.04564377],\n", + " [0.04518688],\n", + " [0.04128893]],\n", + "\n", + " [[0.04216101],\n", + " [0.034663 ],\n", + " [0.04719481],\n", + " ...,\n", + " [0.05366581],\n", + " [0.04280291],\n", + " [0.04502771]],\n", + "\n", + " [[0.04425316],\n", + " [0.04977743],\n", + " [0.06375591],\n", + " ...,\n", + " [0.05387824],\n", + " [0.04947987],\n", + " [0.04541088]],\n", + "\n", + " ...,\n", + "\n", + " [[0.05660668],\n", + " [0.04080752],\n", + " [0.04646816],\n", + " ...,\n", + " [0.0358771 ],\n", + " [0.04357762],\n", + " [0.0356135 ]],\n", + "\n", + " [[0.03870127],\n", + " [0.03450824],\n", + " [0.05299501],\n", + " ...,\n", + " [0.0410384 ],\n", + " [0.04126841],\n", + " [0.05327509]],\n", + "\n", + " [[0.04185225],\n", + " [0.05284803],\n", + " [0.05215264],\n", + " ...,\n", + " [0.03986993],\n", + " [0.04249096],\n", + " [0.03834104]]],\n", + "\n", + "\n", + " ...,\n", + "\n", + "\n", + " [[[0.06054531],\n", + " [0.07125156],\n", + " [0.05390326],\n", + " ...,\n", + " [0.05641456],\n", + " [0.04851629],\n", + " [0.05175951]],\n", + "\n", + " [[0.05432056],\n", + " [0.04388288],\n", + " [0.04020565],\n", + " ...,\n", + " [0.05326294],\n", + " [0.04760348],\n", + " [0.04637051]],\n", + "\n", + " [[0.05404907],\n", + " [0.04661769],\n", + " [0.03625842],\n", + " ...,\n", + " [0.04258636],\n", + " [0.05275417],\n", + " [0.05072172]],\n", + "\n", + " ...,\n", + "\n", + " [[0.24306524],\n", + " [0.2087981 ],\n", + " [0.19237486],\n", + " ...,\n", + " [0.49794546],\n", + " [0.4847785 ],\n", + " [0.4625703 ]],\n", + "\n", + " [[0.2348702 ],\n", + " [0.19395272],\n", + " [0.16197062],\n", + " ...,\n", + " [0.48910564],\n", + " [0.44795933],\n", + " [0.43600747]],\n", + "\n", + " [[0.22424304],\n", + " [0.19533421],\n", + " [0.1724976 ],\n", + " ...,\n", + " [0.47548756],\n", + " [0.44594884],\n", + " [0.42253518]]],\n", + "\n", + "\n", + " [[[0.03412669],\n", + " [0.02684389],\n", + " [0.0306042 ],\n", + " ...,\n", + " [0.0429263 ],\n", + " [0.03350811],\n", + " [0.02986459]],\n", + "\n", + " [[0.03788538],\n", + " [0.03244679],\n", + " [0.02897874],\n", + " ...,\n", + " [0.04118418],\n", + " [0.03908114],\n", + " [0.03557667]],\n", + "\n", + " [[0.03090672],\n", + " [0.02605662],\n", + " [0.03159174],\n", + " ...,\n", + " [0.0460731 ],\n", + " [0.03702852],\n", + " [0.03483194]],\n", + "\n", + " ...,\n", + "\n", + " [[0.14730741],\n", + " [0.11710234],\n", + " [0.0931544 ],\n", + " ...,\n", + " [0.32881948],\n", + " [0.26959002],\n", + " [0.2002877 ]],\n", + "\n", + " [[0.15213549],\n", + " [0.12177654],\n", + " [0.10143584],\n", + " ...,\n", + " [0.3292755 ],\n", + " [0.2774681 ],\n", + " [0.21291104]],\n", + "\n", + " [[0.16264902],\n", + " [0.12794547],\n", + " [0.11394203],\n", + " ...,\n", + " [0.34053007],\n", + " [0.27197832],\n", + " [0.2307058 ]]],\n", + "\n", + "\n", + " [[[0.02904119],\n", + " [0.02146851],\n", + " [0.02850347],\n", + " ...,\n", + " [0.02455656],\n", + " [0.02253807],\n", + " [0.02753014]],\n", + "\n", + " [[0.02338306],\n", + " [0.03034704],\n", + " [0.03378514],\n", + " ...,\n", + " [0.03013202],\n", + " [0.02470984],\n", + " [0.02069771]],\n", + "\n", + " [[0.02743151],\n", + " [0.02638279],\n", + " [0.02410043],\n", + " ...,\n", + " [0.02081456],\n", + " [0.03100825],\n", + " [0.02139291]],\n", + "\n", + " ...,\n", + "\n", + " [[0.04442505],\n", + " [0.02841762],\n", + " [0.02658463],\n", + " ...,\n", + " [0.16010144],\n", + " [0.10274442],\n", + " [0.0616471 ]],\n", + "\n", + " [[0.04835858],\n", + " [0.02837163],\n", + " [0.02553648],\n", + " ...,\n", + " [0.17505771],\n", + " [0.1175088 ],\n", + " [0.07346221]],\n", + "\n", + " [[0.05193048],\n", + " [0.03230145],\n", + " [0.02510335],\n", + " ...,\n", + " [0.1801968 ],\n", + " [0.13308878],\n", + " [0.0920953 ]]]], dtype=float32), 'image': array([[[[-3.38549551e-04],\n", + " [ 2.21106084e-03],\n", + " [ 5.83430170e-04],\n", + " ...,\n", + " [ 7.85706157e-04],\n", + " [ 1.03852700e-03],\n", + " [ 3.46902432e-03]],\n", + "\n", + " [[ 6.48989226e-05],\n", + " [ 1.67032587e-03],\n", + " [ 3.99194937e-03],\n", + " ...,\n", + " [ 5.63127501e-03],\n", + " [ 4.91873873e-03],\n", + " [ 6.53546769e-03]],\n", + "\n", + " [[-7.41710130e-04],\n", + " [ 2.52568140e-03],\n", + " [ 4.06506332e-03],\n", + " ...,\n", + " [ 6.20659487e-03],\n", + " [ 6.28155470e-03],\n", + " [ 5.63799683e-03]],\n", + "\n", + " ...,\n", + "\n", + " [[ 2.28623758e-04],\n", + " [ 2.76093930e-03],\n", + " [ 4.87792864e-03],\n", + " ...,\n", + " [ 5.09494916e-03],\n", + " [ 4.04698867e-03],\n", + " [ 2.72683031e-03]],\n", + "\n", + " [[-2.07442953e-03],\n", + " [ 2.84988247e-03],\n", + " [ 6.06768951e-03],\n", + " ...,\n", + " [ 2.82608904e-03],\n", + " [ 2.44792691e-03],\n", + " [ 1.24655652e-03]],\n", + "\n", + " [[-1.19447918e-03],\n", + " [ 1.02708151e-03],\n", + " [ 1.85332191e-03],\n", + " ...,\n", + " [ 1.38357421e-03],\n", + " [ 1.16201059e-03],\n", + " [ 2.81520624e-04]]],\n", + "\n", + "\n", + " [[[-5.14669693e-04],\n", + " [ 1.37324352e-03],\n", + " [ 3.52379633e-04],\n", + " ...,\n", + " [ 1.15602335e-03],\n", + " [ 1.22728862e-03],\n", + " [ 3.44831985e-03]],\n", + "\n", + " [[-2.37899192e-04],\n", + " [ 1.10615313e-03],\n", + " [ 4.48248489e-03],\n", + " ...,\n", + " [ 5.94434096e-03],\n", + " [ 4.70998138e-03],\n", + " [ 6.24679448e-03]],\n", + "\n", + " [[-4.35464375e-04],\n", + " [ 3.57073732e-03],\n", + " [ 3.90599947e-03],\n", + " ...,\n", + " [ 6.34744763e-03],\n", + " [ 6.92723691e-03],\n", + " [ 5.55104762e-03]],\n", + "\n", + " ...,\n", + "\n", + " [[ 5.70144039e-08],\n", + " [ 4.35262127e-03],\n", + " [ 5.25257131e-03],\n", + " ...,\n", + " [ 4.10042843e-03],\n", + " [ 5.26497187e-03],\n", + " [ 4.19373857e-03]],\n", + "\n", + " [[-1.27210387e-03],\n", + " [ 2.99596856e-03],\n", + " [ 5.72594348e-03],\n", + " ...,\n", + " [ 3.68183502e-03],\n", + " [ 3.28776706e-03],\n", + " [ 1.73376652e-03]],\n", + "\n", + " [[-1.03184069e-03],\n", + " [ 7.60412659e-04],\n", + " [ 1.24529167e-03],\n", + " ...,\n", + " [ 2.72015785e-03],\n", + " [ 2.30470207e-03],\n", + " [ 8.89259740e-04]]],\n", + "\n", + "\n", + " [[[ 1.55373156e-04],\n", + " [ 4.81109601e-04],\n", + " [ 1.85257755e-04],\n", + " ...,\n", + " [ 1.26952899e-03],\n", + " [ 1.40429032e-03],\n", + " [ 4.56278073e-03]],\n", + "\n", + " [[-7.22437515e-04],\n", + " [ 3.06245242e-03],\n", + " [ 5.95690869e-03],\n", + " ...,\n", + " [ 6.87512103e-03],\n", + " [ 6.76461123e-03],\n", + " [ 8.12639296e-03]],\n", + "\n", + " [[-2.46766576e-04],\n", + " [ 4.63837665e-03],\n", + " [ 5.08277677e-03],\n", + " ...,\n", + " [ 9.01930127e-03],\n", + " [ 8.38638656e-03],\n", + " [ 7.57896714e-03]],\n", + "\n", + " ...,\n", + "\n", + " [[ 8.14685540e-04],\n", + " [ 5.08743338e-03],\n", + " [ 5.30617544e-03],\n", + " ...,\n", + " [ 5.94491884e-03],\n", + " [ 4.58824029e-03],\n", + " [ 2.94837053e-03]],\n", + "\n", + " [[-2.54582893e-03],\n", + " [ 1.47350598e-03],\n", + " [ 6.89271837e-03],\n", + " ...,\n", + " [ 3.33093666e-03],\n", + " [ 2.15895753e-03],\n", + " [ 1.13573275e-03]],\n", + "\n", + " [[-9.71535163e-04],\n", + " [ 1.16463890e-03],\n", + " [ 1.50238699e-03],\n", + " ...,\n", + " [ 1.35849416e-03],\n", + " [ 1.75130519e-03],\n", + " [ 2.53740873e-04]]],\n", + "\n", + "\n", + " ...,\n", + "\n", + "\n", + " [[[-1.84552767e-03],\n", + " [ 2.26642517e-03],\n", + " [ 2.50199903e-03],\n", + " ...,\n", + " [ 1.62133342e-03],\n", + " [ 1.19561981e-03],\n", + " [ 4.49999282e-03]],\n", + "\n", + " [[ 5.29747864e-04],\n", + " [ 4.20005992e-03],\n", + " [ 6.04131026e-03],\n", + " ...,\n", + " [ 7.59269716e-03],\n", + " [ 6.72274083e-03],\n", + " [ 8.30146018e-03]],\n", + "\n", + " [[-6.98419695e-04],\n", + " [ 3.98751348e-03],\n", + " [ 5.67378383e-03],\n", + " ...,\n", + " [ 8.86038132e-03],\n", + " [ 9.46310908e-03],\n", + " [ 8.02807696e-03]],\n", + "\n", + " ...,\n", + "\n", + " [[-3.83506250e-03],\n", + " [ 2.88172178e-02],\n", + " [ 3.00614834e-02],\n", + " ...,\n", + " [ 6.64538145e-02],\n", + " [ 5.73254153e-02],\n", + " [ 3.55331041e-02]],\n", + "\n", + " [[-3.53273423e-03],\n", + " [ 1.88302714e-02],\n", + " [ 2.77014151e-02],\n", + " ...,\n", + " [ 4.61639501e-02],\n", + " [ 3.17977704e-02],\n", + " [ 1.39020365e-02]],\n", + "\n", + " [[-9.01793875e-03],\n", + " [ 5.76036330e-03],\n", + " [ 1.20072532e-02],\n", + " ...,\n", + " [ 2.51763277e-02],\n", + " [ 1.53386658e-02],\n", + " [ 3.13971471e-03]]],\n", + "\n", + "\n", + " [[[-4.17507748e-04],\n", + " [ 7.67845311e-04],\n", + " [ 4.06648323e-04],\n", + " ...,\n", + " [ 1.55756494e-03],\n", + " [ 1.93347712e-03],\n", + " [ 4.37485427e-03]],\n", + "\n", + " [[-6.64999679e-05],\n", + " [ 2.30852608e-03],\n", + " [ 4.01693489e-03],\n", + " ...,\n", + " [ 6.86086109e-03],\n", + " [ 7.29326252e-03],\n", + " [ 6.82889065e-03]],\n", + "\n", + " [[-2.48779106e-05],\n", + " [ 2.07340484e-03],\n", + " [ 4.06476948e-03],\n", + " ...,\n", + " [ 8.07710458e-03],\n", + " [ 8.56564939e-03],\n", + " [ 5.76988002e-03]],\n", + "\n", + " ...,\n", + "\n", + " [[-5.35211060e-04],\n", + " [ 1.56849381e-02],\n", + " [ 1.62470769e-02],\n", + " ...,\n", + " [ 5.22287413e-02],\n", + " [ 3.22894752e-02],\n", + " [ 1.47336591e-02]],\n", + "\n", + " [[-2.04390544e-03],\n", + " [ 1.15066739e-02],\n", + " [ 1.54454783e-02],\n", + " ...,\n", + " [ 3.42928916e-02],\n", + " [ 2.12032460e-02],\n", + " [ 2.07589101e-03]],\n", + "\n", + " [[-4.86424379e-03],\n", + " [ 4.26311605e-03],\n", + " [ 7.18892412e-03],\n", + " ...,\n", + " [ 1.62898749e-02],\n", + " [ 8.77049472e-03],\n", + " [-1.83343887e-03]]],\n", + "\n", + "\n", + " [[[-2.73332698e-04],\n", + " [ 3.11197218e-04],\n", + " [ 3.43630556e-04],\n", + " ...,\n", + " [ 7.62445386e-04],\n", + " [ 1.07039860e-03],\n", + " [ 2.91697634e-03]],\n", + "\n", + " [[-5.72583813e-05],\n", + " [ 1.93260156e-03],\n", + " [ 3.22319777e-03],\n", + " ...,\n", + " [ 4.22241259e-03],\n", + " [ 4.19293763e-03],\n", + " [ 4.79434943e-03]],\n", + "\n", + " [[ 6.25447137e-04],\n", + " [ 2.84694950e-03],\n", + " [ 3.78600298e-03],\n", + " ...,\n", + " [ 4.36908705e-03],\n", + " [ 5.21399919e-03],\n", + " [ 4.24094731e-03]],\n", + "\n", + " ...,\n", + "\n", + " [[ 3.30056180e-04],\n", + " [ 4.74191178e-03],\n", + " [ 4.27093031e-03],\n", + " ...,\n", + " [ 2.69412324e-02],\n", + " [ 1.27332192e-02],\n", + " [ 3.45749641e-03]],\n", + "\n", + " [[-8.45994335e-04],\n", + " [ 1.89564051e-03],\n", + " [ 4.12365142e-03],\n", + " ...,\n", + " [ 1.79680120e-02],\n", + " [ 5.90574741e-03],\n", + " [-3.65133304e-03]],\n", + "\n", + " [[-1.68516184e-03],\n", + " [ 6.12936215e-04],\n", + " [ 1.87073369e-03],\n", + " ...,\n", + " [ 3.79876629e-03],\n", + " [-1.14162010e-03],\n", + " [-3.92165594e-03]]]], dtype=float32)}\n" ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ - "model.fit(ds_train, epochs=10, validation_data=ds_val)" + "print(preds)" ] }, { "cell_type": "code", - "execution_count": 114, + "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "30/30 [==============================] - 0s 8ms/step\n", - "(30, 320, 320, 1)\n" + "30/30 [==============================] - 12s 212ms/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2022-08-04 09:17:25.761455: W tensorflow/core/kernels/data/cache_dataset_ops.cc:856] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.\n" ] } ], "source": [ - "result = model.predict(ds_train.take(30))\n", - "print(result['zfill'].shape)" + "preds = model.predict(ds_train.take(30))" ] }, { "cell_type": "code", - "execution_count": 116, + "execution_count": 49, "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "" - ] - }, - "execution_count": 116, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -487,40 +1064,41 @@ } ], "source": [ - "plt.imshow(result['image'][8, ...])" + "show_examples(preds['image'], lambda x: np.abs(x), n=16)" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 53, "metadata": {}, "outputs": [ { "ename": "AttributeError", - "evalue": "module 'tensorflow_mri._api.layers' has no attribute 'LeastSquaresGradientDescent'", + "evalue": "module 'tensorflow_mri._api.activations' has no attribute 'complex_relu'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/workspaces/tensorflow-mri/tools/docs/tutorials/recon/unet_fastmri.ipynb Cell 19\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 18\u001b[0m outputs \u001b[39m=\u001b[39m {\u001b[39m'\u001b[39m\u001b[39mzfill\u001b[39m\u001b[39m'\u001b[39m: zfill, \u001b[39m'\u001b[39m\u001b[39mimage\u001b[39m\u001b[39m'\u001b[39m: x}\n\u001b[1;32m 19\u001b[0m \u001b[39mreturn\u001b[39;00m tf\u001b[39m.\u001b[39mkeras\u001b[39m.\u001b[39mModel(inputs\u001b[39m=\u001b[39minputs, outputs\u001b[39m=\u001b[39moutputs)\n\u001b[0;32m---> 22\u001b[0m model \u001b[39m=\u001b[39m VarNet(inputs)\n\u001b[1;32m 24\u001b[0m model\u001b[39m.\u001b[39mcompile(optimizer\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39madam\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 25\u001b[0m loss\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mmse\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 26\u001b[0m metrics\u001b[39m=\u001b[39m[tfmri\u001b[39m.\u001b[39mmetrics\u001b[39m.\u001b[39mPSNR(), tfmri\u001b[39m.\u001b[39mmetrics\u001b[39m.\u001b[39mSSIM()])\n\u001b[1;32m 28\u001b[0m model\u001b[39m.\u001b[39msummary()\n", - "\u001b[1;32m/workspaces/tensorflow-mri/tools/docs/tutorials/recon/unet_fastmri.ipynb Cell 19\u001b[0m in \u001b[0;36mVarNet\u001b[0;34m(inputs, num_iterations)\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mVarNet\u001b[39m(inputs, num_iterations\u001b[39m=\u001b[39m\u001b[39m5\u001b[39m):\n\u001b[1;32m 2\u001b[0m zfill \u001b[39m=\u001b[39m AdjointRecon(name\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mzfill\u001b[39m\u001b[39m'\u001b[39m)(inputs)\n\u001b[0;32m----> 4\u001b[0m lsgd \u001b[39m=\u001b[39m tfmri\u001b[39m.\u001b[39;49mlayers\u001b[39m.\u001b[39;49mLeastSquaresGradientDescent(\n\u001b[1;32m 5\u001b[0m operator\u001b[39m=\u001b[39mtfmri\u001b[39m.\u001b[39mlinalg\u001b[39m.\u001b[39mLinearOperatorMRI)\n\u001b[1;32m 7\u001b[0m denoise \u001b[39m=\u001b[39m tfmri\u001b[39m.\u001b[39mmodels\u001b[39m.\u001b[39mUNet2D(\n\u001b[1;32m 8\u001b[0m filters\u001b[39m=\u001b[39m[\u001b[39m32\u001b[39m, \u001b[39m64\u001b[39m, \u001b[39m128\u001b[39m],\n\u001b[1;32m 9\u001b[0m kernel_size\u001b[39m=\u001b[39m\u001b[39m3\u001b[39m,\n\u001b[1;32m 10\u001b[0m out_channels\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m,\n\u001b[1;32m 11\u001b[0m name\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mprior\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m 13\u001b[0m x \u001b[39m=\u001b[39m zfill\n", - "\u001b[0;31mAttributeError\u001b[0m: module 'tensorflow_mri._api.layers' has no attribute 'LeastSquaresGradientDescent'" + "\u001b[1;32m/workspaces/tensorflow-mri/tools/docs/tutorials/recon/unet_fastmri.ipynb Cell 20\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 19\u001b[0m outputs \u001b[39m=\u001b[39m {\u001b[39m'\u001b[39m\u001b[39mzfill\u001b[39m\u001b[39m'\u001b[39m: zfill, \u001b[39m'\u001b[39m\u001b[39mimage\u001b[39m\u001b[39m'\u001b[39m: x}\n\u001b[1;32m 20\u001b[0m \u001b[39mreturn\u001b[39;00m tf\u001b[39m.\u001b[39mkeras\u001b[39m.\u001b[39mModel(inputs\u001b[39m=\u001b[39minputs, outputs\u001b[39m=\u001b[39moutputs)\n\u001b[0;32m---> 22\u001b[0m model \u001b[39m=\u001b[39m VarNet(inputs)\n\u001b[1;32m 24\u001b[0m model\u001b[39m.\u001b[39mcompile(optimizer\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39madam\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 25\u001b[0m loss\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mmse\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 26\u001b[0m metrics\u001b[39m=\u001b[39m[tfmri\u001b[39m.\u001b[39mmetrics\u001b[39m.\u001b[39mPSNR(), tfmri\u001b[39m.\u001b[39mmetrics\u001b[39m.\u001b[39mSSIM()])\n\u001b[1;32m 28\u001b[0m model\u001b[39m.\u001b[39msummary()\n", + "\u001b[1;32m/workspaces/tensorflow-mri/tools/docs/tutorials/recon/unet_fastmri.ipynb Cell 20\u001b[0m in \u001b[0;36mVarNet\u001b[0;34m(inputs, num_iterations)\u001b[0m\n\u001b[1;32m 2\u001b[0m adj \u001b[39m=\u001b[39m AdjointRecon(name\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mzfill\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m 3\u001b[0m lsgd \u001b[39m=\u001b[39m tfmri\u001b[39m.\u001b[39mlayers\u001b[39m.\u001b[39mLeastSquaresGradientDescent(\n\u001b[1;32m 4\u001b[0m operator\u001b[39m=\u001b[39mtfmri\u001b[39m.\u001b[39mlinalg\u001b[39m.\u001b[39mLinearOperatorMRI)\n\u001b[1;32m 5\u001b[0m denoise \u001b[39m=\u001b[39m tfmri\u001b[39m.\u001b[39mmodels\u001b[39m.\u001b[39mUNet2D(\n\u001b[1;32m 6\u001b[0m filters\u001b[39m=\u001b[39m[\u001b[39m32\u001b[39m, \u001b[39m64\u001b[39m, \u001b[39m128\u001b[39m],\n\u001b[1;32m 7\u001b[0m kernel_size\u001b[39m=\u001b[39m\u001b[39m3\u001b[39m,\n\u001b[0;32m----> 8\u001b[0m activation\u001b[39m=\u001b[39mtfmri\u001b[39m.\u001b[39;49mactivations\u001b[39m.\u001b[39;49mcomplex_relu,\n\u001b[1;32m 9\u001b[0m out_channels\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m,\n\u001b[1;32m 10\u001b[0m dtype\u001b[39m=\u001b[39mtf\u001b[39m.\u001b[39mcomplex64,\n\u001b[1;32m 11\u001b[0m name\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mprior\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m 13\u001b[0m zfill \u001b[39m=\u001b[39m adj(inputs)\n\u001b[1;32m 14\u001b[0m x \u001b[39m=\u001b[39m zfill\n", + "\u001b[0;31mAttributeError\u001b[0m: module 'tensorflow_mri._api.activations' has no attribute 'complex_relu'" ] } ], "source": [ "def VarNet(inputs, num_iterations=5):\n", - " zfill = AdjointRecon(name='zfill')(inputs)\n", - "\n", + " adj = AdjointRecon(name='zfill')\n", " lsgd = tfmri.layers.LeastSquaresGradientDescent(\n", " operator=tfmri.linalg.LinearOperatorMRI)\n", - "\n", " denoise = tfmri.models.UNet2D(\n", " filters=[32, 64, 128],\n", " kernel_size=3,\n", + " activation=tfmri.activations.complex_relu,\n", " out_channels=1,\n", + " dtype=tf.complex64,\n", " name='prior')\n", "\n", + " zfill = adj(inputs)\n", " x = zfill\n", " for i in range(num_iterations):\n", " x = denoise(x)\n", From 10ea9733482160d0af0042145f3689d8b3ca4791 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 4 Aug 2022 15:52:59 +0000 Subject: [PATCH 011/101] Working on fastMRI --- .vscode/settings.json | 3 +- tensorflow_mri/_api/activations/__init__.py | 4 +- .../python/activations/complex_activations.py | 8 +- .../python/layers/data_consistency.py | 11 +- tools/docs/tutorials/recon/unet_fastmri.ipynb | 862 ++++-------------- 5 files changed, 205 insertions(+), 683 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 3d253868..8f1c2d83 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -9,5 +9,6 @@ "python.testing.pytestEnabled": false, "python.testing.unittestEnabled": true, "python.linting.pylintEnabled": true, - "python.linting.enabled": true + "python.linting.enabled": true, + "notebook.output.textLineLimit": 500 } \ No newline at end of file diff --git a/tensorflow_mri/_api/activations/__init__.py b/tensorflow_mri/_api/activations/__init__.py index cfee3523..12abb9e8 100644 --- a/tensorflow_mri/_api/activations/__init__.py +++ b/tensorflow_mri/_api/activations/__init__.py @@ -2,5 +2,5 @@ # Do not edit. """Activation functions.""" -from tensorflow_mri.python.activations.complex_activations import wrapper as complex_relu -from tensorflow_mri.python.activations.complex_activations import wrapper as mod_relu +from tensorflow_mri.python.activations.complex_activations import complex_relu as complex_relu +from tensorflow_mri.python.activations.complex_activations import mod_relu as mod_relu diff --git a/tensorflow_mri/python/activations/complex_activations.py b/tensorflow_mri/python/activations/complex_activations.py index df7804be..0169b314 100644 --- a/tensorflow_mri/python/activations/complex_activations.py +++ b/tensorflow_mri/python/activations/complex_activations.py @@ -19,7 +19,7 @@ from tensorflow_mri.python.util import api_util -def complexified(split='real_imag'): +def complexified(name, split='real_imag'): """Returns a decorator to create complex-valued activations.""" if split not in ('real_imag', 'abs_angle'): raise ValueError( @@ -35,14 +35,14 @@ def wrapper(x, *args, **kwargs): return tf.dtypes.complex(func(tf.math.real(x), *args, **kwargs), func(tf.math.imag(x), *args, **kwargs)) return func(x, *args, **kwargs) - + wrapper.__name__ = name return wrapper return decorator complex_relu = api_util.export("activations.complex_relu")( - complexified(split='real_imag')(tf.keras.activations.relu)) + complexified(name='complex_relu', split='real_imag')(tf.keras.activations.relu)) complex_relu.__doc__ = ( """Applies the rectified linear unit activation function. @@ -81,7 +81,7 @@ def wrapper(x, *args, **kwargs): mod_relu = api_util.export("activations.mod_relu")( - complexified(split='abs_angle')(tf.keras.activations.relu)) + complexified(name='mod_relu', split='abs_angle')(tf.keras.activations.relu)) mod_relu.__doc__ = ( """Applies the rectified linear unit activation function. diff --git a/tensorflow_mri/python/layers/data_consistency.py b/tensorflow_mri/python/layers/data_consistency.py index 5b84c3d1..834a422d 100644 --- a/tensorflow_mri/python/layers/data_consistency.py +++ b/tensorflow_mri/python/layers/data_consistency.py @@ -29,6 +29,7 @@ class LeastSquaresGradientDescent(tf.keras.layers.Layer): def __init__(self, operator, scale_initializer=1.0, + handle_channel_axis=True, dtype=None, **kwargs): if isinstance(operator, linear_operator.LinearOperator): @@ -61,6 +62,8 @@ def __init__(self, else: dtype = self.operator.dtype + self.handle_channel_axis = handle_channel_axis + super().__init__(dtype=dtype, **kwargs) def build(self, input_shape): @@ -85,8 +88,14 @@ def call(self, inputs): f"unexpected arguments in call when linear operator is a class " f"instance: {args}, {kwargs}") operator = self.operator - return x - tf.cast(self.scale, self.dtype) * operator.transform( + if self.handle_channel_axis: + x = tf.squeeze(x, axis=-1) + print(x.shape, operator.domain_shape, operator.range_shape) + x -= tf.cast(self.scale, self.dtype) * operator.transform( operator.transform(x) - b, adjoint=True) + if self.handle_channel_axis: + x = tf.expand_dims(x, axis=-1) + return x def _parse_inputs(self, inputs): """Parses the inputs to the call method.""" diff --git a/tools/docs/tutorials/recon/unet_fastmri.ipynb b/tools/docs/tutorials/recon/unet_fastmri.ipynb index ff3756de..43b8e3b6 100644 --- a/tools/docs/tutorials/recon/unet_fastmri.ipynb +++ b/tools/docs/tutorials/recon/unet_fastmri.ipynb @@ -9,9 +9,17 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2022-08-04 10:26:12.163495: I tensorflow/core/util/util.cc:169] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n" + ] + } + ], "source": [ "import functools\n", "import itertools\n", @@ -26,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -36,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -50,7 +58,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -61,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -120,9 +128,21 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2022-08-04 10:26:24.364863: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 AVX512F AVX512_VNNI FMA\n", + "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2022-08-04 10:26:25.275846: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1532] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 22290 MB memory: -> device: 0, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:65:00.0, compute capability: 8.6\n", + "2022-08-04 10:26:25.276331: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1532] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 22304 MB memory: -> device: 1, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:b3:00.0, compute capability: 8.6\n", + "2022-08-04 10:26:25.554843: I tensorflow_io/core/kernels/cpu_check.cc:128] Your CPU supports instructions that this TensorFlow IO binary was not compiled to use: AVX2 AVX512F FMA\n" + ] + } + ], "source": [ "ds_train = initialize_fastmri_dataset(files_train)\n", "ds_val = initialize_fastmri_dataset(files_val)\n", @@ -131,7 +151,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -141,7 +161,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -178,7 +198,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -220,16 +240,16 @@ " sensitivities = tfmri.coils.estimate_sensitivities(filt_image, coil_axis=-3)\n", " return sensitivities\n", "\n", - "def scale_kspace(kspace):\n", + "def scale_kspace(kspace, operator):\n", " filt_kspace = filter_kspace_lowpass(kspace)\n", - " filt_image = reconstruct_zerofilled(filt_kspace)\n", + " filt_image = operator.transform(filt_kspace)\n", " scale = tf.math.reduce_max(tf.math.abs(filt_image))\n", " return kspace / tf.cast(scale, kspace.dtype)" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -267,7 +287,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -288,7 +308,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -312,29 +332,116 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ - "class AdjointRecon(tf.keras.layers.Layer):\n", - " def __init__(self, magnitude_only=False, **kwargs):\n", + "def filter_kspace_lowpass(kspace):\n", + " def box(freq):\n", + " cutoff = fully_sampled_region * np.pi\n", + " result = tf.where(tf.math.abs(freq) < cutoff, 1, 0)\n", + " return result\n", + " return tfmri.signal.filter_kspace(kspace, filter_fn=box, filter_rank=1)\n", + "\n", + "def scale_kspace(kspace, operator):\n", + " filt_kspace = filter_kspace_lowpass(kspace)\n", + " filt_image = operator.transform(filt_kspace, adjoint=True)\n", + " scale = tf.math.reduce_max(tf.math.abs(filt_image))\n", + " return kspace / tf.cast(scale, kspace.dtype)\n", + "\n", + "\n", + "\n", + "class LinearOperatorLayer(tf.keras.layers.Layer):\n", + " def __init__(self, operator, input_names, **kwargs):\n", " super().__init__(**kwargs)\n", - " self.magnitude_only = magnitude_only\n", - " \n", + " self.operator = operator\n", + " self.input_names = input_names\n", + "\n", + " def parse_inputs(self, inputs):\n", + " main = {k: inputs[k] for k in self.input_names}\n", + " args = ()\n", + " kwargs = {k: v for k, v in inputs.items() if k not in self.input_names}\n", + " return main, args, kwargs\n", + "\n", + " def get_operator(self, inputs):\n", + " main, args, kwargs = self.parse_inputs(inputs)\n", + " return self.operator(*args, **kwargs)\n", + "\n", + "\n", + "class KSpaceScaling(LinearOperatorLayer):\n", + " def __init__(self,\n", + " operator=tfmri.linalg.LinearOperatorMRI,\n", + " kspace_index='kspace',\n", + " passthrough=False,\n", + " **kwargs):\n", + " super().__init__(operator=operator, input_names=(kspace_index,), **kwargs)\n", + " self.operator = operator\n", + " self.kspace_index = kspace_index\n", + " self.passthrough = passthrough\n", + "\n", " def call(self, inputs):\n", - " # Scale k-space signal.\n", - " kspace = scale_kspace(inputs['kspace'])\n", - " # Reconstruct image.\n", - " image = reconstruct_zerofilled(kspace, mask=inputs['mask'])\n", - " image = tf.expand_dims(image, -1)\n", - " if self.magnitude_only:\n", - " image = tf.math.abs(image)\n", + " main, args, kwargs = self.parse_inputs(inputs)\n", + " operator = self.get_operator(inputs)\n", + " kspace = scale_kspace(main[self.kspace_index], operator)\n", + " if self.passthrough:\n", + " return {self.kspace_index: kspace, **kwargs}\n", + " return kspace\n", + "\n", + "\n", + "class CoilSensitivities(LinearOperatorLayer):\n", + " def __init__(self,\n", + " operator=tfmri.linalg.LinearOperatorMRI,\n", + " kspace_index='kspace',\n", + " sensitivities_index='sensitivities',\n", + " passthrough=False,\n", + " **kwargs):\n", + " super().__init__(operator=operator, input_names=(kspace_index,), **kwargs)\n", + " self.kspace_index = kspace_index\n", + " self.sensitivities_index = sensitivities_index\n", + " self.passthrough = passthrough\n", + "\n", + " def call(self, inputs):\n", + " main, args, kwargs = self.parse_inputs(inputs)\n", + " # TODO: unused operator.\n", + " sensitivities = self.compute_sensitivities(\n", + " main[self.kspace_index], *args, **kwargs)\n", + " if self.passthrough:\n", + " return {self.kspace_index: main[self.kspace_index], **kwargs,\n", + " self.sensitivities_index: sensitivities}\n", + " return sensitivities\n", + "\n", + " def compute_sensitivities(self, kspace, *args, **kwargs):\n", + " filt_kspace = filter_kspace_lowpass(kspace)\n", + " filt_image = tfmri.recon.adjoint(filt_kspace, *args, **kwargs)\n", + " sensitivities = tfmri.coils.estimate_sensitivities(filt_image, coil_axis=-3)\n", + " return sensitivities\n", + "\n", + "\n", + "class ReconAdjoint(LinearOperatorLayer):\n", + " def __init__(self,\n", + " kspace_index='kspace',\n", + " image_index='image',\n", + " passthrough=False,\n", + " **kwargs):\n", + " super().__init__(operator=tfmri.linalg.LinearOperatorMRI,\n", + " input_names=(kspace_index,),\n", + " **kwargs)\n", + " self.kspace_index = kspace_index\n", + " self.image_index = image_index\n", + " self.passthrough = passthrough\n", + "\n", + " def call(self, inputs):\n", + " main, args, kwargs = self.parse_inputs(inputs)\n", + " image = tfmri.recon.adjoint(main[self.kspace_index], *args, **kwargs)\n", + " if self.passthrough:\n", + " return {self.kspace_index: main[self.kspace_index], **kwargs,\n", + " self.image_index: image}\n", " return image" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -385,7 +492,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -394,650 +501,28 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 16, "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "{'zfill': array([[[[0.03730954],\n", - " [0.04248981],\n", - " [0.03511715],\n", - " ...,\n", - " [0.03627022],\n", - " [0.03310308],\n", - " [0.04002528]],\n", - "\n", - " [[0.04117708],\n", - " [0.02795216],\n", - " [0.03342503],\n", - " ...,\n", - " [0.03422057],\n", - " [0.0305617 ],\n", - " [0.03323219]],\n", - "\n", - " [[0.03162055],\n", - " [0.03424564],\n", - " [0.04071327],\n", - " ...,\n", - " [0.03863482],\n", - " [0.03950511],\n", - " [0.04508803]],\n", - "\n", - " ...,\n", - "\n", - " [[0.03643849],\n", - " [0.03413566],\n", - " [0.03994865],\n", - " ...,\n", - " [0.04486349],\n", - " [0.04716439],\n", - " [0.05293337]],\n", - "\n", - " [[0.04042355],\n", - " [0.04095628],\n", - " [0.05113396],\n", - " ...,\n", - " [0.03842064],\n", - " [0.05322709],\n", - " [0.04076931]],\n", - "\n", - " [[0.05052018],\n", - " [0.04702099],\n", - " [0.04676762],\n", - " ...,\n", - " [0.03381801],\n", - " [0.04896087],\n", - " [0.03535406]]],\n", - "\n", - "\n", - " [[[0.03114065],\n", - " [0.04702193],\n", - " [0.03025192],\n", - " ...,\n", - " [0.02723994],\n", - " [0.02741306],\n", - " [0.03783687]],\n", - "\n", - " [[0.03372868],\n", - " [0.03541645],\n", - " [0.03232943],\n", - " ...,\n", - " [0.04178388],\n", - " [0.03118657],\n", - " [0.03604896]],\n", - "\n", - " [[0.02559258],\n", - " [0.03752475],\n", - " [0.04094908],\n", - " ...,\n", - " [0.03027781],\n", - " [0.04414068],\n", - " [0.04159149]],\n", - "\n", - " ...,\n", - "\n", - " [[0.03962037],\n", - " [0.04539109],\n", - " [0.04313568],\n", - " ...,\n", - " [0.03776349],\n", - " [0.04792673],\n", - " [0.04799293]],\n", - "\n", - " [[0.02798527],\n", - " [0.03403655],\n", - " [0.03891989],\n", - " ...,\n", - " [0.05696635],\n", - " [0.0438323 ],\n", - " [0.04689693]],\n", - "\n", - " [[0.03729939],\n", - " [0.04697356],\n", - " [0.03774005],\n", - " ...,\n", - " [0.04366778],\n", - " [0.04349282],\n", - " [0.0391708 ]]],\n", - "\n", - "\n", - " [[[0.03696218],\n", - " [0.03955268],\n", - " [0.03244933],\n", - " ...,\n", - " [0.04564377],\n", - " [0.04518688],\n", - " [0.04128893]],\n", - "\n", - " [[0.04216101],\n", - " [0.034663 ],\n", - " [0.04719481],\n", - " ...,\n", - " [0.05366581],\n", - " [0.04280291],\n", - " [0.04502771]],\n", - "\n", - " [[0.04425316],\n", - " [0.04977743],\n", - " [0.06375591],\n", - " ...,\n", - " [0.05387824],\n", - " [0.04947987],\n", - " [0.04541088]],\n", - "\n", - " ...,\n", - "\n", - " [[0.05660668],\n", - " [0.04080752],\n", - " [0.04646816],\n", - " ...,\n", - " [0.0358771 ],\n", - " [0.04357762],\n", - " [0.0356135 ]],\n", - "\n", - " [[0.03870127],\n", - " [0.03450824],\n", - " [0.05299501],\n", - " ...,\n", - " [0.0410384 ],\n", - " [0.04126841],\n", - " [0.05327509]],\n", - "\n", - " [[0.04185225],\n", - " [0.05284803],\n", - " [0.05215264],\n", - " ...,\n", - " [0.03986993],\n", - " [0.04249096],\n", - " [0.03834104]]],\n", - "\n", - "\n", - " ...,\n", - "\n", - "\n", - " [[[0.06054531],\n", - " [0.07125156],\n", - " [0.05390326],\n", - " ...,\n", - " [0.05641456],\n", - " [0.04851629],\n", - " [0.05175951]],\n", - "\n", - " [[0.05432056],\n", - " [0.04388288],\n", - " [0.04020565],\n", - " ...,\n", - " [0.05326294],\n", - " [0.04760348],\n", - " [0.04637051]],\n", - "\n", - " [[0.05404907],\n", - " [0.04661769],\n", - " [0.03625842],\n", - " ...,\n", - " [0.04258636],\n", - " [0.05275417],\n", - " [0.05072172]],\n", - "\n", - " ...,\n", - "\n", - " [[0.24306524],\n", - " [0.2087981 ],\n", - " [0.19237486],\n", - " ...,\n", - " [0.49794546],\n", - " [0.4847785 ],\n", - " [0.4625703 ]],\n", - "\n", - " [[0.2348702 ],\n", - " [0.19395272],\n", - " [0.16197062],\n", - " ...,\n", - " [0.48910564],\n", - " [0.44795933],\n", - " [0.43600747]],\n", - "\n", - " [[0.22424304],\n", - " [0.19533421],\n", - " [0.1724976 ],\n", - " ...,\n", - " [0.47548756],\n", - " [0.44594884],\n", - " [0.42253518]]],\n", - "\n", - "\n", - " [[[0.03412669],\n", - " [0.02684389],\n", - " [0.0306042 ],\n", - " ...,\n", - " [0.0429263 ],\n", - " [0.03350811],\n", - " [0.02986459]],\n", - "\n", - " [[0.03788538],\n", - " [0.03244679],\n", - " [0.02897874],\n", - " ...,\n", - " [0.04118418],\n", - " [0.03908114],\n", - " [0.03557667]],\n", - "\n", - " [[0.03090672],\n", - " [0.02605662],\n", - " [0.03159174],\n", - " ...,\n", - " [0.0460731 ],\n", - " [0.03702852],\n", - " [0.03483194]],\n", - "\n", - " ...,\n", - "\n", - " [[0.14730741],\n", - " [0.11710234],\n", - " [0.0931544 ],\n", - " ...,\n", - " [0.32881948],\n", - " [0.26959002],\n", - " [0.2002877 ]],\n", - "\n", - " [[0.15213549],\n", - " [0.12177654],\n", - " [0.10143584],\n", - " ...,\n", - " [0.3292755 ],\n", - " [0.2774681 ],\n", - " [0.21291104]],\n", - "\n", - " [[0.16264902],\n", - " [0.12794547],\n", - " [0.11394203],\n", - " ...,\n", - " [0.34053007],\n", - " [0.27197832],\n", - " [0.2307058 ]]],\n", - "\n", - "\n", - " [[[0.02904119],\n", - " [0.02146851],\n", - " [0.02850347],\n", - " ...,\n", - " [0.02455656],\n", - " [0.02253807],\n", - " [0.02753014]],\n", - "\n", - " [[0.02338306],\n", - " [0.03034704],\n", - " [0.03378514],\n", - " ...,\n", - " [0.03013202],\n", - " [0.02470984],\n", - " [0.02069771]],\n", - "\n", - " [[0.02743151],\n", - " [0.02638279],\n", - " [0.02410043],\n", - " ...,\n", - " [0.02081456],\n", - " [0.03100825],\n", - " [0.02139291]],\n", - "\n", - " ...,\n", - "\n", - " [[0.04442505],\n", - " [0.02841762],\n", - " [0.02658463],\n", - " ...,\n", - " [0.16010144],\n", - " [0.10274442],\n", - " [0.0616471 ]],\n", - "\n", - " [[0.04835858],\n", - " [0.02837163],\n", - " [0.02553648],\n", - " ...,\n", - " [0.17505771],\n", - " [0.1175088 ],\n", - " [0.07346221]],\n", - "\n", - " [[0.05193048],\n", - " [0.03230145],\n", - " [0.02510335],\n", - " ...,\n", - " [0.1801968 ],\n", - " [0.13308878],\n", - " [0.0920953 ]]]], dtype=float32), 'image': array([[[[-3.38549551e-04],\n", - " [ 2.21106084e-03],\n", - " [ 5.83430170e-04],\n", - " ...,\n", - " [ 7.85706157e-04],\n", - " [ 1.03852700e-03],\n", - " [ 3.46902432e-03]],\n", - "\n", - " [[ 6.48989226e-05],\n", - " [ 1.67032587e-03],\n", - " [ 3.99194937e-03],\n", - " ...,\n", - " [ 5.63127501e-03],\n", - " [ 4.91873873e-03],\n", - " [ 6.53546769e-03]],\n", - "\n", - " [[-7.41710130e-04],\n", - " [ 2.52568140e-03],\n", - " [ 4.06506332e-03],\n", - " ...,\n", - " [ 6.20659487e-03],\n", - " [ 6.28155470e-03],\n", - " [ 5.63799683e-03]],\n", - "\n", - " ...,\n", - "\n", - " [[ 2.28623758e-04],\n", - " [ 2.76093930e-03],\n", - " [ 4.87792864e-03],\n", - " ...,\n", - " [ 5.09494916e-03],\n", - " [ 4.04698867e-03],\n", - " [ 2.72683031e-03]],\n", - "\n", - " [[-2.07442953e-03],\n", - " [ 2.84988247e-03],\n", - " [ 6.06768951e-03],\n", - " ...,\n", - " [ 2.82608904e-03],\n", - " [ 2.44792691e-03],\n", - " [ 1.24655652e-03]],\n", - "\n", - " [[-1.19447918e-03],\n", - " [ 1.02708151e-03],\n", - " [ 1.85332191e-03],\n", - " ...,\n", - " [ 1.38357421e-03],\n", - " [ 1.16201059e-03],\n", - " [ 2.81520624e-04]]],\n", - "\n", - "\n", - " [[[-5.14669693e-04],\n", - " [ 1.37324352e-03],\n", - " [ 3.52379633e-04],\n", - " ...,\n", - " [ 1.15602335e-03],\n", - " [ 1.22728862e-03],\n", - " [ 3.44831985e-03]],\n", - "\n", - " [[-2.37899192e-04],\n", - " [ 1.10615313e-03],\n", - " [ 4.48248489e-03],\n", - " ...,\n", - " [ 5.94434096e-03],\n", - " [ 4.70998138e-03],\n", - " [ 6.24679448e-03]],\n", - "\n", - " [[-4.35464375e-04],\n", - " [ 3.57073732e-03],\n", - " [ 3.90599947e-03],\n", - " ...,\n", - " [ 6.34744763e-03],\n", - " [ 6.92723691e-03],\n", - " [ 5.55104762e-03]],\n", - "\n", - " ...,\n", - "\n", - " [[ 5.70144039e-08],\n", - " [ 4.35262127e-03],\n", - " [ 5.25257131e-03],\n", - " ...,\n", - " [ 4.10042843e-03],\n", - " [ 5.26497187e-03],\n", - " [ 4.19373857e-03]],\n", - "\n", - " [[-1.27210387e-03],\n", - " [ 2.99596856e-03],\n", - " [ 5.72594348e-03],\n", - " ...,\n", - " [ 3.68183502e-03],\n", - " [ 3.28776706e-03],\n", - " [ 1.73376652e-03]],\n", - "\n", - " [[-1.03184069e-03],\n", - " [ 7.60412659e-04],\n", - " [ 1.24529167e-03],\n", - " ...,\n", - " [ 2.72015785e-03],\n", - " [ 2.30470207e-03],\n", - " [ 8.89259740e-04]]],\n", - "\n", - "\n", - " [[[ 1.55373156e-04],\n", - " [ 4.81109601e-04],\n", - " [ 1.85257755e-04],\n", - " ...,\n", - " [ 1.26952899e-03],\n", - " [ 1.40429032e-03],\n", - " [ 4.56278073e-03]],\n", - "\n", - " [[-7.22437515e-04],\n", - " [ 3.06245242e-03],\n", - " [ 5.95690869e-03],\n", - " ...,\n", - " [ 6.87512103e-03],\n", - " [ 6.76461123e-03],\n", - " [ 8.12639296e-03]],\n", - "\n", - " [[-2.46766576e-04],\n", - " [ 4.63837665e-03],\n", - " [ 5.08277677e-03],\n", - " ...,\n", - " [ 9.01930127e-03],\n", - " [ 8.38638656e-03],\n", - " [ 7.57896714e-03]],\n", - "\n", - " ...,\n", - "\n", - " [[ 8.14685540e-04],\n", - " [ 5.08743338e-03],\n", - " [ 5.30617544e-03],\n", - " ...,\n", - " [ 5.94491884e-03],\n", - " [ 4.58824029e-03],\n", - " [ 2.94837053e-03]],\n", - "\n", - " [[-2.54582893e-03],\n", - " [ 1.47350598e-03],\n", - " [ 6.89271837e-03],\n", - " ...,\n", - " [ 3.33093666e-03],\n", - " [ 2.15895753e-03],\n", - " [ 1.13573275e-03]],\n", - "\n", - " [[-9.71535163e-04],\n", - " [ 1.16463890e-03],\n", - " [ 1.50238699e-03],\n", - " ...,\n", - " [ 1.35849416e-03],\n", - " [ 1.75130519e-03],\n", - " [ 2.53740873e-04]]],\n", - "\n", - "\n", - " ...,\n", - "\n", - "\n", - " [[[-1.84552767e-03],\n", - " [ 2.26642517e-03],\n", - " [ 2.50199903e-03],\n", - " ...,\n", - " [ 1.62133342e-03],\n", - " [ 1.19561981e-03],\n", - " [ 4.49999282e-03]],\n", - "\n", - " [[ 5.29747864e-04],\n", - " [ 4.20005992e-03],\n", - " [ 6.04131026e-03],\n", - " ...,\n", - " [ 7.59269716e-03],\n", - " [ 6.72274083e-03],\n", - " [ 8.30146018e-03]],\n", - "\n", - " [[-6.98419695e-04],\n", - " [ 3.98751348e-03],\n", - " [ 5.67378383e-03],\n", - " ...,\n", - " [ 8.86038132e-03],\n", - " [ 9.46310908e-03],\n", - " [ 8.02807696e-03]],\n", - "\n", - " ...,\n", - "\n", - " [[-3.83506250e-03],\n", - " [ 2.88172178e-02],\n", - " [ 3.00614834e-02],\n", - " ...,\n", - " [ 6.64538145e-02],\n", - " [ 5.73254153e-02],\n", - " [ 3.55331041e-02]],\n", - "\n", - " [[-3.53273423e-03],\n", - " [ 1.88302714e-02],\n", - " [ 2.77014151e-02],\n", - " ...,\n", - " [ 4.61639501e-02],\n", - " [ 3.17977704e-02],\n", - " [ 1.39020365e-02]],\n", - "\n", - " [[-9.01793875e-03],\n", - " [ 5.76036330e-03],\n", - " [ 1.20072532e-02],\n", - " ...,\n", - " [ 2.51763277e-02],\n", - " [ 1.53386658e-02],\n", - " [ 3.13971471e-03]]],\n", - "\n", - "\n", - " [[[-4.17507748e-04],\n", - " [ 7.67845311e-04],\n", - " [ 4.06648323e-04],\n", - " ...,\n", - " [ 1.55756494e-03],\n", - " [ 1.93347712e-03],\n", - " [ 4.37485427e-03]],\n", - "\n", - " [[-6.64999679e-05],\n", - " [ 2.30852608e-03],\n", - " [ 4.01693489e-03],\n", - " ...,\n", - " [ 6.86086109e-03],\n", - " [ 7.29326252e-03],\n", - " [ 6.82889065e-03]],\n", - "\n", - " [[-2.48779106e-05],\n", - " [ 2.07340484e-03],\n", - " [ 4.06476948e-03],\n", - " ...,\n", - " [ 8.07710458e-03],\n", - " [ 8.56564939e-03],\n", - " [ 5.76988002e-03]],\n", - "\n", - " ...,\n", - "\n", - " [[-5.35211060e-04],\n", - " [ 1.56849381e-02],\n", - " [ 1.62470769e-02],\n", - " ...,\n", - " [ 5.22287413e-02],\n", - " [ 3.22894752e-02],\n", - " [ 1.47336591e-02]],\n", - "\n", - " [[-2.04390544e-03],\n", - " [ 1.15066739e-02],\n", - " [ 1.54454783e-02],\n", - " ...,\n", - " [ 3.42928916e-02],\n", - " [ 2.12032460e-02],\n", - " [ 2.07589101e-03]],\n", - "\n", - " [[-4.86424379e-03],\n", - " [ 4.26311605e-03],\n", - " [ 7.18892412e-03],\n", - " ...,\n", - " [ 1.62898749e-02],\n", - " [ 8.77049472e-03],\n", - " [-1.83343887e-03]]],\n", - "\n", - "\n", - " [[[-2.73332698e-04],\n", - " [ 3.11197218e-04],\n", - " [ 3.43630556e-04],\n", - " ...,\n", - " [ 7.62445386e-04],\n", - " [ 1.07039860e-03],\n", - " [ 2.91697634e-03]],\n", - "\n", - " [[-5.72583813e-05],\n", - " [ 1.93260156e-03],\n", - " [ 3.22319777e-03],\n", - " ...,\n", - " [ 4.22241259e-03],\n", - " [ 4.19293763e-03],\n", - " [ 4.79434943e-03]],\n", - "\n", - " [[ 6.25447137e-04],\n", - " [ 2.84694950e-03],\n", - " [ 3.78600298e-03],\n", - " ...,\n", - " [ 4.36908705e-03],\n", - " [ 5.21399919e-03],\n", - " [ 4.24094731e-03]],\n", - "\n", - " ...,\n", - "\n", - " [[ 3.30056180e-04],\n", - " [ 4.74191178e-03],\n", - " [ 4.27093031e-03],\n", - " ...,\n", - " [ 2.69412324e-02],\n", - " [ 1.27332192e-02],\n", - " [ 3.45749641e-03]],\n", - "\n", - " [[-8.45994335e-04],\n", - " [ 1.89564051e-03],\n", - " [ 4.12365142e-03],\n", - " ...,\n", - " [ 1.79680120e-02],\n", - " [ 5.90574741e-03],\n", - " [-3.65133304e-03]],\n", - "\n", - " [[-1.68516184e-03],\n", - " [ 6.12936215e-04],\n", - " [ 1.87073369e-03],\n", - " ...,\n", - " [ 3.79876629e-03],\n", - " [-1.14162010e-03],\n", - " [-3.92165594e-03]]]], dtype=float32)}\n" + "2022-08-04 10:26:54.172315: I tensorflow/stream_executor/cuda/cuda_dnn.cc:384] Loaded cuDNN version 8101\n" ] - } - ], - "source": [ - "print(preds)" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ + }, { "name": "stdout", "output_type": "stream", "text": [ - "30/30 [==============================] - 12s 212ms/step\n" + "30/30 [==============================] - 14s 207ms/step\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "2022-08-04 09:17:25.761455: W tensorflow/core/kernels/data/cache_dataset_ops.cc:856] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.\n" + "2022-08-04 10:27:00.899676: W tensorflow/core/kernels/data/cache_dataset_ops.cc:856] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.\n" ] } ], @@ -1047,12 +532,12 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1069,40 +554,67 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 23, "metadata": {}, "outputs": [ { - "ename": "AttributeError", - "evalue": "module 'tensorflow_mri._api.activations' has no attribute 'complex_relu'", + "name": "stdout", + "output_type": "stream", + "text": [ + "iteration 0\n", + "x.shape: (None, 320, 320, 1), b.shape: (None, None, 320, 320)\n", + "reg: (None, 320, 320, 1)\n", + "(None, 320, 320) (320, 320) (320, 320)\n", + "lsgd: (None, None, 320, 320, 1)\n", + "iteration 1\n", + "x.shape: (None, None, 320, 320, 1), b.shape: (None, None, 320, 320)\n" + ] + }, + { + "ename": "ValueError", + "evalue": "Exception encountered when calling layer \"reg\" (type UNet2D).\n\nin user code:\n\n File \"/workspaces/tensorflow-mri/tensorflow_mri/python/models/conv_endec.py\", line 273, in call *\n x = self._pools[scale](cache[scale])\n File \"/usr/local/lib/python3.8/site-packages/keras/utils/traceback_utils.py\", line 67, in error_handler **\n raise e.with_traceback(filtered_tb) from None\n File \"/usr/local/lib/python3.8/site-packages/keras/engine/input_spec.py\", line 214, in assert_input_compatibility\n raise ValueError(f'Input {input_index} of layer \"{layer_name}\" '\n\n ValueError: Input 0 of layer \"max_pooling2d_8\" is incompatible with the layer: expected ndim=4, found ndim=5. Full shape received: (None, None, 320, 320, 32)\n\n\nCall arguments received by layer \"reg\" (type UNet2D):\n • inputs=tf.Tensor(shape=(None, None, 320, 320, 1), dtype=complex64)\n • training=None", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/workspaces/tensorflow-mri/tools/docs/tutorials/recon/unet_fastmri.ipynb Cell 20\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 19\u001b[0m outputs \u001b[39m=\u001b[39m {\u001b[39m'\u001b[39m\u001b[39mzfill\u001b[39m\u001b[39m'\u001b[39m: zfill, \u001b[39m'\u001b[39m\u001b[39mimage\u001b[39m\u001b[39m'\u001b[39m: x}\n\u001b[1;32m 20\u001b[0m \u001b[39mreturn\u001b[39;00m tf\u001b[39m.\u001b[39mkeras\u001b[39m.\u001b[39mModel(inputs\u001b[39m=\u001b[39minputs, outputs\u001b[39m=\u001b[39moutputs)\n\u001b[0;32m---> 22\u001b[0m model \u001b[39m=\u001b[39m VarNet(inputs)\n\u001b[1;32m 24\u001b[0m model\u001b[39m.\u001b[39mcompile(optimizer\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39madam\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 25\u001b[0m loss\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mmse\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 26\u001b[0m metrics\u001b[39m=\u001b[39m[tfmri\u001b[39m.\u001b[39mmetrics\u001b[39m.\u001b[39mPSNR(), tfmri\u001b[39m.\u001b[39mmetrics\u001b[39m.\u001b[39mSSIM()])\n\u001b[1;32m 28\u001b[0m model\u001b[39m.\u001b[39msummary()\n", - "\u001b[1;32m/workspaces/tensorflow-mri/tools/docs/tutorials/recon/unet_fastmri.ipynb Cell 20\u001b[0m in \u001b[0;36mVarNet\u001b[0;34m(inputs, num_iterations)\u001b[0m\n\u001b[1;32m 2\u001b[0m adj \u001b[39m=\u001b[39m AdjointRecon(name\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mzfill\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m 3\u001b[0m lsgd \u001b[39m=\u001b[39m tfmri\u001b[39m.\u001b[39mlayers\u001b[39m.\u001b[39mLeastSquaresGradientDescent(\n\u001b[1;32m 4\u001b[0m operator\u001b[39m=\u001b[39mtfmri\u001b[39m.\u001b[39mlinalg\u001b[39m.\u001b[39mLinearOperatorMRI)\n\u001b[1;32m 5\u001b[0m denoise \u001b[39m=\u001b[39m tfmri\u001b[39m.\u001b[39mmodels\u001b[39m.\u001b[39mUNet2D(\n\u001b[1;32m 6\u001b[0m filters\u001b[39m=\u001b[39m[\u001b[39m32\u001b[39m, \u001b[39m64\u001b[39m, \u001b[39m128\u001b[39m],\n\u001b[1;32m 7\u001b[0m kernel_size\u001b[39m=\u001b[39m\u001b[39m3\u001b[39m,\n\u001b[0;32m----> 8\u001b[0m activation\u001b[39m=\u001b[39mtfmri\u001b[39m.\u001b[39;49mactivations\u001b[39m.\u001b[39;49mcomplex_relu,\n\u001b[1;32m 9\u001b[0m out_channels\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m,\n\u001b[1;32m 10\u001b[0m dtype\u001b[39m=\u001b[39mtf\u001b[39m.\u001b[39mcomplex64,\n\u001b[1;32m 11\u001b[0m name\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mprior\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m 13\u001b[0m zfill \u001b[39m=\u001b[39m adj(inputs)\n\u001b[1;32m 14\u001b[0m x \u001b[39m=\u001b[39m zfill\n", - "\u001b[0;31mAttributeError\u001b[0m: module 'tensorflow_mri._api.activations' has no attribute 'complex_relu'" + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/workspaces/tensorflow-mri/tools/docs/tutorials/recon/unet_fastmri.ipynb Cell 19\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 27\u001b[0m outputs \u001b[39m=\u001b[39m {\u001b[39m'\u001b[39m\u001b[39mzfill\u001b[39m\u001b[39m'\u001b[39m: zfill, \u001b[39m'\u001b[39m\u001b[39mimage\u001b[39m\u001b[39m'\u001b[39m: x}\n\u001b[1;32m 28\u001b[0m \u001b[39mreturn\u001b[39;00m tf\u001b[39m.\u001b[39mkeras\u001b[39m.\u001b[39mModel(inputs\u001b[39m=\u001b[39minputs, outputs\u001b[39m=\u001b[39moutputs)\n\u001b[0;32m---> 30\u001b[0m model \u001b[39m=\u001b[39m VarNet(inputs)\n\u001b[1;32m 32\u001b[0m model\u001b[39m.\u001b[39mcompile(optimizer\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39madam\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 33\u001b[0m loss\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mmse\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 34\u001b[0m metrics\u001b[39m=\u001b[39m[tfmri\u001b[39m.\u001b[39mmetrics\u001b[39m.\u001b[39mPSNR(), tfmri\u001b[39m.\u001b[39mmetrics\u001b[39m.\u001b[39mSSIM()])\n\u001b[1;32m 36\u001b[0m model\u001b[39m.\u001b[39msummary()\n", + "\u001b[1;32m/workspaces/tensorflow-mri/tools/docs/tutorials/recon/unet_fastmri.ipynb Cell 19\u001b[0m in \u001b[0;36mVarNet\u001b[0;34m(inputs, num_iterations)\u001b[0m\n\u001b[1;32m 17\u001b[0m b \u001b[39m=\u001b[39m inputs[\u001b[39m'\u001b[39m\u001b[39mkspace\u001b[39m\u001b[39m'\u001b[39m]\n\u001b[1;32m 18\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mx.shape: \u001b[39m\u001b[39m{\u001b[39;00mx\u001b[39m.\u001b[39mshape\u001b[39m}\u001b[39;00m\u001b[39m, b.shape: \u001b[39m\u001b[39m{\u001b[39;00mb\u001b[39m.\u001b[39mshape\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m)\n\u001b[0;32m---> 19\u001b[0m x \u001b[39m=\u001b[39m reg(x)\n\u001b[1;32m 20\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mreg: \u001b[39m\u001b[39m{\u001b[39;00mx\u001b[39m.\u001b[39mshape\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 21\u001b[0m x \u001b[39m=\u001b[39m lsgd({\u001b[39m'\u001b[39m\u001b[39mx\u001b[39m\u001b[39m'\u001b[39m: x,\n\u001b[1;32m 22\u001b[0m \u001b[39m'\u001b[39m\u001b[39mb\u001b[39m\u001b[39m'\u001b[39m: inputs[\u001b[39m'\u001b[39m\u001b[39mkspace\u001b[39m\u001b[39m'\u001b[39m],\n\u001b[1;32m 23\u001b[0m \u001b[39m'\u001b[39m\u001b[39mimage_shape\u001b[39m\u001b[39m'\u001b[39m: tf\u001b[39m.\u001b[39mshape(inputs[\u001b[39m'\u001b[39m\u001b[39mkspace\u001b[39m\u001b[39m'\u001b[39m])[\u001b[39m-\u001b[39m\u001b[39m2\u001b[39m:],\n\u001b[1;32m 24\u001b[0m \u001b[39m'\u001b[39m\u001b[39mmask\u001b[39m\u001b[39m'\u001b[39m: inputs[\u001b[39m'\u001b[39m\u001b[39mmask\u001b[39m\u001b[39m'\u001b[39m]})\n", + "File \u001b[0;32m/usr/local/lib/python3.8/site-packages/keras/utils/traceback_utils.py:67\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 65\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e: \u001b[39m# pylint: disable=broad-except\u001b[39;00m\n\u001b[1;32m 66\u001b[0m filtered_tb \u001b[39m=\u001b[39m _process_traceback_frames(e\u001b[39m.\u001b[39m__traceback__)\n\u001b[0;32m---> 67\u001b[0m \u001b[39mraise\u001b[39;00m e\u001b[39m.\u001b[39mwith_traceback(filtered_tb) \u001b[39mfrom\u001b[39;00m \u001b[39mNone\u001b[39m\n\u001b[1;32m 68\u001b[0m \u001b[39mfinally\u001b[39;00m:\n\u001b[1;32m 69\u001b[0m \u001b[39mdel\u001b[39;00m filtered_tb\n", + "File \u001b[0;32m/tmp/__autograph_generated_file_8jwn45w.py:61\u001b[0m, in \u001b[0;36mouter_factory..inner_factory..tf__call\u001b[0;34m(self, inputs, training)\u001b[0m\n\u001b[1;32m 59\u001b[0m ag__\u001b[39m.\u001b[39mif_stmt(ag__\u001b[39m.\u001b[39mld(\u001b[39mself\u001b[39m)\u001b[39m.\u001b[39m_use_tight_frame, if_body_1, else_body_1, get_state_1, set_state_1, (\u001b[39m'\u001b[39m\u001b[39mdetail_cache[scale]\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39mx\u001b[39m\u001b[39m'\u001b[39m), \u001b[39m2\u001b[39m)\n\u001b[1;32m 60\u001b[0m scale \u001b[39m=\u001b[39m ag__\u001b[39m.\u001b[39mUndefined(\u001b[39m'\u001b[39m\u001b[39mscale\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m---> 61\u001b[0m ag__\u001b[39m.\u001b[39mfor_stmt(ag__\u001b[39m.\u001b[39mconverted_call(ag__\u001b[39m.\u001b[39mld(\u001b[39mrange\u001b[39m), ((ag__\u001b[39m.\u001b[39mld(\u001b[39mself\u001b[39m)\u001b[39m.\u001b[39m_scales \u001b[39m-\u001b[39m \u001b[39m1\u001b[39m),), \u001b[39mNone\u001b[39;00m, fscope), \u001b[39mNone\u001b[39;00m, loop_body, get_state_2, set_state_2, (\u001b[39m'\u001b[39m\u001b[39mx\u001b[39m\u001b[39m'\u001b[39m,), {\u001b[39m'\u001b[39m\u001b[39miterate_names\u001b[39m\u001b[39m'\u001b[39m: \u001b[39m'\u001b[39m\u001b[39mscale\u001b[39m\u001b[39m'\u001b[39m})\n\u001b[1;32m 62\u001b[0m x \u001b[39m=\u001b[39m ag__\u001b[39m.\u001b[39mconverted_call(ag__\u001b[39m.\u001b[39mld(\u001b[39mself\u001b[39m)\u001b[39m.\u001b[39m_enc_blocks[(\u001b[39m-\u001b[39m \u001b[39m1\u001b[39m)], (ag__\u001b[39m.\u001b[39mld(x),), \u001b[39mNone\u001b[39;00m, fscope)\n\u001b[1;32m 64\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_state_4\u001b[39m():\n", + "File \u001b[0;32m/tmp/__autograph_generated_file_8jwn45w.py:42\u001b[0m, in \u001b[0;36mouter_factory..inner_factory..tf__call..loop_body\u001b[0;34m(itr)\u001b[0m\n\u001b[1;32m 40\u001b[0m scale \u001b[39m=\u001b[39m itr\n\u001b[1;32m 41\u001b[0m ag__\u001b[39m.\u001b[39mld(cache)[ag__\u001b[39m.\u001b[39mld(scale)] \u001b[39m=\u001b[39m ag__\u001b[39m.\u001b[39mconverted_call(ag__\u001b[39m.\u001b[39mld(\u001b[39mself\u001b[39m)\u001b[39m.\u001b[39m_enc_blocks[ag__\u001b[39m.\u001b[39mld(scale)], (ag__\u001b[39m.\u001b[39mld(x),), \u001b[39mNone\u001b[39;00m, fscope)\n\u001b[0;32m---> 42\u001b[0m x \u001b[39m=\u001b[39m ag__\u001b[39m.\u001b[39;49mconverted_call(ag__\u001b[39m.\u001b[39;49mld(\u001b[39mself\u001b[39;49m)\u001b[39m.\u001b[39;49m_pools[ag__\u001b[39m.\u001b[39;49mld(scale)], (ag__\u001b[39m.\u001b[39;49mld(cache)[ag__\u001b[39m.\u001b[39;49mld(scale)],), \u001b[39mNone\u001b[39;49;00m, fscope)\n\u001b[1;32m 44\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_state_1\u001b[39m():\n\u001b[1;32m 45\u001b[0m \u001b[39mreturn\u001b[39;00m (ag__\u001b[39m.\u001b[39mldu((\u001b[39mlambda\u001b[39;00m : detail_cache[scale]), \u001b[39m'\u001b[39m\u001b[39mdetail_cache[scale]\u001b[39m\u001b[39m'\u001b[39m), x)\n", + "\u001b[0;31mValueError\u001b[0m: Exception encountered when calling layer \"reg\" (type UNet2D).\n\nin user code:\n\n File \"/workspaces/tensorflow-mri/tensorflow_mri/python/models/conv_endec.py\", line 273, in call *\n x = self._pools[scale](cache[scale])\n File \"/usr/local/lib/python3.8/site-packages/keras/utils/traceback_utils.py\", line 67, in error_handler **\n raise e.with_traceback(filtered_tb) from None\n File \"/usr/local/lib/python3.8/site-packages/keras/engine/input_spec.py\", line 214, in assert_input_compatibility\n raise ValueError(f'Input {input_index} of layer \"{layer_name}\" '\n\n ValueError: Input 0 of layer \"max_pooling2d_8\" is incompatible with the layer: expected ndim=4, found ndim=5. Full shape received: (None, None, 320, 320, 32)\n\n\nCall arguments received by layer \"reg\" (type UNet2D):\n • inputs=tf.Tensor(shape=(None, None, 320, 320, 1), dtype=complex64)\n • training=None" ] } ], "source": [ "def VarNet(inputs, num_iterations=5):\n", - " adj = AdjointRecon(name='zfill')\n", + " x = inputs\n", + " x = CoilSensitivities(passthrough=True)(x)\n", + " x = KSpaceScaling(passthrough=True)(x)\n", + " zfill = ReconAdjoint(name='zfill')(x)\n", + "\n", " lsgd = tfmri.layers.LeastSquaresGradientDescent(\n", - " operator=tfmri.linalg.LinearOperatorMRI)\n", - " denoise = tfmri.models.UNet2D(\n", + " operator=tfmri.linalg.LinearOperatorMRI, dtype=tf.complex64)\n", + " reg = tfmri.models.UNet2D(\n", " filters=[32, 64, 128],\n", " kernel_size=3,\n", " activation=tfmri.activations.complex_relu,\n", " out_channels=1,\n", " dtype=tf.complex64,\n", - " name='prior')\n", + " name='reg')\n", "\n", - " zfill = adj(inputs)\n", - " x = zfill\n", " for i in range(num_iterations):\n", - " x = denoise(x)\n", - " x = lsgd(x)\n", + " print(f\"iteration {i}\")\n", + " b = inputs['kspace']\n", + " print(f\"x.shape: {x.shape}, b.shape: {b.shape}\")\n", + " x = reg(x)\n", + " print(f\"reg: {x.shape}\")\n", + " x = lsgd({'x': x,\n", + " 'b': x['kspace'],\n", + " 'image_shape': tf.shape(x['kspace'])[-2:],\n", + " 'mask': x['mask'],\n", + " 'sensitivities': x['sensitivities']})\n", + " print(f\"lsgd: {x.shape}\")\n", "\n", " outputs = {'zfill': zfill, 'image': x}\n", " return tf.keras.Model(inputs=inputs, outputs=outputs)\n", From 817da6b1ae007c8f23b302c4a8164f7a8b6d28d7 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Mon, 15 Aug 2022 13:26:39 +0100 Subject: [PATCH 012/101] Preprocess and postprocess for linear operators --- .../python/linalg/linear_operator.py | 89 ++++++++++++++++++- .../python/linalg/linear_operator_mri.py | 45 +++++++++- .../python/linalg/linear_operator_nufft.py | 26 ++++-- .../linalg/linear_operator_nufft_test.py | 10 ++- tensorflow_mri/python/ops/recon_ops.py | 33 ++----- 5 files changed, 161 insertions(+), 42 deletions(-) diff --git a/tensorflow_mri/python/linalg/linear_operator.py b/tensorflow_mri/python/linalg/linear_operator.py index a2e6ed09..0b493d36 100644 --- a/tensorflow_mri/python/linalg/linear_operator.py +++ b/tensorflow_mri/python/linalg/linear_operator.py @@ -27,18 +27,18 @@ class LinearOperatorMixin(tf.linalg.LinearOperator): """Mixin for linear operators meant to operate on images.""" def transform(self, x, adjoint=False, name="transform"): - """Transform a batch of images. + """Transforms a batch of inputs. - Applies this operator to a batch of non-vectorized images `x`. + Applies this operator to a batch of non-vectorized inputs `x`. Args: - x: A `Tensor` with compatible shape and same dtype as `self`. + x: A `tf.Tensor` with compatible shape and same dtype as `self`. adjoint: A `boolean`. If `True`, transforms the input using the adjoint of the operator, instead of the operator itself. name: A name for this operation. Returns: - The transformed `Tensor` with the same `dtype` as `self`. + The transformed `tf.Tensor` with the same `dtype` as `self`. """ with self._name_scope(name): # pylint: disable=not-callable x = tf.convert_to_tensor(x, name="x") @@ -47,6 +47,54 @@ def transform(self, x, adjoint=False, name="transform"): input_shape.assert_is_compatible_with(x.shape[-input_shape.rank:]) # pylint: disable=invalid-unary-operand-type return self._transform(x, adjoint=adjoint) + def preprocess(self, x, adjoint=False, name="preprocess"): + """Preprocesses a batch of inputs. + + This method should be called **before** applying the operator via + `transform`, `matvec` or `matmul`. The `adjoint` flag should be set to the + same value as the `adjoint` flag passed to `transform`, `matvec` or + `matmul`. + + Args: + x: A `tf.Tensor` with compatible shape and same dtype as `self`. + adjoint: A `boolean`. If `True`, preprocesses the input in preparation + for applying the adjoint. + name: A name for this operation. + + Returns: + The preprocessed `tf.Tensor` with the same `dtype` as `self`. + """ + with self._name_scope(name): + x = tf.convert_to_tensor(x, name="x") + self._check_input_dtype(x) + input_shape = self.range_shape if adjoint else self.domain_shape + input_shape.assert_is_compatible_with(x.shape[-input_shape.rank:]) # pylint: disable=invalid-unary-operand-type + return self._preprocess(x, adjoint=adjoint) + + def postprocess(self, x, adjoint=False, name="postprocess"): + """Postprocesses a batch of inputs. + + This method should be called **after** applying the operator via + `transform`, `matvec` or `matmul`. The `adjoint` flag should be set to the + same value as the `adjoint` flag passed to `transform`, `matvec` or + `matmul`. + + Args: + x: A `tf.Tensor` with compatible shape and same dtype as `self`. + adjoint: A `boolean`. If `True`, postprocesses the input after applying + the adjoint. + name: A name for this operation. + + Returns: + The preprocessed `tf.Tensor` with the same `dtype` as `self`. + """ + with self._name_scope(name): + x = tf.convert_to_tensor(x, name="x") + self._check_input_dtype(x) + input_shape = self.range_shape if adjoint else self.domain_shape + input_shape.assert_is_compatible_with(x.shape[-input_shape.rank:]) # pylint: disable=invalid-unary-operand-type + return self._postprocess(x, adjoint=adjoint) + @property def domain_shape(self): """Domain shape of this linear operator.""" @@ -106,6 +154,14 @@ def _transform(self, x, adjoint=False): # Subclasses must override this method. raise NotImplementedError("Method `_transform` is not implemented.") + def _preprocess(self, x, adjoint=False): + # Subclasses may override this method. + return x + + def _postprocess(self, x, adjoint=False): + # Subclasses may override this method. + return x + def _matvec(self, x, adjoint=False): # Default implementation of `_matvec` for imaging operator. The vectorized # input `x` is first expanded to the its full shape, then transformed, then @@ -326,6 +382,20 @@ class LinearOperator(LinearOperatorMixin, tf.linalg.LinearOperator): # pylint: `expand_range_dimension` may be used to expand vectorized inputs/outputs to their full-shaped form. + **Preprocessing and post-processing** + + It can sometimes be useful to modify a linear operator in order to maintain + certain mathematical properties, such as Hermitian symmetry or positive + definiteness (e.g., [1]). As a result of these modifications the linear + operator may no longer accurately represent the physical system under + consideration. This can be compensated through the use of a pre-processing + step and/or post-processing step. To this end linear operators expose a + `preprocess` method and a `postprocess` method. The user may define their + behavior by overriding the `_preprocess` and/or `_postprocess` methods. If + not overriden, the default behavior is to apply the identity. In the context + of optimization methods, these steps typically only need to be applied at the + beginning or at the end of the optimization. + **Subclassing** Subclasses must always define `_transform`, which implements this operator's @@ -358,6 +428,9 @@ class LinearOperator(LinearOperatorMixin, tf.linalg.LinearOperator): # pylint: is_square: Expect that this operator acts like square [batch] matrices. name: A name for this `LinearOperator`. + References: + .. [1] https://onlinelibrary.wiley.com/doi/full/10.1002/mrm.1241 + .. _tf.linalg.LinearOperator: https://www.tensorflow.org/api_docs/python/tf/linalg/LinearOperator .. _tf.linalg.matvec: https://www.tensorflow.org/api_docs/python/tf/linalg/matvec .. _tf.linalg.matmul: https://www.tensorflow.org/api_docs/python/tf/linalg/matmul @@ -394,6 +467,14 @@ def _transform(self, x, adjoint=False): # pylint: disable=protected-access return self.operator._transform(x, adjoint=(not adjoint)) + def _preprocess(self, x, adjoint=False): + # pylint: disable=protected-access + return self.operator._preprocess(x, adjoint=(not adjoint)) + + def _postprocess(self, x, adjoint=False): + # pylint: disable=protected-access + return self.operator._postprocess(x, adjoint=(not adjoint)) + def _domain_shape(self): return self.operator.range_shape diff --git a/tensorflow_mri/python/linalg/linear_operator_mri.py b/tensorflow_mri/python/linalg/linear_operator_mri.py index 0b1b8df2..5ec28609 100644 --- a/tensorflow_mri/python/linalg/linear_operator_mri.py +++ b/tensorflow_mri/python/linalg/linear_operator_mri.py @@ -88,6 +88,9 @@ class LinearOperatorMRI(linear_operator.LinearOperator): # pylint: disable=abst or `'ortho'`. Defaults to `'ortho'`. sens_norm: A `boolean`. Whether to normalize coil sensitivities. Defaults to `True`. + intensity_correction: A `boolean`. Whether to correct for overall receiver + coil sensitivity. Defaults to `True`. Has no effect if `sens_norm` is also + `True`. dynamic_domain: A `str`. The domain of the dynamic dimension, if present. Must be one of `'time'` or `'frequency'`. May only be provided together with a non-scalar `extra_shape`. The dynamic dimension is the last @@ -108,6 +111,7 @@ def __init__(self, phase=None, fft_norm='ortho', sens_norm=True, + intensity_correction=True, dynamic_domain=None, dtype=tf.complex64, name=None): @@ -122,6 +126,7 @@ def __init__(self, phase=phase, fft_norm=fft_norm, sens_norm=sens_norm, + intensity_correction=intensity_correction, dynamic_domain=dynamic_domain, dtype=dtype, name=name) @@ -285,6 +290,12 @@ def __init__(self, self._sensitivities = math_ops.normalize_no_nan( self._sensitivities, axis=-(self._rank + 1)) + # Intensity correction. + self._intensity_correction = intensity_correction + if self._sensitivities is not None and self._intensity_correction: + self._intensity_weights_sqrt = tf.math.reciprocal_no_nan( + tf.math.sqrt(tf.norm(self._sensitivities, axis=-(self._rank + 1)))) + # Set dynamic domain. if dynamic_domain is not None and self._extra_shape.rank == 0: raise ValueError( @@ -349,6 +360,10 @@ def _transform(self, x, adjoint=False): x *= tf.math.conj(self._phase_rotator) x = tf.cast(tf.math.real(x), self.dtype) + # Apply intensity correction. + if self.is_multicoil and self._intensity_correction: + x *= self._intensity_weights_sqrt + # Apply FFT along dynamic axis, if necessary. if self.is_dynamic and self.dynamic_domain == 'frequency': x = fft_ops.fftn(x, axes=[self.dynamic_axis], @@ -356,11 +371,15 @@ def _transform(self, x, adjoint=False): else: # Forward operator. - # Apply FFT along dynamic axis, if necessary. + # Apply IFFT along dynamic axis, if necessary. if self.is_dynamic and self.dynamic_domain == 'frequency': x = fft_ops.ifftn(x, axes=[self.dynamic_axis], norm='ortho', shift=True) + # Apply intensity correction. + if self.is_multicoil and self._intensity_correction: + x *= self._intensity_weights_sqrt + # Add phase to real-valued image if reconstruction is phase-constrained. if self.is_phase_constrained: x = tf.cast(tf.math.real(x), self.dtype) @@ -392,6 +411,30 @@ def _transform(self, x, adjoint=False): return x + def _preprocess(self, x, adjoint=False): + if adjoint: + if self._density is not None: + x *= self._dens_weights_sqrt + else: + raise NotImplementedError( + "`_preprocess` not implemented for forward transform.") + return x + + def _postprocess(self, x, adjoint=False): + if adjoint: + # Apply temporal Fourier operator, if necessary. + if self.is_dynamic and self.dynamic_domain == 'frequency': + x = fft_ops.ifftn(x, axes=[self.dynamic_axis], + norm='ortho', shift=True) + + # Apply intensity correction, if necessary. + if self.is_multicoil and self._intensity_correction: + x *= self._intensity_weights_sqrt + else: + raise NotImplementedError( + "`_postprocess` not implemented for forward transform.") + return x + def _domain_shape(self): """Returns the static shape of the domain space of this operator.""" return self._extra_shape_static.concatenate(self._image_shape_static) diff --git a/tensorflow_mri/python/linalg/linear_operator_nufft.py b/tensorflow_mri/python/linalg/linear_operator_nufft.py index 04dedba9..bca38634 100644 --- a/tensorflow_mri/python/linalg/linear_operator_nufft.py +++ b/tensorflow_mri/python/linalg/linear_operator_nufft.py @@ -50,12 +50,12 @@ class LinearOperatorNUFFT(linear_operator.LinearOperator): # pylint: disable=ab Notes: In MRI, sampling density compensation is typically performed during the - adjoint transform. However, in order to maintain the validity of the linear - operator, this operator applies the compensation orthogonally, i.e., + adjoint transform. However, in order to maintain certain properties of the + linear operator, this operator applies the compensation orthogonally, i.e., it scales the data by the square root of `density` in both forward and adjoint transforms. If you are using this operator to compute the adjoint and wish to apply the full compensation, you can do so via the - `precompensate` method. + `preprocess` method. >>> import tensorflow as tf >>> import tensorflow_mri as tfmri @@ -75,7 +75,7 @@ class LinearOperatorNUFFT(linear_operator.LinearOperator): # pylint: disable=ab >>> # (square root of weights). >>> image = linop.transform(kspace, adjoint=True) >>> # This reconstructs the image with full compensation. - >>> image = linop.transform(linop.precompensate(kspace), adjoint=True) + >>> image = linop.transform(linop.preprocess(kspace, adjoint=True), adjoint=True) """ def __init__(self, domain_shape, @@ -222,9 +222,21 @@ def _transform(self, x, adjoint=False): x *= self._weights_sqrt return x - def precompensate(self, x): - if self.density is not None: - return x * self._weights_sqrt + def _preprocess(self, x, adjoint=False): + if adjoint: + if self.density is not None: + x *= self._weights_sqrt + else: + raise NotImplementedError( + "_preprocess not implemented for forward transform.") + return x + + def _postprocess(self, x, adjoint=False): + if adjoint: + pass # nothing to do + else: + raise NotImplementedError( + "_postprocess not implemented for forward transform.") return x def _domain_shape(self): diff --git a/tensorflow_mri/python/linalg/linear_operator_nufft_test.py b/tensorflow_mri/python/linalg/linear_operator_nufft_test.py index ee75067a..bfcac13f 100755 --- a/tensorflow_mri/python/linalg/linear_operator_nufft_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_nufft_test.py @@ -187,11 +187,13 @@ def test_with_density(self): kspace_d = linop_d.transform(image) self.assertAllClose(kspace * weights, kspace_d) - # Test adjoint and precompensate function. - recon = linop.transform(linop.precompensate(kspace) * weights * weights, - adjoint=True) + # Test adjoint and preprocess function. + recon = linop.transform( + linop.preprocess(kspace, adjoint=True) * weights * weights, + adjoint=True) recon_d1 = linop_d.transform(kspace_d, adjoint=True) - recon_d2 = linop_d.transform(linop_d.precompensate(kspace), adjoint=True) + recon_d2 = linop_d.transform(linop_d.preprocess(kspace, adjoint=True), + adjoint=True) self.assertAllClose(recon, recon_d1) self.assertAllClose(recon, recon_d2) diff --git a/tensorflow_mri/python/ops/recon_ops.py b/tensorflow_mri/python/ops/recon_ops.py index 436f0f53..b9f1153c 100644 --- a/tensorflow_mri/python/ops/recon_ops.py +++ b/tensorflow_mri/python/ops/recon_ops.py @@ -128,24 +128,15 @@ def reconstruct_adj(kspace, phase=phase, fft_norm='ortho', sens_norm=sens_norm) - rank = operator.rank - # Apply density compensation, if provided. - if density is not None: - dens_weights_sqrt = tf.math.sqrt(tf.math.reciprocal_no_nan(density)) - dens_weights_sqrt = tf.cast(dens_weights_sqrt, kspace.dtype) - if operator.is_multicoil: - dens_weights_sqrt = tf.expand_dims(dens_weights_sqrt, axis=-2) - kspace *= dens_weights_sqrt + # Apply preprocessing. + kspace = operator.preprocess(kspace, adjoint=True) # Compute zero-filled image using the adjoint operator. - image = operator.H.transform(kspace) + image = operator.transform(kspace, adjoint=True) - # Apply intensity correction, if requested. - if operator.is_multicoil and sens_norm: - sens_weights_sqrt = tf.math.reciprocal_no_nan( - tf.norm(sensitivities, axis=-(rank + 1), keepdims=False)) - image *= sens_weights_sqrt + # Apply post-processing. + image = operator.postprocess(image, adjoint=True) return image @@ -354,8 +345,7 @@ def reconstruct_lstsq(kspace, gram_operator = None # Apply density compensation, if provided. - if density is not None: - kspace *= operator._dens_weights_sqrt # pylint: disable=protected-access + kspace = operator.preprocess(kspace, adjoint=True) initial_image = operator.H.transform(kspace) @@ -441,16 +431,7 @@ def _objective(x): else: raise ValueError(f"Unknown optimizer: {optimizer}") - # Apply temporal Fourier operator, if necessary. - if operator.is_dynamic and operator.dynamic_domain == 'frequency': - image = fft_ops.ifftn(image, axes=[operator.dynamic_axis], - norm='ortho', shift=True) - - # Apply intensity correction, if requested. - if operator.is_multicoil and sens_norm: - sens_weights_sqrt = tf.math.reciprocal_no_nan( - tf.norm(sensitivities, axis=-(rank + 1), keepdims=False)) - image *= sens_weights_sqrt + image = operator.postprocess(image, adjoint=True) # If necessary, filter the image to remove k-space corners. This can be # done if the trajectory has circular coverage and does not cover the k-space From 6654b9fbcb59e72aa75fae63705d57c549b38f6b Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Mon, 15 Aug 2022 14:57:27 +0000 Subject: [PATCH 013/101] k-space scaling layer --- tensorflow_mri/_api/recon/__init__.py | 7 +- tensorflow_mri/python/__init__.py | 1 + .../python/layers/data_consistency.py | 1 - .../python/layers/kspace_scaling.py | 62 ++++ .../python/layers/kspace_scaling_test.py | 41 +++ .../python/layers/linear_operator_layer.py | 100 ++++++ .../linalg/linear_operator_gram_nufft_test.py | 9 +- tensorflow_mri/python/models/varnet.py | 94 +++++ tensorflow_mri/python/ops/recon_ops.py | 105 +----- tensorflow_mri/python/ops/recon_ops_test.py | 59 ---- tensorflow_mri/python/recon/__init__.py | 18 + tensorflow_mri/python/recon/recon_adjoint.py | 133 +++++++ .../python/recon/recon_adjoint_test.py | 93 +++++ .../python/recon/recon_least_squares.py | 15 + tensorflow_mri/python/util/api_util.py | 2 +- tools/docs/tutorials/recon/unet_fastmri.ipynb | 324 ++++++++---------- 16 files changed, 719 insertions(+), 345 deletions(-) create mode 100644 tensorflow_mri/python/layers/kspace_scaling.py create mode 100644 tensorflow_mri/python/layers/kspace_scaling_test.py create mode 100644 tensorflow_mri/python/layers/linear_operator_layer.py create mode 100644 tensorflow_mri/python/models/varnet.py create mode 100644 tensorflow_mri/python/recon/__init__.py create mode 100644 tensorflow_mri/python/recon/recon_adjoint.py create mode 100644 tensorflow_mri/python/recon/recon_adjoint_test.py create mode 100644 tensorflow_mri/python/recon/recon_least_squares.py diff --git a/tensorflow_mri/_api/recon/__init__.py b/tensorflow_mri/_api/recon/__init__.py index 2bee140c..6a418f93 100644 --- a/tensorflow_mri/_api/recon/__init__.py +++ b/tensorflow_mri/_api/recon/__init__.py @@ -1,9 +1,10 @@ # This file was automatically generated by tools/build/create_api.py. # Do not edit. -"""Image reconstruction.""" +"""Signal reconstruction.""" -from tensorflow_mri.python.ops.recon_ops import reconstruct_adj as adjoint -from tensorflow_mri.python.ops.recon_ops import reconstruct_adj as adj +from tensorflow_mri.python.recon.recon_adjoint import recon_adjoint as custom_adjoint +from tensorflow_mri.python.recon.recon_adjoint import recon_adjoint_mri as adjoint +from tensorflow_mri.python.recon.recon_adjoint import recon_adjoint_mri as adj from tensorflow_mri.python.ops.recon_ops import reconstruct_lstsq as least_squares from tensorflow_mri.python.ops.recon_ops import reconstruct_lstsq as lstsq from tensorflow_mri.python.ops.recon_ops import reconstruct_sense as sense diff --git a/tensorflow_mri/python/__init__.py b/tensorflow_mri/python/__init__.py index 67e902f7..5853bf11 100644 --- a/tensorflow_mri/python/__init__.py +++ b/tensorflow_mri/python/__init__.py @@ -23,5 +23,6 @@ from tensorflow_mri.python import metrics from tensorflow_mri.python import models from tensorflow_mri.python import ops +from tensorflow_mri.python import recon from tensorflow_mri.python import summary from tensorflow_mri.python import util diff --git a/tensorflow_mri/python/layers/data_consistency.py b/tensorflow_mri/python/layers/data_consistency.py index 834a422d..40618a27 100644 --- a/tensorflow_mri/python/layers/data_consistency.py +++ b/tensorflow_mri/python/layers/data_consistency.py @@ -90,7 +90,6 @@ def call(self, inputs): operator = self.operator if self.handle_channel_axis: x = tf.squeeze(x, axis=-1) - print(x.shape, operator.domain_shape, operator.range_shape) x -= tf.cast(self.scale, self.dtype) * operator.transform( operator.transform(x) - b, adjoint=True) if self.handle_channel_axis: diff --git a/tensorflow_mri/python/layers/kspace_scaling.py b/tensorflow_mri/python/layers/kspace_scaling.py new file mode 100644 index 00000000..8b45bf3b --- /dev/null +++ b/tensorflow_mri/python/layers/kspace_scaling.py @@ -0,0 +1,62 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""*k*-space scaling layer.""" + +import tensorflow as tf + +from tensorflow_mri.python.layers import linear_operator_layer +from tensorflow_mri.python.linalg import linear_operator_mri +from tensorflow_mri.python.recon import recon_adjoint + + +class KSpaceScaling(linear_operator_layer.LinearOperatorLayer): + """K-space scaling layer. + + This layer scales the *k*-space data so that the adjoint reconstruction has + values between 0 and 1. + """ + def __init__(self, + operator=linear_operator_mri.LinearOperatorMRI, + kspace_index=None, + **kwargs): + """Initializes the layer.""" + super().__init__(operator=operator, input_indices=kspace_index, **kwargs) + + def call(self, inputs): + """Applies the layer. + + Args: + inputs: A `tuple` or `dict` containing the *k*-space data as defined by + `kspace_index`. If `operator` is a class not an instance, then `inputs` + must also contain any other arguments to be passed to the constructor of + `operator`. + + Returns: + The scaled k-space data. + """ + kspace, operator = self.parse_inputs(inputs) + image = recon_adjoint.recon_adjoint(kspace, operator) + return kspace / tf.cast(tf.math.reduce_max(tf.math.abs(image)), + kspace.dtype) + + def get_config(self): + """Returns the config of the layer. + + Returns: + A `dict` describing the layer configuration. + """ + base_config = super().get_config() + config = {} + return {**config, **base_config} diff --git a/tensorflow_mri/python/layers/kspace_scaling_test.py b/tensorflow_mri/python/layers/kspace_scaling_test.py new file mode 100644 index 00000000..d81d3af9 --- /dev/null +++ b/tensorflow_mri/python/layers/kspace_scaling_test.py @@ -0,0 +1,41 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Tests for module `kspace_scaling`.""" + +import tensorflow as tf + +from tensorflow_mri.python.layers import kspace_scaling +from tensorflow_mri.python.recon import recon_adjoint +from tensorflow_mri.python.util import test_util + + +class KSpaceScalingTest(test_util.TestCase): + """Tests for module `kspace_scaling`.""" + def test_kspace_scaling(self): + """Tests the k-space scaling layer.""" + layer = kspace_scaling.KSpaceScaling() + image_shape = [4, 4] + + kspace = tf.dtypes.complex( + tf.random.stateless_normal(shape=image_shape, seed=[11, 22]), + tf.random.stateless_normal(shape=image_shape, seed=[12, 34])) + inputs = (kspace, image_shape) + + result = layer(inputs) + + image = recon_adjoint.recon_adjoint_mri(kspace, image_shape) + expected = kspace / tf.math.reduce_max(tf.math.abs(image)) + + self.assertAllClose(expected, result) diff --git a/tensorflow_mri/python/layers/linear_operator_layer.py b/tensorflow_mri/python/layers/linear_operator_layer.py new file mode 100644 index 00000000..f60240b4 --- /dev/null +++ b/tensorflow_mri/python/layers/linear_operator_layer.py @@ -0,0 +1,100 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Linear operator layer.""" + +import inspect + +import tensorflow as tf + +from tensorflow_mri.python.linalg import linear_operator + + +class LinearOperatorLayer(tf.keras.layers.Layer): + """A layer that uses a linear operator (abstract base class).""" + def __init__(self, operator, input_indices, **kwargs): + super().__init__(**kwargs) + + if isinstance(operator, linear_operator.LinearOperator): + self._operator_class = operator.__class__ + self._operator_instance = operator + elif (inspect.isclass(operator) and + issubclass(operator, linear_operator.LinearOperator)): + self._operator_class = operator + self._operator_instance = None + else: + raise TypeError( + f"`operator` must be a subclass of `tfmri.linalg.LinearOperator` " + f"or an instance thereof, but got type: {type(operator)}") + + if isinstance(input_indices, (int, str)): + input_indices = (input_indices,) + self._input_indices = input_indices + + def parse_inputs(self, inputs): + """Parses inputs to the layer. + + This function should typically be called at the beginning of the `call` + method. It returns the inputs and an instance of the linear operator to be + used. + """ + if isinstance(inputs, tuple): + # Parse inputs if passed a tuple. + if self._input_indices is None: + input_indices = (0,) + else: + input_indices = self._input_indices + main = tuple(inputs[i] for i in input_indices) + args = tuple(inputs[i] for i in range(len(inputs)) + if i not in input_indices) + kwargs = {} + + elif isinstance(inputs, dict): + # Parse inputs if passed a dict. + if self._input_indices is None: + input_indices = tuple(inputs.keys())[0] + else: + input_indices = self._input_indices + main = {k: inputs[k] for k in input_indices} + args = () + kwargs = {k: v for k, v in inputs.items() if k not in input_indices} + + # Create operator. + if self._operator_instance is None: + # No instance was provided, so create one. + operator = self._operator_class(*args, **kwargs) + else: + # Instance was provided, so use it. + if args or kwargs: + raise ValueError( + "`args` and `kwargs` cannot be used when an instance of " + "`tfmri.linalg.LinearOperator` was provided. Check your inputs.") + operator = self._operator_instance + return main, operator + + def get_config(self): + base_config = super().get_config() + config = { + 'operator': self.get_input_operator(), + 'input_indices': self._input_indices, + } + return {**config, **base_config} + + def get_input_operator(self): + """Serializes an operator to a dictionary.""" + if self._operator_instance is None: + operator = self._operator_class + else: + operator = self._operator_instance + return operator diff --git a/tensorflow_mri/python/linalg/linear_operator_gram_nufft_test.py b/tensorflow_mri/python/linalg/linear_operator_gram_nufft_test.py index 0fc91b84..e69e67f7 100755 --- a/tensorflow_mri/python/linalg/linear_operator_gram_nufft_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_gram_nufft_test.py @@ -12,16 +12,17 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== -"""Tests for module `linalg_ops`.""" +"""Tests for module `linear_operator_gram_nufft`.""" # pylint: disable=missing-class-docstring,missing-function-docstring from absl.testing import parameterized import numpy as np import tensorflow as tf +from tensorflow_mri.python.linalg import linear_operator_gram_nufft +from tensorflow_mri.python.linalg import linear_operator_nufft from tensorflow_mri.python.ops import geom_ops from tensorflow_mri.python.ops import image_ops -from tensorflow_mri.python.ops import linalg_ops from tensorflow_mri.python.ops import traj_ops from tensorflow_mri.python.util import test_util @@ -53,9 +54,9 @@ def test_general(self, density, norm, toeplitz, batch): if density is not None: density = tf.stack([density, density]) - linop = linalg_ops.LinearOperatorNUFFT( + linop = linear_operator_nufft.LinearOperatorNUFFT( image_shape, trajectory=trajectory, density=density, norm=norm) - linop_gram = linalg_ops.LinearOperatorGramNUFFT( + linop_gram = linear_operator_gram_nufft.LinearOperatorGramNUFFT( image_shape, trajectory=trajectory, density=density, norm=norm, toeplitz=toeplitz) diff --git a/tensorflow_mri/python/models/varnet.py b/tensorflow_mri/python/models/varnet.py new file mode 100644 index 00000000..47fe674e --- /dev/null +++ b/tensorflow_mri/python/models/varnet.py @@ -0,0 +1,94 @@ +# Copyright 2022 University College London. 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. +# ============================================================================== + +import tensorflow as tf + +from tensorflow_mri.python.util import api_util + + +class VarNet(tf.keras.Model): + def __init__(self, + rank, + kspace_index='kspace', + scale_kspace=True, + **kwargs): + super(VarNet, self).__init__(**kwargs) + self.rank = rank + self.scale_kspace = scale_kspace + + def call(self, inputs): + kspace = inputs['kspace'] + kwargs = {k: inputs[k] for k in inputs.keys() if k != 'kspace'} + + if 'image_shape' not in kwargs: + kwargs['image_shape'] = tf.shape(kspace)[-2:] + + kspace = KSpaceScaling()({'kspace': kspace, **kwargs}) + kwargs['sensitivities'] = CoilSensitivities()({'kspace': kspace, **kwargs}) + + zfill = ReconAdjoint()({'kspace': kspace, **kwargs}) + + image = zfill + for i in range(num_iterations): + image = tfmri.models.UNet2D( + filters=[32, 64, 128], + kernel_size=3, + activation=tfmri.activations.complex_relu, + out_channels=1, + dtype=tf.complex64, + name=f'reg_{i}')(image) + image = tfmri.layers.LeastSquaresGradientDescent( + operator=tfmri.linalg.LinearOperatorMRI, + dtype=tf.complex64, + name=f'lsgd_{i}')( + {'x': image, 'b': kspace, **kwargs}) + + outputs = {'zfill': zfill, 'image': image} + return tf.keras.Model(inputs=inputs, outputs=outputs) + + def parse_inputs(self, inputs): + if isinstance(inputs, dict): + kspace = inputs[self.kspace_index] + args = () + kwargs = {k: inputs[k] for k in inputs.keys() if k != self.kspace_index} + elif isinstance(inputs, tuple): + kspace = inputs[0] + args = inputs[1:] + kwargs = {} + else: + raise TypeError( + f"inputs must be a dict or a tuple, but got type: {type(inputs)}") + return kspace, args, kwargs + + +@api_util.export("models.VarNet1D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class VarNet1D(VarNet): + def __init__(self, *args, **kwargs): + super().__init__(1, *args, **kwargs) + + +@api_util.export("models.VarNet2D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class VarNet2D(VarNet): + def __init__(self, *args, **kwargs): + super().__init__(2, *args, **kwargs) + + +@api_util.export("models.VarNet3D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class VarNet3D(VarNet): + def __init__(self, *args, **kwargs): + super().__init__(3, *args, **kwargs) diff --git a/tensorflow_mri/python/ops/recon_ops.py b/tensorflow_mri/python/ops/recon_ops.py index b9f1153c..b393eab1 100644 --- a/tensorflow_mri/python/ops/recon_ops.py +++ b/tensorflow_mri/python/ops/recon_ops.py @@ -39,108 +39,6 @@ from tensorflow_mri.python.util import deprecation -@api_util.export("recon.adjoint", "recon.adj") -def reconstruct_adj(kspace, - image_shape, - mask=None, - trajectory=None, - density=None, - sensitivities=None, - phase=None, - sens_norm=True): - r"""Reconstructs an MR image using the adjoint MRI operator. - - Given *k*-space data :math:`b`, this function estimates the corresponding - image as :math:`x = A^H b`, where :math:`A` is the MRI linear operator. - - This operator supports Cartesian and non-Cartesian *k*-space data. - - Additional density compensation and intensity correction steps are applied - depending on the input arguments. - - This operator supports batched inputs. All batch shapes should be - broadcastable with each other. - - This operator supports multicoil imaging. Coil combination is triggered - when `sensitivities` is not `None`. If you have multiple coils but wish to - reconstruct each coil separately, simply set `sensitivities` to `None`. The - coil dimension will then be treated as a standard batch dimension (i.e., it - becomes part of `...`). - - Args: - kspace: A `Tensor`. The *k*-space samples. Must have type `complex64` or - `complex128`. `kspace` can be either Cartesian or non-Cartesian. A - Cartesian `kspace` must have shape - `[..., num_coils, *image_shape]`, where `...` are batch dimensions. A - non-Cartesian `kspace` must have shape `[..., num_coils, num_samples]`. - If not multicoil (`sensitivities` is `None`), then the `num_coils` axis - must be omitted. - image_shape: A 1D integer `tf.Tensor`. Must have length 2 or 3. - The shape of the reconstructed image[s]. - mask: An optional `Tensor` of type `bool`. The sampling mask. Must have - shape `[..., *image_shape]`. `mask` should be passed for reconstruction - from undersampled Cartesian *k*-space. For each point, `mask` should be - `True` if the corresponding *k*-space sample was measured and `False` - otherwise. - trajectory: An optional `Tensor` of type `float32` or `float64`. Must have - shape `[..., num_samples, rank]`. `trajectory` should be passed for - reconstruction from non-Cartesian *k*-space. - density: An optional `Tensor` of type `float32` or `float64`. The sampling - densities. Must have shape `[..., num_samples]`. This input is only - relevant for non-Cartesian MRI reconstruction. If passed, the MRI linear - operator will include sampling density compensation. If `None`, the MRI - operator will not perform sampling density compensation. - sensitivities: An optional `Tensor` of type `complex64` or `complex128`. - The coil sensitivity maps. Must have shape - `[..., num_coils, *image_shape]`. If provided, a multi-coil parallel - imaging reconstruction will be performed. - phase: An optional `Tensor` of type `float32` or `float64`. Must have shape - `[..., *image_shape]`. A phase estimate for the reconstructed image. If - provided, a phase-constrained reconstruction will be performed. This - improves the conditioning of the reconstruction problem in applications - where there is no interest in the phase data. However, artefacts may - appear if an inaccurate phase estimate is passed. - sens_norm: A `boolean`. Whether to normalize coil sensitivities. Defaults to - `True`. - - Returns: - A `Tensor`. The reconstructed image. Has the same type as `kspace` and - shape `[..., *image_shape]`, where `...` is the broadcasted batch shape of - all inputs. - - Notes: - Reconstructs an image by applying the adjoint MRI operator to the *k*-space - data. This typically involves an inverse FFT or a (density-compensated) - NUFFT, and coil combination for multicoil inputs. This type of - reconstruction is often called zero-filled reconstruction, because missing - *k*-space samples are assumed to be zero. Therefore, the resulting image is - likely to display aliasing artefacts if *k*-space is not sufficiently - sampled according to the Nyquist criterion. - """ - kspace = tf.convert_to_tensor(kspace) - - # Create the linear operator. - operator = linear_operator_mri.LinearOperatorMRI(image_shape, - mask=mask, - trajectory=trajectory, - density=density, - sensitivities=sensitivities, - phase=phase, - fft_norm='ortho', - sens_norm=sens_norm) - - # Apply preprocessing. - kspace = operator.preprocess(kspace, adjoint=True) - - # Compute zero-filled image using the adjoint operator. - image = operator.transform(kspace, adjoint=True) - - # Apply post-processing. - image = operator.postprocess(image, adjoint=True) - - return image - - @api_util.export("recon.least_squares", "recon.lstsq") def reconstruct_lstsq(kspace, image_shape, @@ -206,7 +104,8 @@ def reconstruct_lstsq(kspace, densities. Must have shape `[..., num_samples]`. This input is only relevant for non-Cartesian MRI reconstruction. If passed, the MRI linear operator will include sampling density compensation. If `None`, the MRI - operator will not perform sampling density compensation. + operator will not perform sampling density compensation. Providing + `density` may speed up convergence but results in suboptimal SNR. sensitivities: An optional `Tensor` of type `complex64` or `complex128`. The coil sensitivity maps. Must have shape `[..., num_coils, *image_shape]`. If provided, a multi-coil parallel diff --git a/tensorflow_mri/python/ops/recon_ops_test.py b/tensorflow_mri/python/ops/recon_ops_test.py index d4308d94..8533bcf9 100755 --- a/tensorflow_mri/python/ops/recon_ops_test.py +++ b/tensorflow_mri/python/ops/recon_ops_test.py @@ -39,65 +39,6 @@ def setUpClass(cls): cls.data.update(io_util.read_hdf5('tests/data/recon_ops_data_2.h5')) cls.data.update(io_util.read_hdf5('tests/data/recon_ops_data_3.h5')) - def test_adj_fft(self): - """Test simple FFT recon.""" - kspace = self.data['fft/kspace'] - sens = self.data['fft/sens'] - image_shape = kspace.shape[-2:] - - # Test single-coil. - image = recon_ops.reconstruct_adj(kspace[0, ...], image_shape) - expected = fft_ops.ifftn(kspace[0, ...], norm='ortho', shift=True) - - self.assertAllClose(expected, image) - - # Test multi-coil. - image = recon_ops.reconstruct_adj(kspace, image_shape, sensitivities=sens) - expected = fft_ops.ifftn(kspace, axes=[-2, -1], norm='ortho', shift=True) - scale = tf.math.reduce_sum(sens * tf.math.conj(sens), axis=0) - expected = tf.math.divide_no_nan( - tf.math.reduce_sum(expected * tf.math.conj(sens), axis=0), scale) - - self.assertAllClose(expected, image) - - def test_adj_nufft(self): - """Test simple NUFFT recon.""" - kspace = self.data['nufft/kspace'] - sens = self.data['nufft/sens'] - traj = self.data['nufft/traj'] - dens = self.data['nufft/dens'] - image_shape = [144, 144] - fft_norm_factor = tf.cast(tf.math.sqrt(144. * 144.), tf.complex64) - - # Save us some typing. - inufft = lambda src, pts: tfft.nufft(src, pts, - grid_shape=[144, 144], - transform_type='type_1', - fft_direction='backward') - - # Test single-coil. - image = recon_ops.reconstruct_adj(kspace[0, ...], image_shape, - trajectory=traj, - density=dens) - - expected = inufft(kspace[0, ...] / tf.cast(dens, tf.complex64), traj) - expected /= fft_norm_factor - - self.assertAllClose(expected, image) - - # Test multi-coil. - image = recon_ops.reconstruct_adj(kspace, image_shape, - trajectory=traj, - density=dens, - sensitivities=sens) - expected = inufft(kspace / dens, traj) - expected /= fft_norm_factor - scale = tf.math.reduce_sum(sens * tf.math.conj(sens), axis=0) - expected = tf.math.divide_no_nan( - tf.math.reduce_sum(expected * tf.math.conj(sens), axis=0), scale) - - self.assertAllClose(expected, image) - @test_util.run_in_graph_and_eager_modes def test_inufft_2d(self): """Test inverse NUFFT method with 2D phantom.""" diff --git a/tensorflow_mri/python/recon/__init__.py b/tensorflow_mri/python/recon/__init__.py new file mode 100644 index 00000000..e26ed684 --- /dev/null +++ b/tensorflow_mri/python/recon/__init__.py @@ -0,0 +1,18 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Image reconstruction.""" + +from tensorflow_mri.python.recon import recon_adjoint +from tensorflow_mri.python.recon import recon_least_squares diff --git a/tensorflow_mri/python/recon/recon_adjoint.py b/tensorflow_mri/python/recon/recon_adjoint.py new file mode 100644 index 00000000..14f183dc --- /dev/null +++ b/tensorflow_mri/python/recon/recon_adjoint.py @@ -0,0 +1,133 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Signal reconstruction (adjoint).""" + +import tensorflow as tf + +from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.linalg import linear_operator_mri + + +@api_util.export("recon.custom_adjoint") +def recon_adjoint(data, operator): + r"""Reconstructs a signal using the adjoint of the system operator. + + Given measurement data :math:`b` generated by a linear system :math:`A` such + that :math:`Ax = b`, this function estimates the corresponding signal + :math:`x` as :math:`x = A^H b`, where :math:`A` is the specified linear + operator. + + Args: + data: A `tf.Tensor` of real or complex dtype. The measured data. + operator: A `tfmri.linalg.LinearOperator` representing the system operator. + + Returns: + A `tf.Tensor` with the same dtype as `data`. The reconstructed signal. + """ + data = tf.convert_to_tensor(data) + data = operator.preprocess(data, adjoint=True) + signal = operator.transform(data, adjoint=True) + signal = operator.postprocess(signal, adjoint=True) + return signal + + +@api_util.export("recon.adjoint", "recon.adj") +def recon_adjoint_mri(kspace, + image_shape, + mask=None, + trajectory=None, + density=None, + sensitivities=None, + phase=None, + sens_norm=True): + r"""Reconstructs an MR image using the adjoint MRI operator. + + Given *k*-space data :math:`b`, this function estimates the corresponding + image as :math:`x = A^H b`, where :math:`A` is the MRI linear operator. + + This operator supports Cartesian and non-Cartesian *k*-space data. + + Additional density compensation and intensity correction steps are applied + depending on the input arguments. + + This operator supports batched inputs. All batch shapes should be + broadcastable with each other. + + This operator supports multicoil imaging. Coil combination is triggered + when `sensitivities` is not `None`. If you have multiple coils but wish to + reconstruct each coil separately, simply set `sensitivities` to `None`. The + coil dimension will then be treated as a standard batch dimension (i.e., it + becomes part of `...`). + + Args: + kspace: A `tf.Tensor`. The *k*-space samples. Must have type `complex64` or + `complex128`. `kspace` can be either Cartesian or non-Cartesian. A + Cartesian `kspace` must have shape + `[..., num_coils, *image_shape]`, where `...` are batch dimensions. A + non-Cartesian `kspace` must have shape `[..., num_coils, num_samples]`. + If not multicoil (`sensitivities` is `None`), then the `num_coils` axis + must be omitted. + image_shape: A 1D integer `tf.Tensor`. Must have length 2 or 3. + The shape of the reconstructed image[s]. + mask: An optional `tf.Tensor` of type `bool`. The sampling mask. Must have + shape `[..., *image_shape]`. `mask` should be passed for reconstruction + from undersampled Cartesian *k*-space. For each point, `mask` should be + `True` if the corresponding *k*-space sample was measured and `False` + otherwise. + trajectory: An optional `tf.Tensor` of type `float32` or `float64`. Must + have shape `[..., num_samples, rank]`. `trajectory` should be passed for + reconstruction from non-Cartesian *k*-space. + density: An optional `tf.Tensor` of type `float32` or `float64`. The + sampling densities. Must have shape `[..., num_samples]`. This input is + only relevant for non-Cartesian MRI reconstruction. If passed, the MRI + linear operator will include sampling density compensation. If `None`, + the MRI operator will not perform sampling density compensation. + sensitivities: An optional `tf.Tensor` of type `complex64` or `complex128`. + The coil sensitivity maps. Must have shape + `[..., num_coils, *image_shape]`. If provided, a multi-coil parallel + imaging reconstruction will be performed. + phase: An optional `tf.Tensor` of type `float32` or `float64`. Must have + shape `[..., *image_shape]`. A phase estimate for the reconstructed image. + If provided, a phase-constrained reconstruction will be performed. This + improves the conditioning of the reconstruction problem in applications + where there is no interest in the phase data. However, artefacts may + appear if an inaccurate phase estimate is passed. + sens_norm: A `boolean`. Whether to normalize coil sensitivities. + Defaults to `True`. + + Returns: + A `tf.Tensor`. The reconstructed image. Has the same type as `kspace` and + shape `[..., *image_shape]`, where `...` is the broadcasted batch shape of + all inputs. + + Notes: + Reconstructs an image by applying the adjoint MRI operator to the *k*-space + data. This typically involves an inverse FFT or a (density-compensated) + NUFFT, and coil combination for multicoil inputs. This type of + reconstruction is often called zero-filled reconstruction, because missing + *k*-space samples are assumed to be zero. Therefore, the resulting image is + likely to display aliasing artefacts if *k*-space is not sufficiently + sampled according to the Nyquist criterion. + """ + # Create the linear operator. + operator = linear_operator_mri.LinearOperatorMRI(image_shape, + mask=mask, + trajectory=trajectory, + density=density, + sensitivities=sensitivities, + phase=phase, + fft_norm='ortho', + sens_norm=sens_norm) + return adjoint(kspace, operator) diff --git a/tensorflow_mri/python/recon/recon_adjoint_test.py b/tensorflow_mri/python/recon/recon_adjoint_test.py new file mode 100644 index 00000000..dfb55cf1 --- /dev/null +++ b/tensorflow_mri/python/recon/recon_adjoint_test.py @@ -0,0 +1,93 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Signal reconstruction (adjoint).""" + +import tensorflow as tf +import tensorflow_nufft as tfft + +from tensorflow_mri.python.ops import fft_ops +from tensorflow_mri.python.recon import recon_adjoint +from tensorflow_mri.python.util import io_util +from tensorflow_mri.python.util import test_util + + +class ReconAdjointTest(test_util.TestCase): + """Tests for reconstruction functions.""" + @classmethod + def setUpClass(cls): + """Prepare tests.""" + super().setUpClass() + cls.data = io_util.read_hdf5('tests/data/recon_ops_data.h5') + cls.data.update(io_util.read_hdf5('tests/data/recon_ops_data_2.h5')) + cls.data.update(io_util.read_hdf5('tests/data/recon_ops_data_3.h5')) + + def test_adj_fft(self): + """Test simple FFT recon.""" + kspace = self.data['fft/kspace'] + sens = self.data['fft/sens'] + image_shape = kspace.shape[-2:] + + # Test single-coil. + image = recon_adjoint.recon_adjoint_mri(kspace[0, ...], image_shape) + expected = fft_ops.ifftn(kspace[0, ...], norm='ortho', shift=True) + + self.assertAllClose(expected, image) + + # Test multi-coil. + image = recon_adjoint.recon_adjoint_mri(kspace, image_shape, sensitivities=sens) + expected = fft_ops.ifftn(kspace, axes=[-2, -1], norm='ortho', shift=True) + scale = tf.math.reduce_sum(sens * tf.math.conj(sens), axis=0) + expected = tf.math.divide_no_nan( + tf.math.reduce_sum(expected * tf.math.conj(sens), axis=0), scale) + + self.assertAllClose(expected, image) + + def test_adj_nufft(self): + """Test simple NUFFT recon.""" + kspace = self.data['nufft/kspace'] + sens = self.data['nufft/sens'] + traj = self.data['nufft/traj'] + dens = self.data['nufft/dens'] + image_shape = [144, 144] + fft_norm_factor = tf.cast(tf.math.sqrt(144. * 144.), tf.complex64) + + # Save us some typing. + inufft = lambda src, pts: tfft.nufft(src, pts, + grid_shape=[144, 144], + transform_type='type_1', + fft_direction='backward') + + # Test single-coil. + image = recon_adjoint.recon_adjoint_mri(kspace[0, ...], image_shape, + trajectory=traj, + density=dens) + + expected = inufft(kspace[0, ...] / tf.cast(dens, tf.complex64), traj) + expected /= fft_norm_factor + + self.assertAllClose(expected, image) + + # Test multi-coil. + image = recon_adjoint.recon_adjoint_mri(kspace, image_shape, + trajectory=traj, + density=dens, + sensitivities=sens) + expected = inufft(kspace / dens, traj) + expected /= fft_norm_factor + scale = tf.math.reduce_sum(sens * tf.math.conj(sens), axis=0) + expected = tf.math.divide_no_nan( + tf.math.reduce_sum(expected * tf.math.conj(sens), axis=0), scale) + + self.assertAllClose(expected, image) diff --git a/tensorflow_mri/python/recon/recon_least_squares.py b/tensorflow_mri/python/recon/recon_least_squares.py new file mode 100644 index 00000000..c031d795 --- /dev/null +++ b/tensorflow_mri/python/recon/recon_least_squares.py @@ -0,0 +1,15 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Signal reconstruction (least squares).""" diff --git a/tensorflow_mri/python/util/api_util.py b/tensorflow_mri/python/util/api_util.py index c75afbf1..997b9c54 100644 --- a/tensorflow_mri/python/util/api_util.py +++ b/tensorflow_mri/python/util/api_util.py @@ -62,7 +62,7 @@ 'models': "Keras models.", 'optimize': "Optimization operations.", 'plot': "Plotting utilities.", - 'recon': "Image reconstruction.", + 'recon': "Signal reconstruction.", 'sampling': "k-space sampling operations.", 'signal': "Signal processing operations.", 'summary': "Tensorboard summaries." diff --git a/tools/docs/tutorials/recon/unet_fastmri.ipynb b/tools/docs/tutorials/recon/unet_fastmri.ipynb index 43b8e3b6..52f817cb 100644 --- a/tools/docs/tutorials/recon/unet_fastmri.ipynb +++ b/tools/docs/tutorials/recon/unet_fastmri.ipynb @@ -9,17 +9,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2022-08-04 10:26:12.163495: I tensorflow/core/util/util.cc:169] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n" - ] - } - ], + "outputs": [], "source": [ "import functools\n", "import itertools\n", @@ -34,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -44,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -58,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -69,7 +61,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -128,18 +120,18 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "2022-08-04 10:26:24.364863: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 AVX512F AVX512_VNNI FMA\n", + "2022-08-05 10:46:04.414626: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 AVX512F AVX512_VNNI FMA\n", "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", - "2022-08-04 10:26:25.275846: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1532] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 22290 MB memory: -> device: 0, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:65:00.0, compute capability: 8.6\n", - "2022-08-04 10:26:25.276331: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1532] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 22304 MB memory: -> device: 1, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:b3:00.0, compute capability: 8.6\n", - "2022-08-04 10:26:25.554843: I tensorflow_io/core/kernels/cpu_check.cc:128] Your CPU supports instructions that this TensorFlow IO binary was not compiled to use: AVX2 AVX512F FMA\n" + "2022-08-05 10:46:05.491923: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1532] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 22290 MB memory: -> device: 0, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:65:00.0, compute capability: 8.6\n", + "2022-08-05 10:46:05.493531: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1532] Created device /job:localhost/replica:0/task:0/device:GPU:1 with 22304 MB memory: -> device: 1, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:b3:00.0, compute capability: 8.6\n", + "2022-08-05 10:46:05.767432: I tensorflow_io/core/kernels/cpu_check.cc:128] Your CPU supports instructions that this TensorFlow IO binary was not compiled to use: AVX2 AVX512F FMA\n" ] } ], @@ -151,7 +143,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -161,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -198,7 +190,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -240,16 +232,16 @@ " sensitivities = tfmri.coils.estimate_sensitivities(filt_image, coil_axis=-3)\n", " return sensitivities\n", "\n", - "def scale_kspace(kspace, operator):\n", + "def scale_kspace(kspace):\n", " filt_kspace = filter_kspace_lowpass(kspace)\n", - " filt_image = operator.transform(filt_kspace)\n", + " filt_image = reconstruct_zerofilled(filt_kspace)\n", " scale = tf.math.reduce_max(tf.math.abs(filt_image))\n", " return kspace / tf.cast(scale, kspace.dtype)" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -287,7 +279,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -308,7 +300,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -332,7 +324,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -343,11 +335,11 @@ " return result\n", " return tfmri.signal.filter_kspace(kspace, filter_fn=box, filter_rank=1)\n", "\n", - "def scale_kspace(kspace, operator):\n", - " filt_kspace = filter_kspace_lowpass(kspace)\n", - " filt_image = operator.transform(filt_kspace, adjoint=True)\n", - " scale = tf.math.reduce_max(tf.math.abs(filt_image))\n", - " return kspace / tf.cast(scale, kspace.dtype)\n", + "# def scale_kspace(kspace, operator):\n", + "# filt_kspace = filter_kspace_lowpass(kspace)\n", + "# filt_image = operator.transform(filt_kspace, adjoint=True)\n", + "# scale = tf.math.reduce_max(tf.math.abs(filt_image))\n", + "# return kspace / tf.cast(scale, kspace.dtype)\n", "\n", "\n", "\n", @@ -381,12 +373,17 @@ "\n", " def call(self, inputs):\n", " main, args, kwargs = self.parse_inputs(inputs)\n", - " operator = self.get_operator(inputs)\n", - " kspace = scale_kspace(main[self.kspace_index], operator)\n", + " kspace = self.scale_kspace(main[self.kspace_index], *args, **kwargs)\n", " if self.passthrough:\n", " return {self.kspace_index: kspace, **kwargs}\n", " return kspace\n", "\n", + " def scale_kspace(self, kspace, *args, **kwargs):\n", + " filt_kspace = filter_kspace_lowpass(kspace)\n", + " filt_image = tfmri.recon.adjoint(filt_kspace, *args, **kwargs)\n", + " scale = tf.math.reduce_max(tf.math.abs(filt_image))\n", + " return kspace / tf.cast(scale, kspace.dtype)\n", + "\n", "\n", "class CoilSensitivities(LinearOperatorLayer):\n", " def __init__(self,\n", @@ -433,66 +430,41 @@ " def call(self, inputs):\n", " main, args, kwargs = self.parse_inputs(inputs)\n", " image = tfmri.recon.adjoint(main[self.kspace_index], *args, **kwargs)\n", + " image = tf.expand_dims(image, -1)\n", " if self.passthrough:\n", " return {self.kspace_index: main[self.kspace_index], **kwargs,\n", " self.image_index: image}\n", - " return image" + " return image\n" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 33, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: \"model_1\"\n", - "__________________________________________________________________________________________________\n", - " Layer (type) Output Shape Param # Connected to \n", - "==================================================================================================\n", - " kspace (InputLayer) [(None, None, 320, 0 [] \n", - " 320)] \n", - " \n", - " mask (InputLayer) [(None, 320, 320)] 0 [] \n", - " \n", - " zfill (AdjointRecon) (None, 320, 320, 1) 0 ['kspace[0][0]', \n", - " 'mask[0][0]'] \n", - " \n", - " image (UNet2D) (None, 320, 320, 1) 471233 ['zfill[0][0]'] \n", - " \n", - "==================================================================================================\n", - "Total params: 471,233\n", - "Trainable params: 471,233\n", - "Non-trainable params: 0\n", - "__________________________________________________________________________________________________\n" - ] - } - ], + "outputs": [], "source": [ - "def BaselineUNet(inputs):\n", - " zfill = AdjointRecon(magnitude_only=True, name='zfill')(inputs)\n", - " image = tfmri.models.UNet2D(\n", - " filters=[32, 64, 128],\n", - " kernel_size=3,\n", - " out_channels=1,\n", - " name='image')(zfill)\n", - " outputs = {'zfill': zfill, 'image': image}\n", - " return tf.keras.Model(inputs=inputs, outputs=outputs)\n", - "\n", - "model = BaselineUNet(inputs)\n", - "\n", - "model.compile(optimizer='adam',\n", - " loss='mse',\n", - " metrics=[tfmri.metrics.PSNR(), tfmri.metrics.SSIM()])\n", - "\n", - "model.summary()" + "# def BaselineUNet(inputs):\n", + "# zfill = AdjointRecon(magnitude_only=True, name='zfill')(inputs)\n", + "# image = tfmri.models.UNet2D(\n", + "# filters=[32, 64, 128],\n", + "# kernel_size=3,\n", + "# out_channels=1,\n", + "# name='image')(zfill)\n", + "# outputs = {'zfill': zfill, 'image': image}\n", + "# return tf.keras.Model(inputs=inputs, outputs=outputs)\n", + "\n", + "# model = BaselineUNet(inputs)\n", + "\n", + "# model.compile(optimizer='adam',\n", + "# loss='mse',\n", + "# metrics=[tfmri.metrics.PSNR(), tfmri.metrics.SSIM()])\n", + "\n", + "# model.summary()" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -501,122 +473,65 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 35, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2022-08-04 10:26:54.172315: I tensorflow/stream_executor/cuda/cuda_dnn.cc:384] Loaded cuDNN version 8101\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "30/30 [==============================] - 14s 207ms/step\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2022-08-04 10:27:00.899676: W tensorflow/core/kernels/data/cache_dataset_ops.cc:856] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.\n" - ] - } - ], + "outputs": [], "source": [ - "preds = model.predict(ds_train.take(30))" + "# preds = model.predict(ds_train.take(30))" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 36, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "show_examples(preds['image'], lambda x: np.abs(x), n=16)" + "# show_examples(preds['image'], lambda x: np.abs(x), n=16)" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 39, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "iteration 0\n", - "x.shape: (None, 320, 320, 1), b.shape: (None, None, 320, 320)\n", - "reg: (None, 320, 320, 1)\n", - "(None, 320, 320) (320, 320) (320, 320)\n", - "lsgd: (None, None, 320, 320, 1)\n", - "iteration 1\n", - "x.shape: (None, None, 320, 320, 1), b.shape: (None, None, 320, 320)\n" - ] - }, - { - "ename": "ValueError", - "evalue": "Exception encountered when calling layer \"reg\" (type UNet2D).\n\nin user code:\n\n File \"/workspaces/tensorflow-mri/tensorflow_mri/python/models/conv_endec.py\", line 273, in call *\n x = self._pools[scale](cache[scale])\n File \"/usr/local/lib/python3.8/site-packages/keras/utils/traceback_utils.py\", line 67, in error_handler **\n raise e.with_traceback(filtered_tb) from None\n File \"/usr/local/lib/python3.8/site-packages/keras/engine/input_spec.py\", line 214, in assert_input_compatibility\n raise ValueError(f'Input {input_index} of layer \"{layer_name}\" '\n\n ValueError: Input 0 of layer \"max_pooling2d_8\" is incompatible with the layer: expected ndim=4, found ndim=5. Full shape received: (None, None, 320, 320, 32)\n\n\nCall arguments received by layer \"reg\" (type UNet2D):\n • inputs=tf.Tensor(shape=(None, None, 320, 320, 1), dtype=complex64)\n • training=None", + "ename": "SyntaxError", + "evalue": "invalid syntax (892461145.py, line 21)", "output_type": "error", "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/workspaces/tensorflow-mri/tools/docs/tutorials/recon/unet_fastmri.ipynb Cell 19\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 27\u001b[0m outputs \u001b[39m=\u001b[39m {\u001b[39m'\u001b[39m\u001b[39mzfill\u001b[39m\u001b[39m'\u001b[39m: zfill, \u001b[39m'\u001b[39m\u001b[39mimage\u001b[39m\u001b[39m'\u001b[39m: x}\n\u001b[1;32m 28\u001b[0m \u001b[39mreturn\u001b[39;00m tf\u001b[39m.\u001b[39mkeras\u001b[39m.\u001b[39mModel(inputs\u001b[39m=\u001b[39minputs, outputs\u001b[39m=\u001b[39moutputs)\n\u001b[0;32m---> 30\u001b[0m model \u001b[39m=\u001b[39m VarNet(inputs)\n\u001b[1;32m 32\u001b[0m model\u001b[39m.\u001b[39mcompile(optimizer\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39madam\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 33\u001b[0m loss\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mmse\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 34\u001b[0m metrics\u001b[39m=\u001b[39m[tfmri\u001b[39m.\u001b[39mmetrics\u001b[39m.\u001b[39mPSNR(), tfmri\u001b[39m.\u001b[39mmetrics\u001b[39m.\u001b[39mSSIM()])\n\u001b[1;32m 36\u001b[0m model\u001b[39m.\u001b[39msummary()\n", - "\u001b[1;32m/workspaces/tensorflow-mri/tools/docs/tutorials/recon/unet_fastmri.ipynb Cell 19\u001b[0m in \u001b[0;36mVarNet\u001b[0;34m(inputs, num_iterations)\u001b[0m\n\u001b[1;32m 17\u001b[0m b \u001b[39m=\u001b[39m inputs[\u001b[39m'\u001b[39m\u001b[39mkspace\u001b[39m\u001b[39m'\u001b[39m]\n\u001b[1;32m 18\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mx.shape: \u001b[39m\u001b[39m{\u001b[39;00mx\u001b[39m.\u001b[39mshape\u001b[39m}\u001b[39;00m\u001b[39m, b.shape: \u001b[39m\u001b[39m{\u001b[39;00mb\u001b[39m.\u001b[39mshape\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m)\n\u001b[0;32m---> 19\u001b[0m x \u001b[39m=\u001b[39m reg(x)\n\u001b[1;32m 20\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mreg: \u001b[39m\u001b[39m{\u001b[39;00mx\u001b[39m.\u001b[39mshape\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 21\u001b[0m x \u001b[39m=\u001b[39m lsgd({\u001b[39m'\u001b[39m\u001b[39mx\u001b[39m\u001b[39m'\u001b[39m: x,\n\u001b[1;32m 22\u001b[0m \u001b[39m'\u001b[39m\u001b[39mb\u001b[39m\u001b[39m'\u001b[39m: inputs[\u001b[39m'\u001b[39m\u001b[39mkspace\u001b[39m\u001b[39m'\u001b[39m],\n\u001b[1;32m 23\u001b[0m \u001b[39m'\u001b[39m\u001b[39mimage_shape\u001b[39m\u001b[39m'\u001b[39m: tf\u001b[39m.\u001b[39mshape(inputs[\u001b[39m'\u001b[39m\u001b[39mkspace\u001b[39m\u001b[39m'\u001b[39m])[\u001b[39m-\u001b[39m\u001b[39m2\u001b[39m:],\n\u001b[1;32m 24\u001b[0m \u001b[39m'\u001b[39m\u001b[39mmask\u001b[39m\u001b[39m'\u001b[39m: inputs[\u001b[39m'\u001b[39m\u001b[39mmask\u001b[39m\u001b[39m'\u001b[39m]})\n", - "File \u001b[0;32m/usr/local/lib/python3.8/site-packages/keras/utils/traceback_utils.py:67\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 65\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e: \u001b[39m# pylint: disable=broad-except\u001b[39;00m\n\u001b[1;32m 66\u001b[0m filtered_tb \u001b[39m=\u001b[39m _process_traceback_frames(e\u001b[39m.\u001b[39m__traceback__)\n\u001b[0;32m---> 67\u001b[0m \u001b[39mraise\u001b[39;00m e\u001b[39m.\u001b[39mwith_traceback(filtered_tb) \u001b[39mfrom\u001b[39;00m \u001b[39mNone\u001b[39m\n\u001b[1;32m 68\u001b[0m \u001b[39mfinally\u001b[39;00m:\n\u001b[1;32m 69\u001b[0m \u001b[39mdel\u001b[39;00m filtered_tb\n", - "File \u001b[0;32m/tmp/__autograph_generated_file_8jwn45w.py:61\u001b[0m, in \u001b[0;36mouter_factory..inner_factory..tf__call\u001b[0;34m(self, inputs, training)\u001b[0m\n\u001b[1;32m 59\u001b[0m ag__\u001b[39m.\u001b[39mif_stmt(ag__\u001b[39m.\u001b[39mld(\u001b[39mself\u001b[39m)\u001b[39m.\u001b[39m_use_tight_frame, if_body_1, else_body_1, get_state_1, set_state_1, (\u001b[39m'\u001b[39m\u001b[39mdetail_cache[scale]\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39mx\u001b[39m\u001b[39m'\u001b[39m), \u001b[39m2\u001b[39m)\n\u001b[1;32m 60\u001b[0m scale \u001b[39m=\u001b[39m ag__\u001b[39m.\u001b[39mUndefined(\u001b[39m'\u001b[39m\u001b[39mscale\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m---> 61\u001b[0m ag__\u001b[39m.\u001b[39mfor_stmt(ag__\u001b[39m.\u001b[39mconverted_call(ag__\u001b[39m.\u001b[39mld(\u001b[39mrange\u001b[39m), ((ag__\u001b[39m.\u001b[39mld(\u001b[39mself\u001b[39m)\u001b[39m.\u001b[39m_scales \u001b[39m-\u001b[39m \u001b[39m1\u001b[39m),), \u001b[39mNone\u001b[39;00m, fscope), \u001b[39mNone\u001b[39;00m, loop_body, get_state_2, set_state_2, (\u001b[39m'\u001b[39m\u001b[39mx\u001b[39m\u001b[39m'\u001b[39m,), {\u001b[39m'\u001b[39m\u001b[39miterate_names\u001b[39m\u001b[39m'\u001b[39m: \u001b[39m'\u001b[39m\u001b[39mscale\u001b[39m\u001b[39m'\u001b[39m})\n\u001b[1;32m 62\u001b[0m x \u001b[39m=\u001b[39m ag__\u001b[39m.\u001b[39mconverted_call(ag__\u001b[39m.\u001b[39mld(\u001b[39mself\u001b[39m)\u001b[39m.\u001b[39m_enc_blocks[(\u001b[39m-\u001b[39m \u001b[39m1\u001b[39m)], (ag__\u001b[39m.\u001b[39mld(x),), \u001b[39mNone\u001b[39;00m, fscope)\n\u001b[1;32m 64\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_state_4\u001b[39m():\n", - "File \u001b[0;32m/tmp/__autograph_generated_file_8jwn45w.py:42\u001b[0m, in \u001b[0;36mouter_factory..inner_factory..tf__call..loop_body\u001b[0;34m(itr)\u001b[0m\n\u001b[1;32m 40\u001b[0m scale \u001b[39m=\u001b[39m itr\n\u001b[1;32m 41\u001b[0m ag__\u001b[39m.\u001b[39mld(cache)[ag__\u001b[39m.\u001b[39mld(scale)] \u001b[39m=\u001b[39m ag__\u001b[39m.\u001b[39mconverted_call(ag__\u001b[39m.\u001b[39mld(\u001b[39mself\u001b[39m)\u001b[39m.\u001b[39m_enc_blocks[ag__\u001b[39m.\u001b[39mld(scale)], (ag__\u001b[39m.\u001b[39mld(x),), \u001b[39mNone\u001b[39;00m, fscope)\n\u001b[0;32m---> 42\u001b[0m x \u001b[39m=\u001b[39m ag__\u001b[39m.\u001b[39;49mconverted_call(ag__\u001b[39m.\u001b[39;49mld(\u001b[39mself\u001b[39;49m)\u001b[39m.\u001b[39;49m_pools[ag__\u001b[39m.\u001b[39;49mld(scale)], (ag__\u001b[39m.\u001b[39;49mld(cache)[ag__\u001b[39m.\u001b[39;49mld(scale)],), \u001b[39mNone\u001b[39;49;00m, fscope)\n\u001b[1;32m 44\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_state_1\u001b[39m():\n\u001b[1;32m 45\u001b[0m \u001b[39mreturn\u001b[39;00m (ag__\u001b[39m.\u001b[39mldu((\u001b[39mlambda\u001b[39;00m : detail_cache[scale]), \u001b[39m'\u001b[39m\u001b[39mdetail_cache[scale]\u001b[39m\u001b[39m'\u001b[39m), x)\n", - "\u001b[0;31mValueError\u001b[0m: Exception encountered when calling layer \"reg\" (type UNet2D).\n\nin user code:\n\n File \"/workspaces/tensorflow-mri/tensorflow_mri/python/models/conv_endec.py\", line 273, in call *\n x = self._pools[scale](cache[scale])\n File \"/usr/local/lib/python3.8/site-packages/keras/utils/traceback_utils.py\", line 67, in error_handler **\n raise e.with_traceback(filtered_tb) from None\n File \"/usr/local/lib/python3.8/site-packages/keras/engine/input_spec.py\", line 214, in assert_input_compatibility\n raise ValueError(f'Input {input_index} of layer \"{layer_name}\" '\n\n ValueError: Input 0 of layer \"max_pooling2d_8\" is incompatible with the layer: expected ndim=4, found ndim=5. Full shape received: (None, None, 320, 320, 32)\n\n\nCall arguments received by layer \"reg\" (type UNet2D):\n • inputs=tf.Tensor(shape=(None, None, 320, 320, 1), dtype=complex64)\n • training=None" + "\u001b[0;36m Input \u001b[0;32mIn [39]\u001b[0;36m\u001b[0m\n\u001b[0;31m name=f'reg_{i}')(image)\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" ] } ], "source": [ "def VarNet(inputs, num_iterations=5):\n", - " x = inputs\n", - " x = CoilSensitivities(passthrough=True)(x)\n", - " x = KSpaceScaling(passthrough=True)(x)\n", - " zfill = ReconAdjoint(name='zfill')(x)\n", - "\n", - " lsgd = tfmri.layers.LeastSquaresGradientDescent(\n", - " operator=tfmri.linalg.LinearOperatorMRI, dtype=tf.complex64)\n", - " reg = tfmri.models.UNet2D(\n", - " filters=[32, 64, 128],\n", - " kernel_size=3,\n", - " activation=tfmri.activations.complex_relu,\n", - " out_channels=1,\n", - " dtype=tf.complex64,\n", - " name='reg')\n", + " kspace = inputs['kspace']\n", + " kwargs = {k: inputs[k] for k in inputs.keys() if k != 'kspace'}\n", + "\n", + " if 'image_shape' not in kwargs:\n", + " kwargs['image_shape'] = tf.shape(kspace)[-2:]\n", "\n", + " kspace = KSpaceScaling()({'kspace': kspace, **kwargs})\n", + " kwargs['sensitivities'] = CoilSensitivities()({'kspace': kspace, **kwargs})\n", + "\n", + " zfill = ReconAdjoint()({'kspace': kspace, **kwargs})\n", + "\n", + " image = zfill\n", " for i in range(num_iterations):\n", - " print(f\"iteration {i}\")\n", - " b = inputs['kspace']\n", - " print(f\"x.shape: {x.shape}, b.shape: {b.shape}\")\n", - " x = reg(x)\n", - " print(f\"reg: {x.shape}\")\n", - " x = lsgd({'x': x,\n", - " 'b': x['kspace'],\n", - " 'image_shape': tf.shape(x['kspace'])[-2:],\n", - " 'mask': x['mask'],\n", - " 'sensitivities': x['sensitivities']})\n", - " print(f\"lsgd: {x.shape}\")\n", - "\n", - " outputs = {'zfill': zfill, 'image': x}\n", + " image = tfmri.models.UNet2D(\n", + " filters=[32, 64, 128],\n", + " kernel_size=3,\n", + " activation=tfmri.activations.complex_relu,\n", + " out_channels=1,\n", + " dtype=tf.complex64,\n", + " name=f'reg_{i}')(image)\n", + " image = tfmri.layers.LeastSquaresGradientDescent(\n", + " operator=tfmri.linalg.LinearOperatorMRI,\n", + " dtype=tf.complex64,\n", + " name=f'lsgd_{i}')(\n", + " {'x': image, 'b': kspace, **kwargs})\n", + "\n", + " outputs = {'zfill': zfill, 'image': image}\n", " return tf.keras.Model(inputs=inputs, outputs=outputs)\n", "\n", "model = VarNet(inputs)\n", @@ -628,6 +543,67 @@ "model.summary()" ] }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n", + "(None, 320, 320) (None, None) (None, None, None)\n", + "(None, 320, 320) (None, None) (None, None, None)\n", + "(None, 320, 320) (None, None) (None, None, None)\n", + "(None, 320, 320) (None, None) (None, None, None)\n", + "(None, 320, 320) (None, None) (None, None, None)\n", + "(None, 320, 320) (None, None) (None, None, None)\n", + "(None, 320, 320) (None, None) (None, None, None)\n", + "(None, 320, 320) (None, None) (None, None, None)\n", + "(None, 320, 320) (None, None) (None, None, None)\n", + "(None, 320, 320) (None, None) (None, None, None)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2022-08-05 11:07:45.069637: I tensorflow/stream_executor/cuda/cuda_dnn.cc:384] Loaded cuDNN version 8101\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 76/Unknown - 89s 801ms/step - loss: 0.5787 - least_squares_gradient_descent_10_loss: 0.2163 - recon_adjoint_2_loss: 0.3624 - least_squares_gradient_descent_10_psnr: 10.0989 - least_squares_gradient_descent_10_ssim: 0.1636 - recon_adjoint_2_psnr: 6.0361 - recon_adjoint_2_ssim: 0.1031" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/workspaces/tensorflow-mri/tools/docs/tutorials/recon/unet_fastmri.ipynb Cell 20\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m model\u001b[39m.\u001b[39;49mfit(ds_train, epochs\u001b[39m=\u001b[39;49m\u001b[39m10\u001b[39;49m, validation_data\u001b[39m=\u001b[39;49mds_val)\n", + "File \u001b[0;32m/usr/local/lib/python3.8/site-packages/keras/utils/traceback_utils.py:64\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 62\u001b[0m filtered_tb \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m 63\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m---> 64\u001b[0m \u001b[39mreturn\u001b[39;00m fn(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 65\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e: \u001b[39m# pylint: disable=broad-except\u001b[39;00m\n\u001b[1;32m 66\u001b[0m filtered_tb \u001b[39m=\u001b[39m _process_traceback_frames(e\u001b[39m.\u001b[39m__traceback__)\n", + "File \u001b[0;32m/usr/local/lib/python3.8/site-packages/keras/engine/training.py:1409\u001b[0m, in \u001b[0;36mModel.fit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[1;32m 1402\u001b[0m \u001b[39mwith\u001b[39;00m tf\u001b[39m.\u001b[39mprofiler\u001b[39m.\u001b[39mexperimental\u001b[39m.\u001b[39mTrace(\n\u001b[1;32m 1403\u001b[0m \u001b[39m'\u001b[39m\u001b[39mtrain\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 1404\u001b[0m epoch_num\u001b[39m=\u001b[39mepoch,\n\u001b[1;32m 1405\u001b[0m step_num\u001b[39m=\u001b[39mstep,\n\u001b[1;32m 1406\u001b[0m batch_size\u001b[39m=\u001b[39mbatch_size,\n\u001b[1;32m 1407\u001b[0m _r\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m):\n\u001b[1;32m 1408\u001b[0m callbacks\u001b[39m.\u001b[39mon_train_batch_begin(step)\n\u001b[0;32m-> 1409\u001b[0m tmp_logs \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mtrain_function(iterator)\n\u001b[1;32m 1410\u001b[0m \u001b[39mif\u001b[39;00m data_handler\u001b[39m.\u001b[39mshould_sync:\n\u001b[1;32m 1411\u001b[0m context\u001b[39m.\u001b[39masync_wait()\n", + "File \u001b[0;32m/usr/local/lib/python3.8/site-packages/tensorflow/python/util/traceback_utils.py:150\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 148\u001b[0m filtered_tb \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m 149\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 150\u001b[0m \u001b[39mreturn\u001b[39;00m fn(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 151\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n\u001b[1;32m 152\u001b[0m filtered_tb \u001b[39m=\u001b[39m _process_traceback_frames(e\u001b[39m.\u001b[39m__traceback__)\n", + "File \u001b[0;32m/usr/local/lib/python3.8/site-packages/tensorflow/python/eager/def_function.py:915\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 912\u001b[0m compiler \u001b[39m=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mxla\u001b[39m\u001b[39m\"\u001b[39m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_jit_compile \u001b[39melse\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39mnonXla\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 914\u001b[0m \u001b[39mwith\u001b[39;00m OptionalXlaContext(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_jit_compile):\n\u001b[0;32m--> 915\u001b[0m result \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_call(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwds)\n\u001b[1;32m 917\u001b[0m new_tracing_count \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mexperimental_get_tracing_count()\n\u001b[1;32m 918\u001b[0m without_tracing \u001b[39m=\u001b[39m (tracing_count \u001b[39m==\u001b[39m new_tracing_count)\n", + "File \u001b[0;32m/usr/local/lib/python3.8/site-packages/tensorflow/python/eager/def_function.py:947\u001b[0m, in \u001b[0;36mFunction._call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 944\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lock\u001b[39m.\u001b[39mrelease()\n\u001b[1;32m 945\u001b[0m \u001b[39m# In this case we have created variables on the first call, so we run the\u001b[39;00m\n\u001b[1;32m 946\u001b[0m \u001b[39m# defunned version which is guaranteed to never create variables.\u001b[39;00m\n\u001b[0;32m--> 947\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_stateless_fn(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwds) \u001b[39m# pylint: disable=not-callable\u001b[39;00m\n\u001b[1;32m 948\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_stateful_fn \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 949\u001b[0m \u001b[39m# Release the lock early so that multiple threads can perform the call\u001b[39;00m\n\u001b[1;32m 950\u001b[0m \u001b[39m# in parallel.\u001b[39;00m\n\u001b[1;32m 951\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lock\u001b[39m.\u001b[39mrelease()\n", + "File \u001b[0;32m/usr/local/lib/python3.8/site-packages/tensorflow/python/eager/function.py:2453\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2450\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lock:\n\u001b[1;32m 2451\u001b[0m (graph_function,\n\u001b[1;32m 2452\u001b[0m filtered_flat_args) \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_maybe_define_function(args, kwargs)\n\u001b[0;32m-> 2453\u001b[0m \u001b[39mreturn\u001b[39;00m graph_function\u001b[39m.\u001b[39;49m_call_flat(\n\u001b[1;32m 2454\u001b[0m filtered_flat_args, captured_inputs\u001b[39m=\u001b[39;49mgraph_function\u001b[39m.\u001b[39;49mcaptured_inputs)\n", + "File \u001b[0;32m/usr/local/lib/python3.8/site-packages/tensorflow/python/eager/function.py:1860\u001b[0m, in \u001b[0;36mConcreteFunction._call_flat\u001b[0;34m(self, args, captured_inputs, cancellation_manager)\u001b[0m\n\u001b[1;32m 1856\u001b[0m possible_gradient_type \u001b[39m=\u001b[39m gradients_util\u001b[39m.\u001b[39mPossibleTapeGradientTypes(args)\n\u001b[1;32m 1857\u001b[0m \u001b[39mif\u001b[39;00m (possible_gradient_type \u001b[39m==\u001b[39m gradients_util\u001b[39m.\u001b[39mPOSSIBLE_GRADIENT_TYPES_NONE\n\u001b[1;32m 1858\u001b[0m \u001b[39mand\u001b[39;00m executing_eagerly):\n\u001b[1;32m 1859\u001b[0m \u001b[39m# No tape is watching; skip to running the function.\u001b[39;00m\n\u001b[0;32m-> 1860\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_build_call_outputs(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_inference_function\u001b[39m.\u001b[39;49mcall(\n\u001b[1;32m 1861\u001b[0m ctx, args, cancellation_manager\u001b[39m=\u001b[39;49mcancellation_manager))\n\u001b[1;32m 1862\u001b[0m forward_backward \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_select_forward_and_backward_functions(\n\u001b[1;32m 1863\u001b[0m args,\n\u001b[1;32m 1864\u001b[0m possible_gradient_type,\n\u001b[1;32m 1865\u001b[0m executing_eagerly)\n\u001b[1;32m 1866\u001b[0m forward_function, args_with_tangents \u001b[39m=\u001b[39m forward_backward\u001b[39m.\u001b[39mforward()\n", + "File \u001b[0;32m/usr/local/lib/python3.8/site-packages/tensorflow/python/eager/function.py:497\u001b[0m, in \u001b[0;36m_EagerDefinedFunction.call\u001b[0;34m(self, ctx, args, cancellation_manager)\u001b[0m\n\u001b[1;32m 495\u001b[0m \u001b[39mwith\u001b[39;00m _InterpolateFunctionError(\u001b[39mself\u001b[39m):\n\u001b[1;32m 496\u001b[0m \u001b[39mif\u001b[39;00m cancellation_manager \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 497\u001b[0m outputs \u001b[39m=\u001b[39m execute\u001b[39m.\u001b[39;49mexecute(\n\u001b[1;32m 498\u001b[0m \u001b[39mstr\u001b[39;49m(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msignature\u001b[39m.\u001b[39;49mname),\n\u001b[1;32m 499\u001b[0m num_outputs\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_num_outputs,\n\u001b[1;32m 500\u001b[0m inputs\u001b[39m=\u001b[39;49margs,\n\u001b[1;32m 501\u001b[0m attrs\u001b[39m=\u001b[39;49mattrs,\n\u001b[1;32m 502\u001b[0m ctx\u001b[39m=\u001b[39;49mctx)\n\u001b[1;32m 503\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 504\u001b[0m outputs \u001b[39m=\u001b[39m execute\u001b[39m.\u001b[39mexecute_with_cancellation(\n\u001b[1;32m 505\u001b[0m \u001b[39mstr\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39msignature\u001b[39m.\u001b[39mname),\n\u001b[1;32m 506\u001b[0m num_outputs\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_num_outputs,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 509\u001b[0m ctx\u001b[39m=\u001b[39mctx,\n\u001b[1;32m 510\u001b[0m cancellation_manager\u001b[39m=\u001b[39mcancellation_manager)\n", + "File \u001b[0;32m/usr/local/lib/python3.8/site-packages/tensorflow/python/eager/execute.py:54\u001b[0m, in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m ctx\u001b[39m.\u001b[39mensure_initialized()\n\u001b[0;32m---> 54\u001b[0m tensors \u001b[39m=\u001b[39m pywrap_tfe\u001b[39m.\u001b[39;49mTFE_Py_Execute(ctx\u001b[39m.\u001b[39;49m_handle, device_name, op_name,\n\u001b[1;32m 55\u001b[0m inputs, attrs, num_outputs)\n\u001b[1;32m 56\u001b[0m \u001b[39mexcept\u001b[39;00m core\u001b[39m.\u001b[39m_NotOkStatusException \u001b[39mas\u001b[39;00m e:\n\u001b[1;32m 57\u001b[0m \u001b[39mif\u001b[39;00m name \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "model.fit(ds_train, epochs=10, validation_data=ds_val)" + ] + }, { "cell_type": "code", "execution_count": null, From 2cf2f55f35ba8aa8a1eefe1f8bd5a4ff1e1717b0 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Mon, 15 Aug 2022 15:14:38 +0000 Subject: [PATCH 014/101] Bug fixes --- .../python/layers/kspace_scaling.py | 8 +++++--- .../python/layers/kspace_scaling_test.py | 19 +++++++++++++++---- .../python/layers/linear_operator_layer.py | 8 ++++++-- tensorflow_mri/python/recon/recon_adjoint.py | 16 ++++++++-------- 4 files changed, 34 insertions(+), 17 deletions(-) diff --git a/tensorflow_mri/python/layers/kspace_scaling.py b/tensorflow_mri/python/layers/kspace_scaling.py index 8b45bf3b..182d7283 100644 --- a/tensorflow_mri/python/layers/kspace_scaling.py +++ b/tensorflow_mri/python/layers/kspace_scaling.py @@ -57,6 +57,8 @@ def get_config(self): Returns: A `dict` describing the layer configuration. """ - base_config = super().get_config() - config = {} - return {**config, **base_config} + config = super().get_config() + kspace_index = config.pop('input_indices') + if kspace_index is not None: + kspace_index = kspace_index[0] + return config diff --git a/tensorflow_mri/python/layers/kspace_scaling_test.py b/tensorflow_mri/python/layers/kspace_scaling_test.py index d81d3af9..f6e49776 100644 --- a/tensorflow_mri/python/layers/kspace_scaling_test.py +++ b/tensorflow_mri/python/layers/kspace_scaling_test.py @@ -26,16 +26,27 @@ class KSpaceScalingTest(test_util.TestCase): def test_kspace_scaling(self): """Tests the k-space scaling layer.""" layer = kspace_scaling.KSpaceScaling() - image_shape = [4, 4] + image_shape = tf.convert_to_tensor([4, 4]) kspace = tf.dtypes.complex( tf.random.stateless_normal(shape=image_shape, seed=[11, 22]), tf.random.stateless_normal(shape=image_shape, seed=[12, 34])) - inputs = (kspace, image_shape) + image = recon_adjoint.recon_adjoint_mri(kspace, image_shape) + expected = kspace / tf.cast(tf.math.reduce_max(tf.math.abs(image)), + kspace.dtype) + + # Test with tuple inputs. + inputs = (kspace, image_shape) result = layer(inputs) + self.assertAllClose(expected, result) - image = recon_adjoint.recon_adjoint_mri(kspace, image_shape) - expected = kspace / tf.math.reduce_max(tf.math.abs(image)) + # Test with dict inputs. + inputs = {'kspace': kspace, 'image_shape': image_shape} + result = layer(inputs) + self.assertAllClose(expected, result) + # Test (de)serialization. + layer = kspace_scaling.KSpaceScaling.from_config(layer.get_config()) + result = layer(inputs) self.assertAllClose(expected, result) diff --git a/tensorflow_mri/python/layers/linear_operator_layer.py b/tensorflow_mri/python/layers/linear_operator_layer.py index f60240b4..f7abcd37 100644 --- a/tensorflow_mri/python/layers/linear_operator_layer.py +++ b/tensorflow_mri/python/layers/linear_operator_layer.py @@ -63,13 +63,17 @@ def parse_inputs(self, inputs): elif isinstance(inputs, dict): # Parse inputs if passed a dict. if self._input_indices is None: - input_indices = tuple(inputs.keys())[0] + input_indices = (tuple(inputs.keys())[0],) else: input_indices = self._input_indices main = {k: inputs[k] for k in input_indices} args = () kwargs = {k: v for k, v in inputs.items() if k not in input_indices} + # Unpack single input. + if len(input_indices) == 1: + main = main[input_indices[0]] + # Create operator. if self._operator_instance is None: # No instance was provided, so create one. @@ -87,7 +91,7 @@ def get_config(self): base_config = super().get_config() config = { 'operator': self.get_input_operator(), - 'input_indices': self._input_indices, + 'input_indices': self._input_indices } return {**config, **base_config} diff --git a/tensorflow_mri/python/recon/recon_adjoint.py b/tensorflow_mri/python/recon/recon_adjoint.py index 14f183dc..e5e6717e 100644 --- a/tensorflow_mri/python/recon/recon_adjoint.py +++ b/tensorflow_mri/python/recon/recon_adjoint.py @@ -45,13 +45,13 @@ def recon_adjoint(data, operator): @api_util.export("recon.adjoint", "recon.adj") def recon_adjoint_mri(kspace, - image_shape, - mask=None, - trajectory=None, - density=None, - sensitivities=None, - phase=None, - sens_norm=True): + image_shape, + mask=None, + trajectory=None, + density=None, + sensitivities=None, + phase=None, + sens_norm=True): r"""Reconstructs an MR image using the adjoint MRI operator. Given *k*-space data :math:`b`, this function estimates the corresponding @@ -130,4 +130,4 @@ def recon_adjoint_mri(kspace, phase=phase, fft_norm='ortho', sens_norm=sens_norm) - return adjoint(kspace, operator) + return recon_adjoint(kspace, operator) From 5615cb48d8d0f0fc3f891025f55dd5f8cf096158 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 17 Aug 2022 08:24:33 +0000 Subject: [PATCH 015/101] Refactoring coil sensitivities --- .devcontainer/devcontainer.json | 1 - tensorflow_mri/_api/coils/__init__.py | 1 - tensorflow_mri/python/__init__.py | 1 + tensorflow_mri/python/coils/__init__.py | 0 .../python/coils/coil_sensitivities.py | 482 ++++++++++++++++++ .../python/coils/coil_sensitivities_test.py | 185 +++++++ .../python/layers/coil_sensitivities.py | 70 +++ .../python/linalg/linear_operator_mri.py | 8 + tensorflow_mri/python/models/varnet.py | 21 +- tensorflow_mri/python/ops/coil_ops.py | 386 -------------- tensorflow_mri/python/ops/image_ops.py | 12 +- tensorflow_mri/python/ops/image_ops_test.py | 4 +- tensorflow_mri/python/ops/signal_ops.py | 39 +- tensorflow_mri/python/ops/signal_ops_test.py | 7 + 14 files changed, 809 insertions(+), 408 deletions(-) create mode 100644 tensorflow_mri/python/coils/__init__.py create mode 100644 tensorflow_mri/python/coils/coil_sensitivities.py create mode 100644 tensorflow_mri/python/coils/coil_sensitivities_test.py create mode 100644 tensorflow_mri/python/layers/coil_sensitivities.py diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index 3bb3a01a..4558c0a4 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -15,7 +15,6 @@ // Enable plotting. "mounts": [ "type=bind,source=/tmp/.X11-unix,target=/tmp/.X11-unix", - "type=bind,source=/media/storage,target=/media/storage" ], // Enable plotting. "containerEnv": { diff --git a/tensorflow_mri/_api/coils/__init__.py b/tensorflow_mri/_api/coils/__init__.py index 06f5eacb..401cc580 100644 --- a/tensorflow_mri/_api/coils/__init__.py +++ b/tensorflow_mri/_api/coils/__init__.py @@ -2,7 +2,6 @@ # Do not edit. """Parallel imaging operations.""" -from tensorflow_mri.python.ops.coil_ops import estimate_coil_sensitivities as estimate_sensitivities from tensorflow_mri.python.ops.coil_ops import combine_coils as combine_coils from tensorflow_mri.python.ops.coil_ops import compress_coils as compress_coils from tensorflow_mri.python.ops.coil_ops import CoilCompressorSVD as CoilCompressorSVD diff --git a/tensorflow_mri/python/__init__.py b/tensorflow_mri/python/__init__.py index 5853bf11..c3e14470 100644 --- a/tensorflow_mri/python/__init__.py +++ b/tensorflow_mri/python/__init__.py @@ -16,6 +16,7 @@ from tensorflow_mri.python import activations from tensorflow_mri.python import callbacks +from tensorflow_mri.python import coils from tensorflow_mri.python import initializers from tensorflow_mri.python import io from tensorflow_mri.python import layers diff --git a/tensorflow_mri/python/coils/__init__.py b/tensorflow_mri/python/coils/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tensorflow_mri/python/coils/coil_sensitivities.py b/tensorflow_mri/python/coils/coil_sensitivities.py new file mode 100644 index 00000000..e3855cf5 --- /dev/null +++ b/tensorflow_mri/python/coils/coil_sensitivities.py @@ -0,0 +1,482 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Coil sensitivity estimation.""" + +import functools + +import numpy as np +import tensorflow as tf + +from tensorflow_mri.python.ops import array_ops +from tensorflow_mri.python.ops import fft_ops +from tensorflow_mri.python.ops import signal_ops +from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.util import check_util + + +@api_util.export("coils.custom_sensitivities") +def coil_sensitivities(kspace, + operator, + calib_filter='rect', + calib_region=None, + method='walsh', + **kwargs): + rank = operator.rank + calib_region = canonicalize_calib_region(calib_region, rank) + + # Low-pass filtering. + kspace = signal_ops.filter_kspace(kspace, + trajectory=operator.trajectory, + filter_fn=calib_filter, + filter_rank=rank, + filter_kwargs=dict( + cutoff=min(calib_region) + )) + + # Reconstruct image. + inputs = operator.transform(kspace, adjoint=True) + + # ESPIRiT method takes in k-space data, so convert back to k-space in this + # case. + if method == 'espirit': + axes = list(range(-rank, 0)) + inputs = fft_ops.fftn(inputs, axes=axes, norm='ortho', shift=True) + + # Reshape to single batch dimension. + batch_shape_static = inputs.shape[:-(rank + 1)] + batch_shape = tf.shape(inputs)[:-(rank + 1)] + input_shape = tf.shape(inputs)[-(rank + 1):] + inputs = tf.reshape(inputs, tf.concat([[-1], input_shape], 0)) + + # Apply estimation for each element in batch. + sensitivities = tf.map_fn( + functools.partial(estimate_coil_sensitivities, + coil_axis=-(rank + 1), + method=method, + **kwargs), + inputs) + + # Restore batch shape. + output_shape = tf.shape(sensitivities)[1:] + output_shape_static = sensitivities.shape[1:] + sensitivities = tf.reshape(sensitivities, + tf.concat([batch_shape, output_shape], 0)) + sensitivities = tf.ensure_shape( + sensitivities, batch_shape_static.concatenate(output_shape_static)) + + return sensitivities + + +def canonicalize_calib_region(calib_region, rank): + if isinstance(calib_region, float): + calib_region = (calib_region,) * rank + if isinstance(calib_region, list): + calib_region = tuple(calib_region) + if not isinstance(calib_region, tuple): + raise TypeError( + f"calib_region must be a float or a tuple, " + f"but got {type(calib_region)}") + if len(calib_region) != rank: + raise ValueError( + f"calib_region has length {len(calib_region)}, " + f"but expected length {rank}") + return calib_region + + +@api_util.export("coils.estimate_sensitivities") +def estimate_coil_sensitivities(input_, + coil_axis=-1, + method='walsh', + **kwargs): + """Estimate coil sensitivity maps. + + This method supports 2D and 3D inputs. + + Args: + input_: A `Tensor`. Must have type `complex64` or `complex128`. Must have + shape `[height, width, coils]` for 2D inputs, or `[depth, height, + width, coils]` for 3D inputs. Alternatively, this function accepts a + transposed array by setting the `coil_axis` argument accordingly. Inputs + should be images if `method` is `'walsh'` or `'inati'`, and k-space data + if `method` is `'espirit'`. + coil_axis: An `int`. Defaults to -1. + method: A `string`. The coil sensitivity estimation algorithm. Must be one + of: `{'walsh', 'inati', 'espirit'}`. Defaults to `'walsh'`. + **kwargs: Additional keyword arguments for the coil sensitivity estimation + algorithm. See Notes. + + Returns: + A `Tensor`. Has the same type as `input_`. Has shape + `input_.shape + [num_maps]` if `method` is `'espirit'`, or shape + `input_.shape` otherwise. + + Notes: + + This function accepts the following method-specific keyword arguments: + + * For `method="walsh"`: + + * **filter_size**: An `int`. The size of the smoothing filter. + + * For `method="inati"`: + + * **filter_size**: An `int`. The size of the smoothing filter. + * **max_iter**: An `int`. The maximum number of iterations. + * **tol**: A `float`. The convergence tolerance. + + * For `method="espirit"`: + + * **calib_size**: An `int` or a list of `ints`. The size of the + calibration region. If `None`, this is set to `input_.shape[:-1]` (ie, + use full input for calibration). Defaults to 24. + * **kernel_size**: An `int` or a list of `ints`. The kernel size. Defaults + to 6. + * **num_maps**: An `int`. The number of output maps. Defaults to 2. + * **null_threshold**: A `float`. The threshold used to determine the size + of the null-space. Defaults to 0.02. + * **eigen_threshold**: A `float`. The threshold used to determine the + locations where coil sensitivity maps should be masked out. Defaults + to 0.95. + * **image_shape**: A `tf.TensorShape` or a list of `ints`. The shape of + the output maps. If `None`, this is set to `input_.shape`. Defaults to + `None`. + + References: + .. [1] Walsh, D.O., Gmitro, A.F. and Marcellin, M.W. (2000), Adaptive + reconstruction of phased array MR imagery. Magn. Reson. Med., 43: + 682-690. https://doi.org/10.1002/(SICI)1522-2594(200005)43:5<682::AID-MRM10>3.0.CO;2-G + + .. [2] Inati, S.J., Hansen, M.S. and Kellman, P. (2014). A fast optimal + method for coil sensitivity estimation and adaptive coil combination for + complex images. Proceedings of the 2014 Joint Annual Meeting + ISMRM-ESMRMB. + + .. [3] Uecker, M., Lai, P., Murphy, M.J., Virtue, P., Elad, M., Pauly, J.M., + Vasanawala, S.S. and Lustig, M. (2014), ESPIRiT—an eigenvalue approach + to autocalibrating parallel MRI: Where SENSE meets GRAPPA. Magn. Reson. + Med., 71: 990-1001. https://doi.org/10.1002/mrm.24751 + """ + # pylint: disable=missing-raises-doc + input_ = tf.convert_to_tensor(input_) + tf.debugging.assert_rank_at_least(input_, 2, message=( + f"Argument `input_` must have rank of at least 2, but got shape: " + f"{input_.shape}")) + coil_axis = check_util.validate_type(coil_axis, int, name='coil_axis') + method = check_util.validate_enum( + method, {'walsh', 'inati', 'espirit'}, name='method') + + # Move coil axis to innermost dimension if not already there. + if coil_axis != -1: + rank = input_.shape.rank + canonical_coil_axis = coil_axis + rank if coil_axis < 0 else coil_axis + perm = ( + [ax for ax in range(rank) if not ax == canonical_coil_axis] + + [canonical_coil_axis]) + input_ = tf.transpose(input_, perm) + + if method == 'walsh': + maps = _estimate_coil_sensitivities_walsh(input_, **kwargs) + elif method == 'inati': + maps = _estimate_coil_sensitivities_inati(input_, **kwargs) + elif method == 'espirit': + maps = _estimate_coil_sensitivities_espirit(input_, **kwargs) + else: + raise RuntimeError("This should never happen.") + + # If necessary, move coil axis back to its original location. + if coil_axis != -1: + inv_perm = tf.math.invert_permutation(perm) + if method == 'espirit': + # When using ESPIRiT method, output has an additional `maps` dimension. + inv_perm = tf.concat([inv_perm, [tf.shape(inv_perm)[0]]], 0) + maps = tf.transpose(maps, inv_perm) + + return maps + + + +def _estimate_coil_sensitivities_walsh(images, filter_size=5): + """Estimate coil sensitivity maps using Walsh's method. + + For the parameters, see `estimate_coil_sensitivities`. + """ + rank = images.shape.rank - 1 + image_shape = tf.shape(images)[:-1] + num_coils = tf.shape(images)[-1] + + filter_size = check_util.validate_list( + filter_size, element_type=int, length=rank, name='filter_size') + + # Flatten all spatial dimensions into a single axis, so `images` has shape + # `[num_pixels, num_coils]`. + flat_images = tf.reshape(images, [-1, num_coils]) + + # Compute covariance matrix for each pixel; with shape + # `[num_pixels, num_coils, num_coils]`. + correlation_matrix = tf.math.multiply( + tf.reshape(flat_images, [-1, num_coils, 1]), + tf.math.conj(tf.reshape(flat_images, [-1, 1, num_coils]))) + + # Smooth the covariance tensor along the spatial dimensions. + correlation_matrix = tf.reshape( + correlation_matrix, tf.concat([image_shape, [-1]], 0)) + correlation_matrix = _apply_uniform_filter(correlation_matrix, filter_size) + correlation_matrix = tf.reshape(correlation_matrix, [-1] + [num_coils] * 2) + + # Get sensitivity maps as the dominant eigenvector. + _, eigenvectors = tf.linalg.eig(correlation_matrix) # pylint: disable=no-value-for-parameter + maps = eigenvectors[..., -1] + + # Restore spatial axes. + maps = tf.reshape(maps, tf.concat([image_shape, [num_coils]], 0)) + + return maps + + +def _estimate_coil_sensitivities_inati(images, + filter_size=5, + max_iter=5, + tol=1e-3): + """Estimate coil sensitivity maps using Inati's fast method. + + For the parameters, see `estimate_coil_sensitivities`. + """ + rank = images.shape.rank - 1 + spatial_axes = list(range(rank)) + coil_axis = -1 + + # Validate inputs. + filter_size = check_util.validate_list( + filter_size, element_type=int, length=rank, name='filter_size') + max_iter = check_util.validate_type(max_iter, int, name='max_iter') + tol = check_util.validate_type(tol, float, name='tol') + + d_sum = tf.math.reduce_sum(images, axis=spatial_axes, keepdims=True) + d_sum /= tf.norm(d_sum, axis=coil_axis, keepdims=True) + + r = tf.math.reduce_sum( + tf.math.conj(d_sum) * images, axis=coil_axis, keepdims=True) + + eps = tf.cast( + tnp.finfo(images.dtype).eps * tf.math.reduce_mean(tf.math.abs(images)), + images.dtype) + + State = collections.namedtuple('State', ['i', 'maps', 'r', 'd']) + + def _cond(i, state): + return tf.math.logical_and(i < max_iter, state.d >= tol) + + def _body(i, state): + prev_r = state.r + r = state.r + + r = tf.math.conj(r) + + maps = images * r + smooth_maps = _apply_uniform_filter(maps, filter_size) + d = smooth_maps * tf.math.conj(smooth_maps) + + # Sum over coils. + r = tf.math.reduce_sum(d, axis=coil_axis, keepdims=True) + + r = tf.math.sqrt(r) + r = tf.math.reciprocal(r + eps) + + maps = smooth_maps * r + + d = images * tf.math.conj(maps) + r = tf.math.reduce_sum(d, axis=coil_axis, keepdims=True) + + d = maps * r + + d_sum = tf.math.reduce_sum(d, axis=spatial_axes, keepdims=True) + d_sum /= tf.norm(d_sum, axis=coil_axis, keepdims=True) + + im_t = tf.math.reduce_sum( + tf.math.conj(d_sum) * maps, axis=coil_axis, keepdims=True) + im_t /= (tf.cast(tf.math.abs(im_t), images.dtype) + eps) + r *= im_t + im_t = tf.math.conj(im_t) + maps = maps * im_t + + diff_r = r - prev_r + d = tf.math.abs(tf.norm(diff_r) / tf.norm(r)) + + return i + 1, State(i=i + 1, maps=maps, r=r, d=d) + + i = tf.constant(0, dtype=tf.int32) + state = State(i=i, + maps=tf.zeros_like(images), + r=r, + d=tf.constant(1.0, dtype=images.dtype.real_dtype)) + [i, state] = tf.while_loop(_cond, _body, [i, state]) + + return tf.reshape(state.maps, images.shape) + + +def _estimate_coil_sensitivities_espirit(kspace, + calib_size=24, + kernel_size=6, + num_maps=2, + null_threshold=0.02, + eigen_threshold=0.95, + image_shape=None): + """Estimate coil sensitivity maps using the ESPIRiT method. + + For the parameters, see `estimate_coil_sensitivities`. + """ + kspace = tf.convert_to_tensor(kspace) + rank = kspace.shape.rank - 1 + spatial_axes = list(range(rank)) + num_coils = tf.shape(kspace)[-1] + if image_shape is None: + image_shape = kspace.shape[:-1] + if calib_size is None: + calib_size = image_shape.as_list() + + calib_size = check_util.validate_list( + calib_size, element_type=int, length=rank, name='calib_size') + kernel_size = check_util.validate_list( + kernel_size, element_type=int, length=rank, name='kernel_size') + + with tf.control_dependencies([ + tf.debugging.assert_greater(calib_size, kernel_size, message=( + f"`calib_size` must be greater than `kernel_size`, but got " + f"{calib_size} and {kernel_size}"))]): + kspace = tf.identity(kspace) + + # Get calibration region. + calib = array_ops.central_crop(kspace, calib_size + [-1]) + + # Construct the calibration block Hankel matrix. + conv_size = [cs - ks + 1 for cs, ks in zip(calib_size, kernel_size)] + calib_matrix = tf.zeros([_prod(conv_size), _prod(kernel_size) * num_coils], + dtype=calib.dtype) + idx = 0 + for nd_inds in np.ndindex(*conv_size): + slices = [slice(ii, ii + ks) for ii, ks in zip(nd_inds, kernel_size)] + calib_matrix = tf.tensor_scatter_nd_update( + calib_matrix, [[idx]], tf.reshape(calib[slices], [1, -1])) + idx += 1 + + # Compute SVD decomposition, threshold singular values and reshape V to create + # k-space kernel matrix. + s, _, v = tf.linalg.svd(calib_matrix, full_matrices=True) + num_values = tf.math.count_nonzero(s >= s[0] * null_threshold) + v = v[:, :num_values] + kernel = tf.reshape(v, kernel_size + [num_coils, -1]) + + # Rotate kernel to order by maximum variance. + perm = list(range(kernel.shape.rank)) + perm[-2], perm[-1] = perm[-1], perm[-2] + kernel = tf.transpose(kernel, perm) + kernel = tf.reshape(kernel, [-1, num_coils]) + _, _, rot_matrix = tf.linalg.svd(kernel, full_matrices=False) + kernel = tf.linalg.matmul(kernel, rot_matrix) + kernel = tf.reshape(kernel, kernel_size + [-1, num_coils]) + kernel = tf.transpose(kernel, perm) + + # Compute inverse FFT of k-space kernel. + kernel = tf.reverse(kernel, spatial_axes) + kernel = tf.math.conj(kernel) + + kernel_image = fft_ops.fftn(kernel, + shape=image_shape, + axes=list(range(rank)), + shift=True) + + kernel_image /= tf.cast(tf.sqrt(tf.cast(tf.math.reduce_prod(kernel_size), + kernel_image.dtype.real_dtype)), + kernel_image.dtype) + + values, maps, _ = tf.linalg.svd(kernel_image, full_matrices=False) + + # Apply phase modulation. + maps *= tf.math.exp(tf.complex(tf.constant(0.0, dtype=maps.dtype.real_dtype), + -tf.math.angle(maps[..., 0:1, :]))) + + # Undo rotation. + maps = tf.linalg.matmul(rot_matrix, maps) + + # Keep only the requested number of maps. + values = values[..., :num_maps] + maps = maps[..., :num_maps] + + # Apply thresholding. + mask = tf.expand_dims(values >= eigen_threshold, -2) + maps *= tf.cast(mask, maps.dtype) + + # If possible, set static number of maps. + if isinstance(num_maps, int): + maps_shape = maps.shape.as_list() + maps_shape[-1] = num_maps + maps = tf.ensure_shape(maps, maps_shape) + + return maps + + +def _apply_uniform_filter(tensor, size=5): + """Apply a uniform filter. + + Args: + tensor: A `Tensor`. Must have shape `spatial_shape + [channels]`. + size: An `int`. The size of the filter. Defaults to 5. + + Returns: + A `Tensor`. Has the same type as `tensor`. + """ + rank = tensor.shape.rank - 1 + + # Compute filters. + if isinstance(size, int): + size = [size] * rank + filters_shape = size + [1, 1] + filters = tf.ones(filters_shape, dtype=tensor.dtype.real_dtype) + filters /= _prod(size) + + # Select appropriate convolution function. + conv_nd = { + 1: tf.nn.conv1d, + 2: tf.nn.conv2d, + 3: tf.nn.conv3d}[rank] + + # Move channels dimension to batch dimension. + tensor = tf.transpose(tensor) + + # Add a channels dimension, as required by `tf.nn.conv*` functions. + tensor = tf.expand_dims(tensor, -1) + + if tensor.dtype.is_complex: + # For complex input, we filter the real and imaginary parts separately. + tensor_real = tf.math.real(tensor) + tensor_imag = tf.math.imag(tensor) + + output_real = conv_nd(tensor_real, filters, [1] * (rank + 2), 'SAME') + output_imag = conv_nd(tensor_imag, filters, [1] * (rank + 2), 'SAME') + + output = tf.dtypes.complex(output_real, output_imag) + else: + output = conv_nd(tensor, filters, [1] * (rank + 2), 'SAME') + + # Remove channels dimension. + output = output[..., 0] + + # Move channels dimension back to last dimension. + output = tf.transpose(output) + + return output + + +_prod = lambda iterable: functools.reduce(lambda x, y: x * y, iterable) diff --git a/tensorflow_mri/python/coils/coil_sensitivities_test.py b/tensorflow_mri/python/coils/coil_sensitivities_test.py new file mode 100644 index 00000000..0b2e3997 --- /dev/null +++ b/tensorflow_mri/python/coils/coil_sensitivities_test.py @@ -0,0 +1,185 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Coil sensitivity estimation.""" + +import numpy as np +import tensorflow as tf + +from tensorflow_mri.python.coils import coil_sensitivities +from tensorflow_mri.python.linalg import linear_operator_mri +from tensorflow_mri.python.ops import fft_ops +from tensorflow_mri.python.ops import image_ops +from tensorflow_mri.python.ops import traj_ops +from tensorflow_mri.python.util import test_util + +import matplotlib.pyplot as plt +from tensorflow_mri.python.util import plot_util + + +class CoilSensitivitiesTest(test_util.TestCase): + + def test_coil_sensitivities(self): + # Simulate k-space. + image_shape = (8, 8) + image = image_ops.phantom(shape=image_shape, num_coils=4, + dtype=tf.complex64) + kspace = fft_ops.fftn(image, axes=(-2, -1), shift=True) + + # Create a mask. + mask = traj_ops.random_sampling_mask( + shape=image_shape, + density=traj_ops.density_grid(image_shape, + outer_density=0.2, + inner_cutoff=0.1, + outer_cutoff=0.1)) + + operator = linear_operator_mri.LinearOperatorMRI( + image_shape=image_shape, mask=mask) + + sens = coil_sensitivities.coil_sensitivities(kspace, + operator, + calib_region=0.1 * np.pi) + + expected = [ + [[0.43218857-4.6583355e-09j, 0.43218845-8.7869850e-11j, + 0.43218854-6.1883219e-09j, 0.43218854-6.1883219e-09j, + 0.43218854-6.1883219e-09j, 0.43218854-6.1883219e-09j, + 0.43218845-8.7869850e-11j, 0.43218857-4.6583355e-09j], + [0.43218845-8.7869850e-11j, 0.4321886 -3.5613092e-09j, + 0.4321885 +1.2543831e-08j, 0.4321885 +1.2543831e-08j, + 0.4321885 +1.2543831e-08j, 0.4321885 +1.2543831e-08j, + 0.4321886 -3.5613092e-09j, 0.43218845-8.7869850e-11j], + [0.43218854-6.1883219e-09j, 0.4321885 +1.2543831e-08j, + 0.4321885 -4.5338737e-09j, 0.4321885 -4.5338737e-09j, + 0.4321885 -4.5338737e-09j, 0.4321885 -4.5338737e-09j, + 0.4321885 +1.2543831e-08j, 0.43218854-6.1883219e-09j], + [0.43218854-6.1883219e-09j, 0.4321885 +1.2543831e-08j, + 0.4321885 -4.5338737e-09j, 0.4321885 -4.5338737e-09j, + 0.4321885 -4.5338737e-09j, 0.4321885 -4.5338737e-09j, + 0.4321885 +1.2543831e-08j, 0.43218854-6.1883219e-09j], + [0.43218854-6.1883219e-09j, 0.4321885 +1.2543831e-08j, + 0.4321885 -4.5338737e-09j, 0.4321885 -4.5338737e-09j, + 0.4321885 -4.5338737e-09j, 0.4321885 -4.5338737e-09j, + 0.4321885 +1.2543831e-08j, 0.43218854-6.1883219e-09j], + [0.43218854-6.1883219e-09j, 0.4321885 +1.2543831e-08j, + 0.4321885 -4.5338737e-09j, 0.4321885 -4.5338737e-09j, + 0.4321885 -4.5338737e-09j, 0.4321885 -4.5338737e-09j, + 0.4321885 +1.2543831e-08j, 0.43218854-6.1883219e-09j], + [0.43218845-8.7869850e-11j, 0.4321886 -3.5613092e-09j, + 0.4321885 +1.2543831e-08j, 0.4321885 +1.2543831e-08j, + 0.4321885 +1.2543831e-08j, 0.4321885 +1.2543831e-08j, + 0.4321886 -3.5613092e-09j, 0.43218845-8.7869850e-11j], + [0.43218857-4.6583355e-09j, 0.43218845-8.7869850e-11j, + 0.43218854-6.1883219e-09j, 0.43218854-6.1883219e-09j, + 0.43218854-6.1883219e-09j, 0.43218854-6.1883219e-09j, + 0.43218845-8.7869850e-11j, 0.43218857-4.6583355e-09j]], + [[0.482938 -6.7950569e-02j, 0.48293796-6.7950562e-02j, + 0.48293793-6.7950577e-02j, 0.48293793-6.7950577e-02j, + 0.48293793-6.7950577e-02j, 0.48293793-6.7950577e-02j, + 0.48293796-6.7950562e-02j, 0.482938 -6.7950569e-02j], + [0.48293796-6.7950562e-02j, 0.4829379 -6.7950562e-02j, + 0.4829379 -6.7950569e-02j, 0.4829379 -6.7950569e-02j, + 0.4829379 -6.7950569e-02j, 0.4829379 -6.7950569e-02j, + 0.4829379 -6.7950562e-02j, 0.48293796-6.7950562e-02j], + [0.48293793-6.7950577e-02j, 0.4829379 -6.7950569e-02j, + 0.48293784-6.7950577e-02j, 0.48293784-6.7950577e-02j, + 0.48293784-6.7950577e-02j, 0.48293784-6.7950577e-02j, + 0.4829379 -6.7950569e-02j, 0.48293793-6.7950577e-02j], + [0.48293793-6.7950577e-02j, 0.4829379 -6.7950569e-02j, + 0.48293784-6.7950577e-02j, 0.48293784-6.7950577e-02j, + 0.48293784-6.7950577e-02j, 0.48293784-6.7950577e-02j, + 0.4829379 -6.7950569e-02j, 0.48293793-6.7950577e-02j], + [0.48293793-6.7950577e-02j, 0.4829379 -6.7950569e-02j, + 0.48293784-6.7950577e-02j, 0.48293784-6.7950577e-02j, + 0.48293784-6.7950577e-02j, 0.48293784-6.7950577e-02j, + 0.4829379 -6.7950569e-02j, 0.48293793-6.7950577e-02j], + [0.48293793-6.7950577e-02j, 0.4829379 -6.7950569e-02j, + 0.48293784-6.7950577e-02j, 0.48293784-6.7950577e-02j, + 0.48293784-6.7950577e-02j, 0.48293784-6.7950577e-02j, + 0.4829379 -6.7950569e-02j, 0.48293793-6.7950577e-02j], + [0.48293796-6.7950562e-02j, 0.4829379 -6.7950562e-02j, + 0.4829379 -6.7950569e-02j, 0.4829379 -6.7950569e-02j, + 0.4829379 -6.7950569e-02j, 0.4829379 -6.7950569e-02j, + 0.4829379 -6.7950562e-02j, 0.48293796-6.7950562e-02j], + [0.482938 -6.7950569e-02j, 0.48293796-6.7950562e-02j, + 0.48293793-6.7950577e-02j, 0.48293793-6.7950577e-02j, + 0.48293793-6.7950577e-02j, 0.48293793-6.7950577e-02j, + 0.48293796-6.7950562e-02j, 0.482938 -6.7950569e-02j]], + [[0.48752287-6.2960379e-02j, 0.4875229 -6.2960386e-02j, + 0.48752284-6.2960386e-02j, 0.48752284-6.2960386e-02j, + 0.48752284-6.2960386e-02j, 0.48752284-6.2960386e-02j, + 0.4875229 -6.2960386e-02j, 0.48752287-6.2960379e-02j], + [0.4875229 -6.2960386e-02j, 0.4875229 -6.2960394e-02j, + 0.48752287-6.2960371e-02j, 0.48752287-6.2960371e-02j, + 0.48752287-6.2960371e-02j, 0.48752287-6.2960371e-02j, + 0.4875229 -6.2960394e-02j, 0.4875229 -6.2960386e-02j], + [0.48752284-6.2960386e-02j, 0.48752287-6.2960371e-02j, + 0.48752296-6.2960409e-02j, 0.48752296-6.2960409e-02j, + 0.48752296-6.2960409e-02j, 0.48752296-6.2960409e-02j, + 0.48752287-6.2960371e-02j, 0.48752284-6.2960386e-02j], + [0.48752284-6.2960386e-02j, 0.48752287-6.2960371e-02j, + 0.48752296-6.2960409e-02j, 0.48752296-6.2960409e-02j, + 0.48752296-6.2960409e-02j, 0.48752296-6.2960409e-02j, + 0.48752287-6.2960371e-02j, 0.48752284-6.2960386e-02j], + [0.48752284-6.2960386e-02j, 0.48752287-6.2960371e-02j, + 0.48752296-6.2960409e-02j, 0.48752296-6.2960409e-02j, + 0.48752296-6.2960409e-02j, 0.48752296-6.2960409e-02j, + 0.48752287-6.2960371e-02j, 0.48752284-6.2960386e-02j], + [0.48752284-6.2960386e-02j, 0.48752287-6.2960371e-02j, + 0.48752296-6.2960409e-02j, 0.48752296-6.2960409e-02j, + 0.48752296-6.2960409e-02j, 0.48752296-6.2960409e-02j, + 0.48752287-6.2960371e-02j, 0.48752284-6.2960386e-02j], + [0.4875229 -6.2960386e-02j, 0.4875229 -6.2960394e-02j, + 0.48752287-6.2960371e-02j, 0.48752287-6.2960371e-02j, + 0.48752287-6.2960371e-02j, 0.48752287-6.2960371e-02j, + 0.4875229 -6.2960394e-02j, 0.4875229 -6.2960386e-02j], + [0.48752287-6.2960379e-02j, 0.4875229 -6.2960386e-02j, + 0.48752284-6.2960386e-02j, 0.48752284-6.2960386e-02j, + 0.48752284-6.2960386e-02j, 0.48752284-6.2960386e-02j, + 0.4875229 -6.2960386e-02j, 0.48752287-6.2960379e-02j]], + [[0.57736677+1.9284124e-02j, 0.57736677+1.9284116e-02j, + 0.5773667 +1.9284122e-02j, 0.5773667 +1.9284122e-02j, + 0.5773667 +1.9284122e-02j, 0.5773667 +1.9284122e-02j, + 0.57736677+1.9284116e-02j, 0.57736677+1.9284124e-02j], + [0.57736677+1.9284116e-02j, 0.57736677+1.9284124e-02j, + 0.57736677+1.9284150e-02j, 0.57736677+1.9284150e-02j, + 0.57736677+1.9284150e-02j, 0.57736677+1.9284150e-02j, + 0.57736677+1.9284124e-02j, 0.57736677+1.9284116e-02j], + [0.5773667 +1.9284122e-02j, 0.57736677+1.9284150e-02j, + 0.5773668 +1.9284131e-02j, 0.5773668 +1.9284131e-02j, + 0.5773668 +1.9284131e-02j, 0.5773668 +1.9284131e-02j, + 0.57736677+1.9284150e-02j, 0.5773667 +1.9284122e-02j], + [0.5773667 +1.9284122e-02j, 0.57736677+1.9284150e-02j, + 0.5773668 +1.9284131e-02j, 0.5773668 +1.9284131e-02j, + 0.5773668 +1.9284131e-02j, 0.5773668 +1.9284131e-02j, + 0.57736677+1.9284150e-02j, 0.5773667 +1.9284122e-02j], + [0.5773667 +1.9284122e-02j, 0.57736677+1.9284150e-02j, + 0.5773668 +1.9284131e-02j, 0.5773668 +1.9284131e-02j, + 0.5773668 +1.9284131e-02j, 0.5773668 +1.9284131e-02j, + 0.57736677+1.9284150e-02j, 0.5773667 +1.9284122e-02j], + [0.5773667 +1.9284122e-02j, 0.57736677+1.9284150e-02j, + 0.5773668 +1.9284131e-02j, 0.5773668 +1.9284131e-02j, + 0.5773668 +1.9284131e-02j, 0.5773668 +1.9284131e-02j, + 0.57736677+1.9284150e-02j, 0.5773667 +1.9284122e-02j], + [0.57736677+1.9284116e-02j, 0.57736677+1.9284124e-02j, + 0.57736677+1.9284150e-02j, 0.57736677+1.9284150e-02j, + 0.57736677+1.9284150e-02j, 0.57736677+1.9284150e-02j, + 0.57736677+1.9284124e-02j, 0.57736677+1.9284116e-02j], + [0.57736677+1.9284124e-02j, 0.57736677+1.9284116e-02j, + 0.5773667 +1.9284122e-02j, 0.5773667 +1.9284122e-02j, + 0.5773667 +1.9284122e-02j, 0.5773667 +1.9284122e-02j, + 0.57736677+1.9284116e-02j, 0.57736677+1.9284124e-02j]]] + + self.assertAllClose(expected, sens) diff --git a/tensorflow_mri/python/layers/coil_sensitivities.py b/tensorflow_mri/python/layers/coil_sensitivities.py new file mode 100644 index 00000000..2f3a159f --- /dev/null +++ b/tensorflow_mri/python/layers/coil_sensitivities.py @@ -0,0 +1,70 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""*k*-space scaling layer.""" + +import tensorflow as tf + +from tensorflow_mri.python.layers import linear_operator_layer +from tensorflow_mri.python.linalg import linear_operator_mri +from tensorflow_mri.python.recon import recon_adjoint +from tensorflow_mri.python.ops import signal_ops + + +class CoilSensitivityEstimation(linear_operator_layer.LinearOperatorLayer): + """Coil sensitivity estimation layer. + + This layer scales the *k*-space data so that the adjoint reconstruction has + values between 0 and 1. + """ + def __init__(self, + operator=linear_operator_mri.LinearOperatorMRI, + kspace_index=None, + **kwargs): + """Initializes the layer.""" + super().__init__(operator=operator, input_indices=kspace_index, **kwargs) + + def call(self, inputs): + """Applies the layer. + + Args: + inputs: A `tuple` or `dict` containing the *k*-space data as defined by + `kspace_index`. If `operator` is a class not an instance, then `inputs` + must also contain any other arguments to be passed to the constructor of + `operator`. + + Returns: + The scaled k-space data. + """ + kspace, operator = self.parse_inputs(inputs) + filter_fn = lambda x: signal_ops.hamming(calib_region * x) + kspace = signal_ops.filter_kspace(kspace, + trajectory=operator.trajectory, + filter_fn=filter_fn, + filter_rank=operator.rank) + image = recon_adjoint.recon_adjoint(kspace, operator) + return kspace / tf.cast(tf.math.reduce_max(tf.math.abs(image)), + kspace.dtype) + + def get_config(self): + """Returns the config of the layer. + + Returns: + A `dict` describing the layer configuration. + """ + config = super().get_config() + kspace_index = config.pop('input_indices') + if kspace_index is not None: + kspace_index = kspace_index[0] + return config diff --git a/tensorflow_mri/python/linalg/linear_operator_mri.py b/tensorflow_mri/python/linalg/linear_operator_mri.py index 5ec28609..768eb04c 100644 --- a/tensorflow_mri/python/linalg/linear_operator_mri.py +++ b/tensorflow_mri/python/linalg/linear_operator_mri.py @@ -484,6 +484,14 @@ def rank(self): """The number of spatial dimensions.""" return self._rank + @property + def trajectory(self): + """The k-space trajectory. + + Returns `None` for Cartesian imaging. + """ + return self._trajectory + @property def is_cartesian(self): """Whether this is a Cartesian MRI operator.""" diff --git a/tensorflow_mri/python/models/varnet.py b/tensorflow_mri/python/models/varnet.py index 47fe674e..56232bfe 100644 --- a/tensorflow_mri/python/models/varnet.py +++ b/tensorflow_mri/python/models/varnet.py @@ -15,27 +15,32 @@ import tensorflow as tf +from tensorflow_mri.python.layers import kspace_scaling from tensorflow_mri.python.util import api_util class VarNet(tf.keras.Model): def __init__(self, rank, - kspace_index='kspace', + kspace_index=None, scale_kspace=True, **kwargs): - super(VarNet, self).__init__(**kwargs) + super().__init__(**kwargs) self.rank = rank + self.kspace_index = kspace_index self.scale_kspace = scale_kspace + if self.scale_kspace: + self._kspace_scaling_layer = kspace_scaling.KSpaceScaling( + kspace_index=self.kspace_index) + else: + self._kspace_scaling_layer = None def call(self, inputs): - kspace = inputs['kspace'] - kwargs = {k: inputs[k] for k in inputs.keys() if k != 'kspace'} - - if 'image_shape' not in kwargs: - kwargs['image_shape'] = tf.shape(kspace)[-2:] + if self.scale_kspace: + kspace = self._kspace_scaling_layer(inputs) - kspace = KSpaceScaling()({'kspace': kspace, **kwargs}) + if self.scale_kspace: + sensitivities = CoilSensitivityEstimation() kwargs['sensitivities'] = CoilSensitivities()({'kspace': kspace, **kwargs}) zfill = ReconAdjoint()({'kspace': kspace, **kwargs}) diff --git a/tensorflow_mri/python/ops/coil_ops.py b/tensorflow_mri/python/ops/coil_ops.py index d4932e17..480c2c55 100755 --- a/tensorflow_mri/python/ops/coil_ops.py +++ b/tensorflow_mri/python/ops/coil_ops.py @@ -32,117 +32,6 @@ from tensorflow_mri.python.util import check_util -@api_util.export("coils.estimate_sensitivities") -def estimate_coil_sensitivities(input_, - coil_axis=-1, - method='walsh', - **kwargs): - """Estimate coil sensitivity maps. - - This method supports 2D and 3D inputs. - - Args: - input_: A `Tensor`. Must have type `complex64` or `complex128`. Must have - shape `[height, width, coils]` for 2D inputs, or `[depth, height, - width, coils]` for 3D inputs. Alternatively, this function accepts a - transposed array by setting the `coil_axis` argument accordingly. Inputs - should be images if `method` is `'walsh'` or `'inati'`, and k-space data - if `method` is `'espirit'`. - coil_axis: An `int`. Defaults to -1. - method: A `string`. The coil sensitivity estimation algorithm. Must be one - of: `{'walsh', 'inati', 'espirit'}`. Defaults to `'walsh'`. - **kwargs: Additional keyword arguments for the coil sensitivity estimation - algorithm. See Notes. - - Returns: - A `Tensor`. Has the same type as `input_`. Has shape - `input_.shape + [num_maps]` if `method` is `'espirit'`, or shape - `input_.shape` otherwise. - - Notes: - - This function accepts the following method-specific keyword arguments: - - * For `method="walsh"`: - - * **filter_size**: An `int`. The size of the smoothing filter. - - * For `method="inati"`: - - * **filter_size**: An `int`. The size of the smoothing filter. - * **max_iter**: An `int`. The maximum number of iterations. - * **tol**: A `float`. The convergence tolerance. - - * For `method="espirit"`: - - * **calib_size**: An `int` or a list of `ints`. The size of the - calibration region. If `None`, this is set to `input_.shape[:-1]` (ie, - use full input for calibration). Defaults to 24. - * **kernel_size**: An `int` or a list of `ints`. The kernel size. Defaults - to 6. - * **num_maps**: An `int`. The number of output maps. Defaults to 2. - * **null_threshold**: A `float`. The threshold used to determine the size - of the null-space. Defaults to 0.02. - * **eigen_threshold**: A `float`. The threshold used to determine the - locations where coil sensitivity maps should be masked out. Defaults - to 0.95. - * **image_shape**: A `tf.TensorShape` or a list of `ints`. The shape of - the output maps. If `None`, this is set to `input_.shape`. Defaults to - `None`. - - References: - .. [1] Walsh, D.O., Gmitro, A.F. and Marcellin, M.W. (2000), Adaptive - reconstruction of phased array MR imagery. Magn. Reson. Med., 43: - 682-690. https://doi.org/10.1002/(SICI)1522-2594(200005)43:5<682::AID-MRM10>3.0.CO;2-G - - .. [2] Inati, S.J., Hansen, M.S. and Kellman, P. (2014). A fast optimal - method for coil sensitivity estimation and adaptive coil combination for - complex images. Proceedings of the 2014 Joint Annual Meeting - ISMRM-ESMRMB. - - .. [3] Uecker, M., Lai, P., Murphy, M.J., Virtue, P., Elad, M., Pauly, J.M., - Vasanawala, S.S. and Lustig, M. (2014), ESPIRiT—an eigenvalue approach - to autocalibrating parallel MRI: Where SENSE meets GRAPPA. Magn. Reson. - Med., 71: 990-1001. https://doi.org/10.1002/mrm.24751 - """ - # pylint: disable=missing-raises-doc - input_ = tf.convert_to_tensor(input_) - tf.debugging.assert_rank_at_least(input_, 2, message=( - f"Argument `input_` must have rank of at least 2, but got shape: " - f"{input_.shape}")) - coil_axis = check_util.validate_type(coil_axis, int, name='coil_axis') - method = check_util.validate_enum( - method, {'walsh', 'inati', 'espirit'}, name='method') - - # Move coil axis to innermost dimension if not already there. - if coil_axis != -1: - rank = input_.shape.rank - canonical_coil_axis = coil_axis + rank if coil_axis < 0 else coil_axis - perm = ( - [ax for ax in range(rank) if not ax == canonical_coil_axis] + - [canonical_coil_axis]) - input_ = tf.transpose(input_, perm) - - if method == 'walsh': - maps = _estimate_coil_sensitivities_walsh(input_, **kwargs) - elif method == 'inati': - maps = _estimate_coil_sensitivities_inati(input_, **kwargs) - elif method == 'espirit': - maps = _estimate_coil_sensitivities_espirit(input_, **kwargs) - else: - raise RuntimeError("This should never happen.") - - # If necessary, move coil axis back to its original location. - if coil_axis != -1: - inv_perm = tf.math.invert_permutation(perm) - if method == 'espirit': - # When using ESPIRiT method, output has an additional `maps` dimension. - inv_perm = tf.concat([inv_perm, [tf.shape(inv_perm)[0]]], 0) - maps = tf.transpose(maps, inv_perm) - - return maps - - @api_util.export("coils.combine_coils") def combine_coils(images, maps=None, coil_axis=-1, keepdims=False): """Sum of squares or adaptive coil combination. @@ -189,226 +78,6 @@ def combine_coils(images, maps=None, coil_axis=-1, keepdims=False): return combined -def _estimate_coil_sensitivities_walsh(images, filter_size=5): - """Estimate coil sensitivity maps using Walsh's method. - - For the parameters, see `estimate_coil_sensitivities`. - """ - rank = images.shape.rank - 1 - image_shape = tf.shape(images)[:-1] - num_coils = tf.shape(images)[-1] - - filter_size = check_util.validate_list( - filter_size, element_type=int, length=rank, name='filter_size') - - # Flatten all spatial dimensions into a single axis, so `images` has shape - # `[num_pixels, num_coils]`. - flat_images = tf.reshape(images, [-1, num_coils]) - - # Compute covariance matrix for each pixel; with shape - # `[num_pixels, num_coils, num_coils]`. - correlation_matrix = tf.math.multiply( - tf.reshape(flat_images, [-1, num_coils, 1]), - tf.math.conj(tf.reshape(flat_images, [-1, 1, num_coils]))) - - # Smooth the covariance tensor along the spatial dimensions. - correlation_matrix = tf.reshape( - correlation_matrix, tf.concat([image_shape, [-1]], 0)) - correlation_matrix = _apply_uniform_filter(correlation_matrix, filter_size) - correlation_matrix = tf.reshape(correlation_matrix, [-1] + [num_coils] * 2) - - # Get sensitivity maps as the dominant eigenvector. - _, eigenvectors = tf.linalg.eig(correlation_matrix) # pylint: disable=no-value-for-parameter - maps = eigenvectors[..., -1] - - # Restore spatial axes. - maps = tf.reshape(maps, tf.concat([image_shape, [num_coils]], 0)) - - return maps - - -def _estimate_coil_sensitivities_inati(images, - filter_size=5, - max_iter=5, - tol=1e-3): - """Estimate coil sensitivity maps using Inati's fast method. - - For the parameters, see `estimate_coil_sensitivities`. - """ - rank = images.shape.rank - 1 - spatial_axes = list(range(rank)) - coil_axis = -1 - - # Validate inputs. - filter_size = check_util.validate_list( - filter_size, element_type=int, length=rank, name='filter_size') - max_iter = check_util.validate_type(max_iter, int, name='max_iter') - tol = check_util.validate_type(tol, float, name='tol') - - d_sum = tf.math.reduce_sum(images, axis=spatial_axes, keepdims=True) - d_sum /= tf.norm(d_sum, axis=coil_axis, keepdims=True) - - r = tf.math.reduce_sum( - tf.math.conj(d_sum) * images, axis=coil_axis, keepdims=True) - - eps = tf.cast( - tnp.finfo(images.dtype).eps * tf.math.reduce_mean(tf.math.abs(images)), - images.dtype) - - State = collections.namedtuple('State', ['i', 'maps', 'r', 'd']) - - def _cond(i, state): - return tf.math.logical_and(i < max_iter, state.d >= tol) - - def _body(i, state): - prev_r = state.r - r = state.r - - r = tf.math.conj(r) - - maps = images * r - smooth_maps = _apply_uniform_filter(maps, filter_size) - d = smooth_maps * tf.math.conj(smooth_maps) - - # Sum over coils. - r = tf.math.reduce_sum(d, axis=coil_axis, keepdims=True) - - r = tf.math.sqrt(r) - r = tf.math.reciprocal(r + eps) - - maps = smooth_maps * r - - d = images * tf.math.conj(maps) - r = tf.math.reduce_sum(d, axis=coil_axis, keepdims=True) - - d = maps * r - - d_sum = tf.math.reduce_sum(d, axis=spatial_axes, keepdims=True) - d_sum /= tf.norm(d_sum, axis=coil_axis, keepdims=True) - - im_t = tf.math.reduce_sum( - tf.math.conj(d_sum) * maps, axis=coil_axis, keepdims=True) - im_t /= (tf.cast(tf.math.abs(im_t), images.dtype) + eps) - r *= im_t - im_t = tf.math.conj(im_t) - maps = maps * im_t - - diff_r = r - prev_r - d = tf.math.abs(tf.norm(diff_r) / tf.norm(r)) - - return i + 1, State(i=i + 1, maps=maps, r=r, d=d) - - i = tf.constant(0, dtype=tf.int32) - state = State(i=i, - maps=tf.zeros_like(images), - r=r, - d=tf.constant(1.0, dtype=images.dtype.real_dtype)) - [i, state] = tf.while_loop(_cond, _body, [i, state]) - - return tf.reshape(state.maps, images.shape) - - -def _estimate_coil_sensitivities_espirit(kspace, - calib_size=24, - kernel_size=6, - num_maps=2, - null_threshold=0.02, - eigen_threshold=0.95, - image_shape=None): - """Estimate coil sensitivity maps using the ESPIRiT method. - - For the parameters, see `estimate_coil_sensitivities`. - """ - kspace = tf.convert_to_tensor(kspace) - rank = kspace.shape.rank - 1 - spatial_axes = list(range(rank)) - num_coils = tf.shape(kspace)[-1] - if image_shape is None: - image_shape = kspace.shape[:-1] - if calib_size is None: - calib_size = image_shape.as_list() - - calib_size = check_util.validate_list( - calib_size, element_type=int, length=rank, name='calib_size') - kernel_size = check_util.validate_list( - kernel_size, element_type=int, length=rank, name='kernel_size') - - with tf.control_dependencies([ - tf.debugging.assert_greater(calib_size, kernel_size, message=( - f"`calib_size` must be greater than `kernel_size`, but got " - f"{calib_size} and {kernel_size}"))]): - kspace = tf.identity(kspace) - - # Get calibration region. - calib = array_ops.central_crop(kspace, calib_size + [-1]) - - # Construct the calibration block Hankel matrix. - conv_size = [cs - ks + 1 for cs, ks in zip(calib_size, kernel_size)] - calib_matrix = tf.zeros([_prod(conv_size), _prod(kernel_size) * num_coils], - dtype=calib.dtype) - idx = 0 - for nd_inds in np.ndindex(*conv_size): - slices = [slice(ii, ii + ks) for ii, ks in zip(nd_inds, kernel_size)] - calib_matrix = tf.tensor_scatter_nd_update( - calib_matrix, [[idx]], tf.reshape(calib[slices], [1, -1])) - idx += 1 - - # Compute SVD decomposition, threshold singular values and reshape V to create - # k-space kernel matrix. - s, _, v = tf.linalg.svd(calib_matrix, full_matrices=True) - num_values = tf.math.count_nonzero(s >= s[0] * null_threshold) - v = v[:, :num_values] - kernel = tf.reshape(v, kernel_size + [num_coils, -1]) - - # Rotate kernel to order by maximum variance. - perm = list(range(kernel.shape.rank)) - perm[-2], perm[-1] = perm[-1], perm[-2] - kernel = tf.transpose(kernel, perm) - kernel = tf.reshape(kernel, [-1, num_coils]) - _, _, rot_matrix = tf.linalg.svd(kernel, full_matrices=False) - kernel = tf.linalg.matmul(kernel, rot_matrix) - kernel = tf.reshape(kernel, kernel_size + [-1, num_coils]) - kernel = tf.transpose(kernel, perm) - - # Compute inverse FFT of k-space kernel. - kernel = tf.reverse(kernel, spatial_axes) - kernel = tf.math.conj(kernel) - - kernel_image = fft_ops.fftn(kernel, - shape=image_shape, - axes=list(range(rank)), - shift=True) - - kernel_image /= tf.cast(tf.sqrt(tf.cast(tf.math.reduce_prod(kernel_size), - kernel_image.dtype.real_dtype)), - kernel_image.dtype) - - values, maps, _ = tf.linalg.svd(kernel_image, full_matrices=False) - - # Apply phase modulation. - maps *= tf.math.exp(tf.complex(tf.constant(0.0, dtype=maps.dtype.real_dtype), - -tf.math.angle(maps[..., 0:1, :]))) - - # Undo rotation. - maps = tf.linalg.matmul(rot_matrix, maps) - - # Keep only the requested number of maps. - values = values[..., :num_maps] - maps = maps[..., :num_maps] - - # Apply thresholding. - mask = tf.expand_dims(values >= eigen_threshold, -2) - maps *= tf.cast(mask, maps.dtype) - - # If possible, set static number of maps. - if isinstance(num_maps, int): - maps_shape = maps.shape.as_list() - maps_shape[-1] = num_maps - maps = tf.ensure_shape(maps, maps_shape) - - return maps - - @api_util.export("coils.compress_coils") def compress_coils(kspace, coil_axis=-1, @@ -658,58 +327,3 @@ def explained_variance(self): def explained_variance_ratio(self): """The percentage of variance explained by each virtual coil.""" return self._explained_variance_ratio - - -def _apply_uniform_filter(tensor, size=5): - """Apply a uniform filter. - - Args: - tensor: A `Tensor`. Must have shape `spatial_shape + [channels]`. - size: An `int`. The size of the filter. Defaults to 5. - - Returns: - A `Tensor`. Has the same type as `tensor`. - """ - rank = tensor.shape.rank - 1 - - # Compute filters. - if isinstance(size, int): - size = [size] * rank - filters_shape = size + [1, 1] - filters = tf.ones(filters_shape, dtype=tensor.dtype.real_dtype) - filters /= _prod(size) - - # Select appropriate convolution function. - conv_nd = { - 1: tf.nn.conv1d, - 2: tf.nn.conv2d, - 3: tf.nn.conv3d}[rank] - - # Move channels dimension to batch dimension. - tensor = tf.transpose(tensor) - - # Add a channels dimension, as required by `tf.nn.conv*` functions. - tensor = tf.expand_dims(tensor, -1) - - if tensor.dtype.is_complex: - # For complex input, we filter the real and imaginary parts separately. - tensor_real = tf.math.real(tensor) - tensor_imag = tf.math.imag(tensor) - - output_real = conv_nd(tensor_real, filters, [1] * (rank + 2), 'SAME') - output_imag = conv_nd(tensor_imag, filters, [1] * (rank + 2), 'SAME') - - output = tf.dtypes.complex(output_real, output_imag) - else: - output = conv_nd(tensor, filters, [1] * (rank + 2), 'SAME') - - # Remove channels dimension. - output = output[..., 0] - - # Move channels dimension back to last dimension. - output = tf.transpose(output) - - return output - - -_prod = lambda iterable: functools.reduce(lambda x, y: x * y, iterable) diff --git a/tensorflow_mri/python/ops/image_ops.py b/tensorflow_mri/python/ops/image_ops.py index 755871bd..5cc32aed 100644 --- a/tensorflow_mri/python/ops/image_ops.py +++ b/tensorflow_mri/python/ops/image_ops.py @@ -103,7 +103,7 @@ def psnr(img1, img2 = tf.image.convert_image_dtype(img2, tf.float32) # Resolve batch and image dimensions. - batch_dims, image_dims = _resolve_batch_and_image_dims( + batch_dims, image_dims = resolve_batch_and_image_dims( img1, batch_dims, image_dims) mse = tf.math.reduce_mean( @@ -262,7 +262,7 @@ def ssim(img1, img2 = tf.image.convert_image_dtype(img2, tf.float32) # Resolve batch and image dimensions. - batch_dims, image_dims = _resolve_batch_and_image_dims( + batch_dims, image_dims = resolve_batch_and_image_dims( img1, batch_dims, image_dims) # Check shapes. @@ -493,7 +493,7 @@ def ssim_multiscale(img1, img2 = tf.image.convert_image_dtype(img2, tf.dtypes.float32) # Resolve batch and image dimensions. - batch_dims, image_dims = _resolve_batch_and_image_dims( + batch_dims, image_dims = resolve_batch_and_image_dims( img1, batch_dims, image_dims) # Shape checking. @@ -933,7 +933,7 @@ def image_gradients(image, method='sobel', norm=False, """ with tf.name_scope(name or 'image_gradients'): image = tf.convert_to_tensor(image) - batch_dims, image_dims = _resolve_batch_and_image_dims( + batch_dims, image_dims = resolve_batch_and_image_dims( image, batch_dims, image_dims) kernels = _gradient_operators( @@ -1322,7 +1322,7 @@ def _validate_iqa_inputs(img1, img2, max_val, batch_dims, image_dims): img2 = tf.image.convert_image_dtype(img2, tf.float32) # Resolve batch and image dimensions. - batch_dims, image_dims = _resolve_batch_and_image_dims( + batch_dims, image_dims = resolve_batch_and_image_dims( img1, batch_dims, image_dims) # Check that the image shapes are compatible. @@ -1974,7 +1974,7 @@ def extract_and_scale_complex_part(value, part, max_val): return value -def _resolve_batch_and_image_dims(image, batch_dims, image_dims): +def resolve_batch_and_image_dims(image, batch_dims, image_dims): """Resolves `batch_dims` and `image_dims` for a given `image`. Args: diff --git a/tensorflow_mri/python/ops/image_ops_test.py b/tensorflow_mri/python/ops/image_ops_test.py index 80f54c0e..1d5ccc25 100644 --- a/tensorflow_mri/python/ops/image_ops_test.py +++ b/tensorflow_mri/python/ops/image_ops_test.py @@ -870,7 +870,7 @@ def _np_birdcage_sensitivities(self, shape, r=1.5, nzz=8, dtype=np.complex64): # class TestResolveBatchAndImageDims(test_util.TestCase): - """Tests for `_resolve_batch_and_image_dims`.""" + """Tests for `resolve_batch_and_image_dims`.""" # pylint: disable=missing-function-docstring @parameterized.parameters( # rank, batch_dims, image_dims, expected_batch_dims, expected_image_dims @@ -885,7 +885,7 @@ def test_resolve_batch_and_image_dims( self, rank, input_batch_dims, input_image_dims, expected_batch_dims, expected_image_dims): image = tf.zeros((4,) * rank) - batch_dims, image_dims = image_ops._resolve_batch_and_image_dims( # pylint: disable=protected-access + batch_dims, image_dims = image_ops.resolve_batch_and_image_dims( # pylint: disable=protected-access image, input_batch_dims, input_image_dims) self.assertEqual(expected_batch_dims, batch_dims) self.assertEqual(expected_image_dims, image_dims) diff --git a/tensorflow_mri/python/ops/signal_ops.py b/tensorflow_mri/python/ops/signal_ops.py index eddc9a68..fbd02819 100644 --- a/tensorflow_mri/python/ops/signal_ops.py +++ b/tensorflow_mri/python/ops/signal_ops.py @@ -99,6 +99,36 @@ def atanfilt(arg, cutoff=np.pi, beta=100.0, name=None): return 0.5 + (1.0 / np.pi) * tf.math.atan(beta * (cutoff - arg) / cutoff) +@api_util.export("signal.rect") +def rect(arg, cutoff=np.pi, name=None): + """Returns the rectangular function. + + The rectangular function is defined as: + + .. math:: + \operatorname{rect}(x) = \Pi(t) = + \left\{\begin{array}{rl} + 0, & \text{if } |x| > \pi \\ + \frac{1}{2}, & \text{if } |x| = \pi \\ + 1, & \text{if } |x| < \pi. + \end{array}\right. + + Args: + arg: Input tensor. + cutoff: A `float` in the range [0, pi]. The cutoff frequency of the filter. + name: Name to use for the scope. + + Returns: + A `Tensor` of shape `arg.shape`. + """ + with tf.name_scope(name or 'rect'): + one = tf.constant(1.0, dtype=arg.dtype) + zero = tf.constant(0.0, dtype=arg.dtype) + half = tf.constant(0.5, dtype=arg.dtype) + return tf.where(tf.math.abs(arg) == cutoff, + half, tf.where(tf.math.abs(arg) < cutoff, one, zero)) + + @api_util.export("signal.filter_kspace") def filter_kspace(kspace, trajectory=None, @@ -114,9 +144,9 @@ def filter_kspace(kspace, trajectory: A `Tensor` of shape `kspace.shape + [N]`, where `N` is the number of spatial dimensions. If `None`, `kspace` is assumed to be Cartesian. - filter_fn: A `str` (one of `'hamming'`, `'hann'` or `'atanfilt'`) or a - callable that accepts a coordinate array and returns corresponding filter - values. + filter_fn: A `str` (one of `'rect'`, `'hamming'`, `'hann'` or `'atanfilt'`) + or a callable that accepts a coordinate array and returns corresponding + filter values. filter_rank: An `int`. The rank of the filter. Only relevant if *k*-space is Cartesian. Defaults to `kspace.shape.rank`. filter_kwargs: A `dict`. Additional keyword arguments to pass to the @@ -150,9 +180,10 @@ def filter_kspace(kspace, # filter_fn not a callable, so should be an enum value. Get the # corresponding function. filter_fn = check_util.validate_enum( - filter_fn, valid_values={'hamming', 'hann', 'atanfilt'}, + filter_fn, valid_values={'rect', 'hamming', 'hann', 'atanfilt'}, name='filter_fn') filter_fn = { + 'rect': rect, 'hamming': hamming, 'hann': hann, 'atanfilt': atanfilt diff --git a/tensorflow_mri/python/ops/signal_ops_test.py b/tensorflow_mri/python/ops/signal_ops_test.py index f7976660..c788c9e2 100755 --- a/tensorflow_mri/python/ops/signal_ops_test.py +++ b/tensorflow_mri/python/ops/signal_ops_test.py @@ -60,6 +60,13 @@ def test_atanfilt(self): result = signal_ops.atanfilt(x) self.assertAllClose(expected, result) + def test_rect(self): + """Test rectangular function.""" + x = [-3.1, -1.3, -0.2, 0.0, 0.4, 1.0, 3.1] + expected = [0.0, 0.0, 1.0, 1.0, 1.0, 0.5, 0.0] + result = signal_ops.rect(x, cutoff=1.0) + self.assertAllClose(expected, result) + class KSpaceFilterTest(test_util.TestCase): """Test k-space filters.""" From fcc720b42f252ab6b8a74fa9cec2c6c47b0f1583 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 17 Aug 2022 09:56:11 +0000 Subject: [PATCH 016/101] Fixed a bug in base linear operator --- tensorflow_mri/_api/coils/__init__.py | 2 ++ tensorflow_mri/_api/signal/__init__.py | 1 + tensorflow_mri/python/coils/__init__.py | 17 +++++++++++++++++ tensorflow_mri/python/linalg/linear_operator.py | 2 +- 4 files changed, 21 insertions(+), 1 deletion(-) diff --git a/tensorflow_mri/_api/coils/__init__.py b/tensorflow_mri/_api/coils/__init__.py index 401cc580..99b8a7d8 100644 --- a/tensorflow_mri/_api/coils/__init__.py +++ b/tensorflow_mri/_api/coils/__init__.py @@ -2,6 +2,8 @@ # Do not edit. """Parallel imaging operations.""" +from tensorflow_mri.python.coils.coil_sensitivities import coil_sensitivities as custom_sensitivities +from tensorflow_mri.python.coils.coil_sensitivities import estimate_coil_sensitivities as estimate_sensitivities from tensorflow_mri.python.ops.coil_ops import combine_coils as combine_coils from tensorflow_mri.python.ops.coil_ops import compress_coils as compress_coils from tensorflow_mri.python.ops.coil_ops import CoilCompressorSVD as CoilCompressorSVD diff --git a/tensorflow_mri/_api/signal/__init__.py b/tensorflow_mri/_api/signal/__init__.py index b8e37ce3..fbe3cdc9 100644 --- a/tensorflow_mri/_api/signal/__init__.py +++ b/tensorflow_mri/_api/signal/__init__.py @@ -15,5 +15,6 @@ from tensorflow_mri.python.ops.signal_ops import hann as hann from tensorflow_mri.python.ops.signal_ops import hamming as hamming from tensorflow_mri.python.ops.signal_ops import atanfilt as atanfilt +from tensorflow_mri.python.ops.signal_ops import rect as rect from tensorflow_mri.python.ops.signal_ops import filter_kspace as filter_kspace from tensorflow_mri.python.ops.signal_ops import crop_kspace as crop_kspace diff --git a/tensorflow_mri/python/coils/__init__.py b/tensorflow_mri/python/coils/__init__.py index e69de29b..77758f16 100644 --- a/tensorflow_mri/python/coils/__init__.py +++ b/tensorflow_mri/python/coils/__init__.py @@ -0,0 +1,17 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Operators for coil arrays.""" + +from tensorflow_mri.python.coils import coil_sensitivities diff --git a/tensorflow_mri/python/linalg/linear_operator.py b/tensorflow_mri/python/linalg/linear_operator.py index 0b493d36..4d6f5a84 100644 --- a/tensorflow_mri/python/linalg/linear_operator.py +++ b/tensorflow_mri/python/linalg/linear_operator.py @@ -91,7 +91,7 @@ def postprocess(self, x, adjoint=False, name="postprocess"): with self._name_scope(name): x = tf.convert_to_tensor(x, name="x") self._check_input_dtype(x) - input_shape = self.range_shape if adjoint else self.domain_shape + input_shape = self.domain_shape if adjoint else self.range_shape input_shape.assert_is_compatible_with(x.shape[-input_shape.rank:]) # pylint: disable=invalid-unary-operand-type return self._postprocess(x, adjoint=adjoint) From df4c1489af76b0ca31c1a0e767f91f469148ba5b Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 17 Aug 2022 14:48:57 +0000 Subject: [PATCH 017/101] Improvements to documentation --- tensorflow_mri/python/coils/coil_sensitivities.py | 6 +++++- tensorflow_mri/python/models/conv_endec.py | 12 ++++++++++++ tools/docs/conf.py | 5 +++-- 3 files changed, 20 insertions(+), 3 deletions(-) diff --git a/tensorflow_mri/python/coils/coil_sensitivities.py b/tensorflow_mri/python/coils/coil_sensitivities.py index e3855cf5..e4e1ae43 100644 --- a/tensorflow_mri/python/coils/coil_sensitivities.py +++ b/tensorflow_mri/python/coils/coil_sensitivities.py @@ -46,7 +46,11 @@ def coil_sensitivities(kspace, )) # Reconstruct image. - inputs = operator.transform(kspace, adjoint=True) + inputs = operator.postprocess( + operator.transform( + operator.preprocess(kspace, adjoint=True), + adjoint=True), + adjoint=True) # ESPIRiT method takes in k-space data, so convert back to k-space in this # case. diff --git a/tensorflow_mri/python/models/conv_endec.py b/tensorflow_mri/python/models/conv_endec.py index 5d814105..f79799cf 100644 --- a/tensorflow_mri/python/models/conv_endec.py +++ b/tensorflow_mri/python/models/conv_endec.py @@ -14,6 +14,7 @@ # ============================================================================== """Convolutional encoder-decoder models.""" +import inspect import string import tensorflow as tf @@ -368,3 +369,14 @@ def __init__(self, *args, **kwargs): UNet1D.__doc__ = UNET_DOC_TEMPLATE.substitute(rank=1) UNet2D.__doc__ = UNET_DOC_TEMPLATE.substitute(rank=2) UNet3D.__doc__ = UNET_DOC_TEMPLATE.substitute(rank=3) + + +# Set explicit signatures for the UNetND objects. Otherwise they will appear as +# (*args, **kwargs) in the docs. +signature = inspect.signature(UNet.__init__) +parameters = signature.parameters +parameters = [v for k, v in parameters.items() if k not in ('self', 'rank')] +signature = signature.replace(parameters=parameters) +UNet1D.__signature__ = signature +UNet2D.__signature__ = signature +UNet3D.__signature__ = signature diff --git a/tools/docs/conf.py b/tools/docs/conf.py index b7f201c6..d09d3726 100644 --- a/tools/docs/conf.py +++ b/tools/docs/conf.py @@ -161,8 +161,9 @@ def linkcode_resolve(domain, info): Returns: The GitHub URL to the object, or `None` if not relevant. """ - if info['fullname'] == 'nufft': - # Can't provide link for nufft, since it lives in external package. + custom_ops = {'nufft', 'spiral_waveform'} + if info['fullname'] in custom_ops: + # Can't provide link to source for custom ops. return None # Obtain fully-qualified name of object. From dc7740fc5d8462a919b5bcfa8e533d61004d10c6 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 17 Aug 2022 15:49:36 +0000 Subject: [PATCH 018/101] Add ReconAdjoint layer --- tensorflow_mri/python/layers/__init__.py | 5 +- tensorflow_mri/python/layers/recon_adjoint.py | 65 +++++++++++++++++++ .../python/layers/recon_adjoint_test.py | 51 +++++++++++++++ 3 files changed, 120 insertions(+), 1 deletion(-) create mode 100644 tensorflow_mri/python/layers/recon_adjoint.py create mode 100644 tensorflow_mri/python/layers/recon_adjoint_test.py diff --git a/tensorflow_mri/python/layers/__init__.py b/tensorflow_mri/python/layers/__init__.py index 4e1d41d0..89bd6e55 100644 --- a/tensorflow_mri/python/layers/__init__.py +++ b/tensorflow_mri/python/layers/__init__.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. @@ -15,10 +15,13 @@ """Keras layers.""" from tensorflow_mri.python.layers import convolutional +from tensorflow_mri.python.layers import coil_sensitivities from tensorflow_mri.python.layers import conv_blocks from tensorflow_mri.python.layers import conv_endec from tensorflow_mri.python.layers import data_consistency +from tensorflow_mri.python.layers import kspace_scaling from tensorflow_mri.python.layers import pooling from tensorflow_mri.python.layers import preproc_layers +from tensorflow_mri.python.layers import recon_adjoint from tensorflow_mri.python.layers import reshaping from tensorflow_mri.python.layers import signal_layers diff --git a/tensorflow_mri/python/layers/recon_adjoint.py b/tensorflow_mri/python/layers/recon_adjoint.py new file mode 100644 index 00000000..9ceca76f --- /dev/null +++ b/tensorflow_mri/python/layers/recon_adjoint.py @@ -0,0 +1,65 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Adjoint reconstruction layer.""" + +import tensorflow as tf + +from tensorflow_mri.python.layers import linear_operator_layer +from tensorflow_mri.python.linalg import linear_operator_mri +from tensorflow_mri.python.recon import recon_adjoint +from tensorflow_mri.python.util import api_util + + +@api_util.export("layers.ReconAdjoint") +@tf.keras.utils.register_keras_serializable(package="MRI") +class ReconAdjoint(linear_operator_layer.LinearOperatorLayer): + """Adjoint reconstruction layer. + + This layer reconstructs a signal using the adjoint of the system operator. + """ + def __init__(self, + operator=linear_operator_mri.LinearOperatorMRI, + kspace_index=None, + **kwargs): + """Initializes the layer.""" + super().__init__(operator=operator, input_indices=kspace_index, **kwargs) + + def call(self, inputs): + """Applies the layer. + + Args: + inputs: A `tuple` or `dict` containing the *k*-space data as defined by + `kspace_index`. If `operator` is a class not an instance, then `inputs` + must also contain any other arguments to be passed to the constructor of + `operator`. + + Returns: + The reconstructed k-space data. + """ + kspace, operator = self.parse_inputs(inputs) + image = recon_adjoint.recon_adjoint(kspace, operator) + return image + + def get_config(self): + """Returns the config of the layer. + + Returns: + A `dict` describing the layer configuration. + """ + config = super().get_config() + kspace_index = config.pop('input_indices') + if kspace_index is not None: + kspace_index = kspace_index[0] + return config diff --git a/tensorflow_mri/python/layers/recon_adjoint_test.py b/tensorflow_mri/python/layers/recon_adjoint_test.py new file mode 100644 index 00000000..281b895b --- /dev/null +++ b/tensorflow_mri/python/layers/recon_adjoint_test.py @@ -0,0 +1,51 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Tests for module `recon_adjoint`.""" + +import tensorflow as tf + +from tensorflow_mri.python.layers import recon_adjoint as recon_adjoint_layer +from tensorflow_mri.python.recon import recon_adjoint +from tensorflow_mri.python.util import test_util + + +class ReconAdjointTest(test_util.TestCase): + def test_recon_adjoint(self): + # Create layer. + layer = recon_adjoint_layer.ReconAdjoint() + + # Generate k-space data. + image_shape = tf.constant([4, 4]) + kspace = tf.dtypes.complex( + tf.random.stateless_normal(shape=image_shape, seed=[11, 22]), + tf.random.stateless_normal(shape=image_shape, seed=[12, 34])) + + # Reconstruct image. + expected = recon_adjoint.recon_adjoint_mri(kspace, image_shape) + + # Test with tuple inputs. + inputs = (kspace, image_shape) + result = layer(inputs) + self.assertAllClose(expected, result) + + # Test with dict inputs. + inputs = {'kspace': kspace, 'image_shape': image_shape} + result = layer(inputs) + self.assertAllClose(expected, result) + + # Test (de)serialization. + layer = recon_adjoint_layer.ReconAdjoint.from_config(layer.get_config()) + result = layer(inputs) + self.assertAllClose(expected, result) From de4ec460b53ee48232b2531966857c63d58cd3ec Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 17 Aug 2022 17:01:08 +0000 Subject: [PATCH 019/101] Add separable filter --- .../python/layers/kspace_scaling.py | 5 + tensorflow_mri/python/ops/signal_ops.py | 114 +++++++++++------- tensorflow_mri/python/ops/signal_ops_test.py | 20 +++ 3 files changed, 98 insertions(+), 41 deletions(-) diff --git a/tensorflow_mri/python/layers/kspace_scaling.py b/tensorflow_mri/python/layers/kspace_scaling.py index 182d7283..631a5d82 100644 --- a/tensorflow_mri/python/layers/kspace_scaling.py +++ b/tensorflow_mri/python/layers/kspace_scaling.py @@ -19,8 +19,11 @@ from tensorflow_mri.python.layers import linear_operator_layer from tensorflow_mri.python.linalg import linear_operator_mri from tensorflow_mri.python.recon import recon_adjoint +from tensorflow_mri.python.util import api_util +@api_util.export("layers.KSpaceScaling") +@tf.keras.utils.register_keras_serializable(package="MRI") class KSpaceScaling(linear_operator_layer.LinearOperatorLayer): """K-space scaling layer. @@ -28,6 +31,7 @@ class KSpaceScaling(linear_operator_layer.LinearOperatorLayer): values between 0 and 1. """ def __init__(self, + calib_region, operator=linear_operator_mri.LinearOperatorMRI, kspace_index=None, **kwargs): @@ -47,6 +51,7 @@ def call(self, inputs): The scaled k-space data. """ kspace, operator = self.parse_inputs(inputs) + # kspace = image = recon_adjoint.recon_adjoint(kspace, operator) return kspace / tf.cast(tf.math.reduce_max(tf.math.abs(image)), kspace.dtype) diff --git a/tensorflow_mri/python/ops/signal_ops.py b/tensorflow_mri/python/ops/signal_ops.py index fbd02819..a8a30d2d 100644 --- a/tensorflow_mri/python/ops/signal_ops.py +++ b/tensorflow_mri/python/ops/signal_ops.py @@ -114,14 +114,16 @@ def rect(arg, cutoff=np.pi, name=None): \end{array}\right. Args: - arg: Input tensor. - cutoff: A `float` in the range [0, pi]. The cutoff frequency of the filter. + arg: The input `tf.Tensor`. + cutoff: A scalar `tf.Tensor` in the range `[0, pi]`. + The cutoff frequency of the filter. name: Name to use for the scope. Returns: - A `Tensor` of shape `arg.shape`. + A `tf.Tensor` with the same shape and type as `arg`. """ with tf.name_scope(name or 'rect'): + arg = tf.convert_to_tensor(arg) one = tf.constant(1.0, dtype=arg.dtype) zero = tf.constant(0.0, dtype=arg.dtype) half = tf.constant(0.5, dtype=arg.dtype) @@ -129,12 +131,40 @@ def rect(arg, cutoff=np.pi, name=None): half, tf.where(tf.math.abs(arg) < cutoff, one, zero)) +def separable_filter(func): + """Returns a function that computes a separable filter. + + This function creates a separable N-D filters as the outer product of 1D + filters along different dimensions. + + Args: + func: A 1D filter function. Must have signature `func(x, *args)`. + + Returns: + A function that computes a separable filter. Has signature `func(x, *args)`, + where `x` is a `tf.Tensor` of shape `[..., N]` and each element of `args` is + a `tf.Tensor` of shape `[N, ...]`. Each element of `*args` will be unpacked + along the first dimension. + """ + def wrapper(x, *args): + # Convert each input to a tensor. + args = tuple(tf.convert_to_tensor(arg) for arg in args) + def fn(accumulator, current): + index, value = accumulator + return index + 1, value * func(x[..., index], *current) + initializer = tf.constant(1.0, dtype=x.dtype) + _, out = tf.foldl(fn, args, initializer=(0, initializer)) + return out + return wrapper + + @api_util.export("signal.filter_kspace") def filter_kspace(kspace, trajectory=None, filter_fn='hamming', filter_rank=None, - filter_kwargs=None): + filter_kwargs=None, + name=None): """Filter *k*-space. Multiplies *k*-space by a filtering function. @@ -151,47 +181,49 @@ def filter_kspace(kspace, Cartesian. Defaults to `kspace.shape.rank`. filter_kwargs: A `dict`. Additional keyword arguments to pass to the filtering function. + name: Name to use for the scope. Returns: A `Tensor` of shape `kspace.shape`. The filtered *k*-space. """ - kspace = tf.convert_to_tensor(kspace) - if trajectory is not None: - kspace, trajectory = check_util.verify_compatible_trajectory( - kspace, trajectory) - - # Make a "trajectory" for Cartesian k-spaces. - is_cartesian = trajectory is None - if is_cartesian: - filter_rank = filter_rank or kspace.shape.rank - vecs = tf.TensorArray(dtype=kspace.dtype.real_dtype, - size=filter_rank, - infer_shape=False, - clear_after_read=False) - for i in range(-filter_rank, 0): - size = tf.shape(kspace)[i] - pi = tf.cast(np.pi, kspace.dtype.real_dtype) - low = -pi - high = pi - (2.0 * pi / tf.cast(size, kspace.dtype.real_dtype)) - vecs = vecs.write(i + filter_rank, tf.linspace(low, high, size)) - trajectory = array_ops.dynamic_meshgrid(vecs) - - if not callable(filter_fn): - # filter_fn not a callable, so should be an enum value. Get the - # corresponding function. - filter_fn = check_util.validate_enum( - filter_fn, valid_values={'rect', 'hamming', 'hann', 'atanfilt'}, - name='filter_fn') - filter_fn = { - 'rect': rect, - 'hamming': hamming, - 'hann': hann, - 'atanfilt': atanfilt - }[filter_fn] - filter_kwargs = filter_kwargs or {} - - traj_norm = tf.norm(trajectory, axis=-1) - return kspace * tf.cast(filter_fn(traj_norm, **filter_kwargs), kspace.dtype) + with tf.name_scope(name or 'filter_kspace'): + kspace = tf.convert_to_tensor(kspace) + if trajectory is not None: + kspace, trajectory = check_util.verify_compatible_trajectory( + kspace, trajectory) + + # Make a "trajectory" for Cartesian k-spaces. + is_cartesian = trajectory is None + if is_cartesian: + filter_rank = filter_rank or kspace.shape.rank + vecs = tf.TensorArray(dtype=kspace.dtype.real_dtype, + size=filter_rank, + infer_shape=False, + clear_after_read=False) + for i in range(-filter_rank, 0): + size = tf.shape(kspace)[i] + pi = tf.cast(np.pi, kspace.dtype.real_dtype) + low = -pi + high = pi - (2.0 * pi / tf.cast(size, kspace.dtype.real_dtype)) + vecs = vecs.write(i + filter_rank, tf.linspace(low, high, size)) + trajectory = array_ops.dynamic_meshgrid(vecs) + + if not callable(filter_fn): + # filter_fn not a callable, so should be an enum value. Get the + # corresponding function. + filter_fn = check_util.validate_enum( + filter_fn, valid_values={'rect', 'hamming', 'hann', 'atanfilt'}, + name='filter_fn') + filter_fn = { + 'rect': rect, + 'hamming': hamming, + 'hann': hann, + 'atanfilt': atanfilt + }[filter_fn] + filter_kwargs = filter_kwargs or {} + + traj_norm = tf.norm(trajectory, axis=-1) + return kspace * tf.cast(filter_fn(traj_norm, **filter_kwargs), kspace.dtype) @api_util.export("signal.crop_kspace") diff --git a/tensorflow_mri/python/ops/signal_ops_test.py b/tensorflow_mri/python/ops/signal_ops_test.py index c788c9e2..8d5f9199 100755 --- a/tensorflow_mri/python/ops/signal_ops_test.py +++ b/tensorflow_mri/python/ops/signal_ops_test.py @@ -67,6 +67,25 @@ def test_rect(self): result = signal_ops.rect(x, cutoff=1.0) self.assertAllClose(expected, result) + def test_separable_rect(self): + """Test separable rectangular function.""" + x = array_ops.meshgrid( + [-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0], + [-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0]) + + separable_rect = signal_ops.separable_filter(signal_ops.rect) + result = separable_rect(x, (1.0, 0.5)) + expected = [[0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. ], + [0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. ], + [0. , 0. , 0. , 0.25, 0.5 , 0.25, 0. , 0. , 0. ], + [0. , 0. , 0. , 0.5 , 1. , 0.5 , 0. , 0. , 0. ], + [0. , 0. , 0. , 0.5 , 1. , 0.5 , 0. , 0. , 0. ], + [0. , 0. , 0. , 0.5 , 1. , 0.5 , 0. , 0. , 0. ], + [0. , 0. , 0. , 0.25, 0.5 , 0.25, 0. , 0. , 0. ], + [0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. ], + [0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. ]] + self.assertAllClose(expected, result) + class KSpaceFilterTest(test_util.TestCase): """Test k-space filters.""" @@ -150,5 +169,6 @@ def test_filter_custom_fn(self): kspace, trajectory=traj, filter_fn=filter_fn) self.assertAllClose(expected, result) + if __name__ == '__main__': tf.test.main() From 21ccdb7929ae822bd7371490331d9f8377da0ca8 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 17 Aug 2022 17:08:29 +0000 Subject: [PATCH 020/101] Improved separable filter --- tensorflow_mri/python/ops/signal_ops.py | 18 ++++++++++-------- tensorflow_mri/python/ops/signal_ops_test.py | 10 +++++++--- 2 files changed, 17 insertions(+), 11 deletions(-) diff --git a/tensorflow_mri/python/ops/signal_ops.py b/tensorflow_mri/python/ops/signal_ops.py index a8a30d2d..2cac124a 100644 --- a/tensorflow_mri/python/ops/signal_ops.py +++ b/tensorflow_mri/python/ops/signal_ops.py @@ -138,22 +138,24 @@ def separable_filter(func): filters along different dimensions. Args: - func: A 1D filter function. Must have signature `func(x, *args)`. + func: A 1D filter function. Must have signature `func(x, *args, **kwargs)`. Returns: - A function that computes a separable filter. Has signature `func(x, *args)`, - where `x` is a `tf.Tensor` of shape `[..., N]` and each element of `args` is - a `tf.Tensor` of shape `[N, ...]`. Each element of `*args` will be unpacked - along the first dimension. + A function that computes a separable filter. Has signature + `func(x, *args, **kwargs)`, where `x` is a `tf.Tensor` of shape `[..., N]` + and each element of `args` and `kwargs is a `tf.Tensor` of shape `[N, ...]`, + which will be unpacked along the first dimension. """ - def wrapper(x, *args): + def wrapper(x, *args, **kwargs): # Convert each input to a tensor. args = tuple(tf.convert_to_tensor(arg) for arg in args) + kwargs = {k: tf.convert_to_tensor(v) for k, v in kwargs.items()} def fn(accumulator, current): index, value = accumulator - return index + 1, value * func(x[..., index], *current) + args, kwargs = current + return index + 1, value * func(x[..., index], *args, **kwargs) initializer = tf.constant(1.0, dtype=x.dtype) - _, out = tf.foldl(fn, args, initializer=(0, initializer)) + _, out = tf.foldl(fn, (args, kwargs), initializer=(0, initializer)) return out return wrapper diff --git a/tensorflow_mri/python/ops/signal_ops_test.py b/tensorflow_mri/python/ops/signal_ops_test.py index 8d5f9199..63d092cb 100755 --- a/tensorflow_mri/python/ops/signal_ops_test.py +++ b/tensorflow_mri/python/ops/signal_ops_test.py @@ -72,9 +72,6 @@ def test_separable_rect(self): x = array_ops.meshgrid( [-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0], [-2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0]) - - separable_rect = signal_ops.separable_filter(signal_ops.rect) - result = separable_rect(x, (1.0, 0.5)) expected = [[0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. ], [0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. ], [0. , 0. , 0. , 0.25, 0.5 , 0.25, 0. , 0. , 0. ], @@ -84,6 +81,13 @@ def test_separable_rect(self): [0. , 0. , 0. , 0.25, 0.5 , 0.25, 0. , 0. , 0. ], [0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. ], [0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. ]] + + separable_rect = signal_ops.separable_filter(signal_ops.rect) + + result = separable_rect(x, (1.0, 0.5)) + self.assertAllClose(expected, result) + + result = separable_rect(x, cutoff=(1.0, 0.5)) self.assertAllClose(expected, result) From 4057f444946e3819e7e6022e7f401cee74eb5c79 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 17 Aug 2022 17:25:24 +0000 Subject: [PATCH 021/101] Add separable argument to filter_kspace --- tensorflow_mri/python/ops/signal_ops.py | 28 ++++++++++++++++++++----- 1 file changed, 23 insertions(+), 5 deletions(-) diff --git a/tensorflow_mri/python/ops/signal_ops.py b/tensorflow_mri/python/ops/signal_ops.py index 2cac124a..c08eea79 100644 --- a/tensorflow_mri/python/ops/signal_ops.py +++ b/tensorflow_mri/python/ops/signal_ops.py @@ -166,6 +166,7 @@ def filter_kspace(kspace, filter_fn='hamming', filter_rank=None, filter_kwargs=None, + separable=False, name=None): """Filter *k*-space. @@ -177,12 +178,19 @@ def filter_kspace(kspace, number of spatial dimensions. If `None`, `kspace` is assumed to be Cartesian. filter_fn: A `str` (one of `'rect'`, `'hamming'`, `'hann'` or `'atanfilt'`) - or a callable that accepts a coordinate array and returns corresponding - filter values. + or a callable that accepts a coordinates array and returns corresponding + filter values. The passed coordinates array will have shape `kspace.shape` + if `separable=False` and `[*kspace.shape, N]` if `separable=True`. filter_rank: An `int`. The rank of the filter. Only relevant if *k*-space is Cartesian. Defaults to `kspace.shape.rank`. filter_kwargs: A `dict`. Additional keyword arguments to pass to the filtering function. + separable: A `boolean`. If `True`, the input *k*-space will be filtered + using an N-D separable window instead of a circularly symmetric window. + If `filter_fn` has one of the default string values, the function is + automatically made separable. If `filter_fn` is a custom callable, it is + the responsibility of the user to ensure that the passed callable is + appropriate. name: Name to use for the scope. Returns: @@ -210,6 +218,11 @@ def filter_kspace(kspace, vecs = vecs.write(i + filter_rank, tf.linspace(low, high, size)) trajectory = array_ops.dynamic_meshgrid(vecs) + # For non-separable filters, use the frequency magnitude (circularly + # symmetric filter). + if not separable: + trajectory = tf.norm(trajectory, axis=-1) + if not callable(filter_fn): # filter_fn not a callable, so should be an enum value. Get the # corresponding function. @@ -222,10 +235,15 @@ def filter_kspace(kspace, 'hann': hann, 'atanfilt': atanfilt }[filter_fn] - filter_kwargs = filter_kwargs or {} - traj_norm = tf.norm(trajectory, axis=-1) - return kspace * tf.cast(filter_fn(traj_norm, **filter_kwargs), kspace.dtype) + if separable: + # The above functions are 1D. If `separable` is `True`, make them N-D + # by wrapping them with `separable_filter`. + filter_fn = separable_filter(filter_fn) + + filter_kwargs = filter_kwargs or {} # Make sure it's a dict. + filter_values = filter_fn(trajectory, **filter_kwargs) + return kspace * tf.cast(filter_values, kspace.dtype) @api_util.export("signal.crop_kspace") From e22dc52eebcdd3097e2a1dd9872192ac4e2a38fe Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 17 Aug 2022 17:27:40 +0000 Subject: [PATCH 022/101] Renamed separable_window --- tensorflow_mri/python/ops/signal_ops.py | 13 +++++++------ tensorflow_mri/python/ops/signal_ops_test.py | 2 +- 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/tensorflow_mri/python/ops/signal_ops.py b/tensorflow_mri/python/ops/signal_ops.py index c08eea79..d130e67b 100644 --- a/tensorflow_mri/python/ops/signal_ops.py +++ b/tensorflow_mri/python/ops/signal_ops.py @@ -131,17 +131,18 @@ def rect(arg, cutoff=np.pi, name=None): half, tf.where(tf.math.abs(arg) < cutoff, one, zero)) -def separable_filter(func): - """Returns a function that computes a separable filter. +@api_util.export("signal.separable_window") +def separable_window(func): + """Returns a function that computes a separable window. This function creates a separable N-D filters as the outer product of 1D filters along different dimensions. Args: - func: A 1D filter function. Must have signature `func(x, *args, **kwargs)`. + func: A 1D window function. Must have signature `func(x, *args, **kwargs)`. Returns: - A function that computes a separable filter. Has signature + A function that computes a separable window. Has signature `func(x, *args, **kwargs)`, where `x` is a `tf.Tensor` of shape `[..., N]` and each element of `args` and `kwargs is a `tf.Tensor` of shape `[N, ...]`, which will be unpacked along the first dimension. @@ -238,8 +239,8 @@ def filter_kspace(kspace, if separable: # The above functions are 1D. If `separable` is `True`, make them N-D - # by wrapping them with `separable_filter`. - filter_fn = separable_filter(filter_fn) + # by wrapping them with `separable_window`. + filter_fn = separable_window(filter_fn) filter_kwargs = filter_kwargs or {} # Make sure it's a dict. filter_values = filter_fn(trajectory, **filter_kwargs) diff --git a/tensorflow_mri/python/ops/signal_ops_test.py b/tensorflow_mri/python/ops/signal_ops_test.py index 63d092cb..b609306d 100755 --- a/tensorflow_mri/python/ops/signal_ops_test.py +++ b/tensorflow_mri/python/ops/signal_ops_test.py @@ -82,7 +82,7 @@ def test_separable_rect(self): [0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. ], [0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. ]] - separable_rect = signal_ops.separable_filter(signal_ops.rect) + separable_rect = signal_ops.separable_window(signal_ops.rect) result = separable_rect(x, (1.0, 0.5)) self.assertAllClose(expected, result) From 43a8a709a30a6b5b8c6f288181f93dad08ebd752 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 17 Aug 2022 17:33:03 +0000 Subject: [PATCH 023/101] Improved implementation of separable_window --- tensorflow_mri/python/ops/signal_ops.py | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/tensorflow_mri/python/ops/signal_ops.py b/tensorflow_mri/python/ops/signal_ops.py index d130e67b..bd8affa8 100644 --- a/tensorflow_mri/python/ops/signal_ops.py +++ b/tensorflow_mri/python/ops/signal_ops.py @@ -152,12 +152,14 @@ def wrapper(x, *args, **kwargs): args = tuple(tf.convert_to_tensor(arg) for arg in args) kwargs = {k: tf.convert_to_tensor(v) for k, v in kwargs.items()} def fn(accumulator, current): - index, value = accumulator - args, kwargs = current - return index + 1, value * func(x[..., index], *args, **kwargs) + x, args, kwargs = current + return accumulator * func(x, *args, **kwargs) + # Move last axis to front. + perm = tf.concat([[tf.rank(x) - 1], tf.range(0, tf.rank(x) - 1)], 0) + x = tf.transpose(x, perm) + # Initialize as 1.0. initializer = tf.constant(1.0, dtype=x.dtype) - _, out = tf.foldl(fn, (args, kwargs), initializer=(0, initializer)) - return out + return tf.foldl(fn, (x, args, kwargs), initializer=initializer) return wrapper From d29e516355d8bce217d515e093d9e979ea0a81a6 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 17 Aug 2022 17:52:29 +0000 Subject: [PATCH 024/101] Fixed k-space scaling layer --- .../python/layers/kspace_scaling.py | 21 +++++++++++++++---- .../python/layers/kspace_scaling_test.py | 9 +++++++- 2 files changed, 25 insertions(+), 5 deletions(-) diff --git a/tensorflow_mri/python/layers/kspace_scaling.py b/tensorflow_mri/python/layers/kspace_scaling.py index 631a5d82..4d91413e 100644 --- a/tensorflow_mri/python/layers/kspace_scaling.py +++ b/tensorflow_mri/python/layers/kspace_scaling.py @@ -14,10 +14,12 @@ # ============================================================================== """*k*-space scaling layer.""" +import numpy as np import tensorflow as tf from tensorflow_mri.python.layers import linear_operator_layer from tensorflow_mri.python.linalg import linear_operator_mri +from tensorflow_mri.python.ops import signal_ops from tensorflow_mri.python.recon import recon_adjoint from tensorflow_mri.python.util import api_util @@ -28,15 +30,18 @@ class KSpaceScaling(linear_operator_layer.LinearOperatorLayer): """K-space scaling layer. This layer scales the *k*-space data so that the adjoint reconstruction has - values between 0 and 1. + magnitude values in the approximate `[0, 1]` range. """ def __init__(self, - calib_region, + calib_window='rect', + calib_region=0.1 * np.pi, operator=linear_operator_mri.LinearOperatorMRI, kspace_index=None, **kwargs): """Initializes the layer.""" super().__init__(operator=operator, input_indices=kspace_index, **kwargs) + self.calib_window = calib_window + self.calib_region = calib_region def call(self, inputs): """Applies the layer. @@ -51,8 +56,16 @@ def call(self, inputs): The scaled k-space data. """ kspace, operator = self.parse_inputs(inputs) - # kspace = - image = recon_adjoint.recon_adjoint(kspace, operator) + filtered_kspace = signal_ops.filter_kspace( + kspace, + operator.trajectory, + filter_fn=self.calib_window, + filter_rank=operator.rank, + filter_kwargs=dict( + cutoff=self.calib_region + ), + separable=isinstance(self.calib_region, (list, tuple))) + image = recon_adjoint.recon_adjoint(filtered_kspace, operator) return kspace / tf.cast(tf.math.reduce_max(tf.math.abs(image)), kspace.dtype) diff --git a/tensorflow_mri/python/layers/kspace_scaling_test.py b/tensorflow_mri/python/layers/kspace_scaling_test.py index f6e49776..2f31217b 100644 --- a/tensorflow_mri/python/layers/kspace_scaling_test.py +++ b/tensorflow_mri/python/layers/kspace_scaling_test.py @@ -32,7 +32,14 @@ def test_kspace_scaling(self): tf.random.stateless_normal(shape=image_shape, seed=[11, 22]), tf.random.stateless_normal(shape=image_shape, seed=[12, 34])) - image = recon_adjoint.recon_adjoint_mri(kspace, image_shape) + # This mask simulates the default filtering operation. + mask = tf.constant([[False, False, False, False], + [False, False, False, False], + [False, False, True, False], + [False, False, False, False]], dtype=tf.bool) + + filtered_kspace = tf.where(mask, kspace, tf.zeros_like(kspace)) + image = recon_adjoint.recon_adjoint_mri(filtered_kspace, image_shape) expected = kspace / tf.cast(tf.math.reduce_max(tf.math.abs(image)), kspace.dtype) From 583fc2c78c63ff29c33bb1644242e960ec43be33 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 18 Aug 2022 13:39:34 +0000 Subject: [PATCH 025/101] Add coil sensitivity estimation layer --- tensorflow_mri/_api/coils/__init__.py | 1 - .../python/coils/coil_sensitivities.py | 56 +++++++++---------- .../python/layers/coil_sensitivities.py | 51 +++++++++++------ .../python/layers/kspace_scaling.py | 14 +++-- 4 files changed, 70 insertions(+), 52 deletions(-) diff --git a/tensorflow_mri/_api/coils/__init__.py b/tensorflow_mri/_api/coils/__init__.py index 99b8a7d8..870f204b 100644 --- a/tensorflow_mri/_api/coils/__init__.py +++ b/tensorflow_mri/_api/coils/__init__.py @@ -2,7 +2,6 @@ # Do not edit. """Parallel imaging operations.""" -from tensorflow_mri.python.coils.coil_sensitivities import coil_sensitivities as custom_sensitivities from tensorflow_mri.python.coils.coil_sensitivities import estimate_coil_sensitivities as estimate_sensitivities from tensorflow_mri.python.ops.coil_ops import combine_coils as combine_coils from tensorflow_mri.python.ops.coil_ops import compress_coils as compress_coils diff --git a/tensorflow_mri/python/coils/coil_sensitivities.py b/tensorflow_mri/python/coils/coil_sensitivities.py index e4e1ae43..f16a4431 100644 --- a/tensorflow_mri/python/coils/coil_sensitivities.py +++ b/tensorflow_mri/python/coils/coil_sensitivities.py @@ -22,55 +22,55 @@ from tensorflow_mri.python.ops import array_ops from tensorflow_mri.python.ops import fft_ops from tensorflow_mri.python.ops import signal_ops +from tensorflow_mri.python.recon import recon_adjoint from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util -@api_util.export("coils.custom_sensitivities") -def coil_sensitivities(kspace, - operator, - calib_filter='rect', - calib_region=None, - method='walsh', - **kwargs): +@api_util.export("coils.extract_calibration_data_and_estimate_sensitivities") +def extract_calibration_data_and_estimate_sensitivities( + kspace, + operator, + calib_window='rect', + calib_region=0.1 * np.pi, + calib_method='walsh', + calib_kwargs=None): + # For convenience. rank = operator.rank - calib_region = canonicalize_calib_region(calib_region, rank) # Low-pass filtering. - kspace = signal_ops.filter_kspace(kspace, - trajectory=operator.trajectory, - filter_fn=calib_filter, - filter_rank=rank, - filter_kwargs=dict( - cutoff=min(calib_region) - )) + kspace = signal_ops.filter_kspace( + kspace, + trajectory=operator.trajectory, + filter_fn=calib_window, + filter_rank=rank, + filter_kwargs=dict( + cutoff=calib_region + ), + separable=isinstance(calib_region, (list, tuple))) # Reconstruct image. - inputs = operator.postprocess( - operator.transform( - operator.preprocess(kspace, adjoint=True), - adjoint=True), - adjoint=True) + calib_data = recon_adjoint.recon_adjoint(kspace, operator) # ESPIRiT method takes in k-space data, so convert back to k-space in this # case. - if method == 'espirit': + if calib_method == 'espirit': axes = list(range(-rank, 0)) inputs = fft_ops.fftn(inputs, axes=axes, norm='ortho', shift=True) # Reshape to single batch dimension. - batch_shape_static = inputs.shape[:-(rank + 1)] - batch_shape = tf.shape(inputs)[:-(rank + 1)] - input_shape = tf.shape(inputs)[-(rank + 1):] - inputs = tf.reshape(inputs, tf.concat([[-1], input_shape], 0)) + batch_shape_static = calib_data.shape[:-(rank + 1)] + batch_shape = tf.shape(calib_data)[:-(rank + 1)] + calib_shape = tf.shape(calib_data)[-(rank + 1):] + calib_data = tf.reshape(calib_data, tf.concat([[-1], calib_shape], 0)) # Apply estimation for each element in batch. sensitivities = tf.map_fn( functools.partial(estimate_coil_sensitivities, coil_axis=-(rank + 1), - method=method, - **kwargs), - inputs) + method=calib_method, + **(calib_kwargs or {})), + calib_data) # Restore batch shape. output_shape = tf.shape(sensitivities)[1:] diff --git a/tensorflow_mri/python/layers/coil_sensitivities.py b/tensorflow_mri/python/layers/coil_sensitivities.py index 2f3a159f..fffde7b6 100644 --- a/tensorflow_mri/python/layers/coil_sensitivities.py +++ b/tensorflow_mri/python/layers/coil_sensitivities.py @@ -14,26 +14,33 @@ # ============================================================================== """*k*-space scaling layer.""" -import tensorflow as tf +import numpy as np from tensorflow_mri.python.layers import linear_operator_layer from tensorflow_mri.python.linalg import linear_operator_mri -from tensorflow_mri.python.recon import recon_adjoint -from tensorflow_mri.python.ops import signal_ops +from tensorflow_mri.python.coils import coil_sensitivities class CoilSensitivityEstimation(linear_operator_layer.LinearOperatorLayer): """Coil sensitivity estimation layer. - This layer scales the *k*-space data so that the adjoint reconstruction has - values between 0 and 1. + This layer extracts a calibration region and estimates the coil sensitivity + maps. """ def __init__(self, + calib_window='rect', + calib_region=0.1 * np.pi, + calib_method='walsh', + calib_kwargs=None, operator=linear_operator_mri.LinearOperatorMRI, kspace_index=None, **kwargs): """Initializes the layer.""" super().__init__(operator=operator, input_indices=kspace_index, **kwargs) + self.calib_window = calib_window + self.calib_region = calib_region + self.calib_method = calib_method + self.calib_kwargs = calib_kwargs def call(self, inputs): """Applies the layer. @@ -48,14 +55,16 @@ def call(self, inputs): The scaled k-space data. """ kspace, operator = self.parse_inputs(inputs) - filter_fn = lambda x: signal_ops.hamming(calib_region * x) - kspace = signal_ops.filter_kspace(kspace, - trajectory=operator.trajectory, - filter_fn=filter_fn, - filter_rank=operator.rank) - image = recon_adjoint.recon_adjoint(kspace, operator) - return kspace / tf.cast(tf.math.reduce_max(tf.math.abs(image)), - kspace.dtype) + return ( + coil_sensitivities.extract_calibration_data_and_estimate_sensitivities( + kspace, + operator, + calib_window=self.calib_window, + calib_region=self.calib_region, + calib_method=self.calib_method, + calib_kwargs=self.calib_kwargs + ) + ) def get_config(self): """Returns the config of the layer. @@ -63,8 +72,14 @@ def get_config(self): Returns: A `dict` describing the layer configuration. """ - config = super().get_config() - kspace_index = config.pop('input_indices') - if kspace_index is not None: - kspace_index = kspace_index[0] - return config + config = { + 'calib_window': self.calib_window, + 'calib_region': self.calib_region, + 'calib_method': self.calib_method, + 'calib_kwargs': self.calib_kwargs + } + base_config = super().get_config() + kspace_index = base_config.pop('input_indices') + config['kspace_index'] = ( + kspace_index[0] if kspace_index is not None else None) + return {**config, **base_config} diff --git a/tensorflow_mri/python/layers/kspace_scaling.py b/tensorflow_mri/python/layers/kspace_scaling.py index 4d91413e..515d9e06 100644 --- a/tensorflow_mri/python/layers/kspace_scaling.py +++ b/tensorflow_mri/python/layers/kspace_scaling.py @@ -75,8 +75,12 @@ def get_config(self): Returns: A `dict` describing the layer configuration. """ - config = super().get_config() - kspace_index = config.pop('input_indices') - if kspace_index is not None: - kspace_index = kspace_index[0] - return config + config = { + 'calib_window': self.calib_window, + 'calib_region': self.calib_region + } + base_config = super().get_config() + kspace_index = base_config.pop('input_indices') + config['kspace_index'] = ( + kspace_index[0] if kspace_index is not None else None) + return {**config, **base_config} From 411bbb52803c326bda8f8f1c31a40546d889bcc3 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 18 Aug 2022 15:05:34 +0000 Subject: [PATCH 026/101] Working on VarNet --- AUTHORS | 7 ++ CONTRIBUTORS | 6 + .../python/layers/data_consistency.py | 105 +++++------------- .../{varnet.py => variational_network.py} | 80 +++++++------ .../python/models/variational_network_test.py | 0 5 files changed, 82 insertions(+), 116 deletions(-) create mode 100644 AUTHORS create mode 100644 CONTRIBUTORS rename tensorflow_mri/python/models/{varnet.py => variational_network.py} (52%) create mode 100644 tensorflow_mri/python/models/variational_network_test.py diff --git a/AUTHORS b/AUTHORS new file mode 100644 index 00000000..7af508cb --- /dev/null +++ b/AUTHORS @@ -0,0 +1,7 @@ +# This file contains a list of individuals and organizations who are authors +# of this project for copyright purposes. +# For a full list of individuals who have contributed to the project, see the +# CONTRIBUTORS file. + +Javier Montalt-Tordera +University College London diff --git a/CONTRIBUTORS b/CONTRIBUTORS new file mode 100644 index 00000000..164b2472 --- /dev/null +++ b/CONTRIBUTORS @@ -0,0 +1,6 @@ +# This file contains a list of individuals who have made a contribution to this +# project. If you are making a contribution, please add yourself to this list +# using the format: +# Name + +Javier Montalt-Tordera diff --git a/tensorflow_mri/python/layers/data_consistency.py b/tensorflow_mri/python/layers/data_consistency.py index 40618a27..8e40a9c1 100644 --- a/tensorflow_mri/python/layers/data_consistency.py +++ b/tensorflow_mri/python/layers/data_consistency.py @@ -14,59 +14,35 @@ # ============================================================================== """Data consistency layers.""" -import inspect - import tensorflow as tf -from tensorflow_mri.python.linalg import linear_operator +from tensorflow_mri.python.layers import linear_operator_layer +from tensorflow_mri.python.linalg import linear_operator_mri from tensorflow_mri.python.util import api_util @api_util.export("layers.LeastSquaresGradientDescent") -class LeastSquaresGradientDescent(tf.keras.layers.Layer): +class LeastSquaresGradientDescent(linear_operator_layer.LinearOperatorLayer): """Least squares gradient descent layer. """ def __init__(self, - operator, scale_initializer=1.0, - handle_channel_axis=True, - dtype=None, + ignore_channels=True, + operator=linear_operator_mri.LinearOperatorMRI, + image_index='image', + kspace_index='kspace', **kwargs): - if isinstance(operator, linear_operator.LinearOperator): - # operator is a class instance. - self.operator = operator - self._operator_is_class = False - self._operator_is_instance = True - elif (inspect.isclass(operator) and - issubclass(operator, linear_operator.LinearOperator)): - # operator is a class. - self.operator = operator - self._operator_is_class = True - self._operator_is_instance = False - else: - raise TypeError( - f"operator must be a subclass of `tfmri.linalg.LinearOperator` " - f"or an instance thereof, but got type: {type(operator)}") - + super().__init__(operator=operator, + input_indices=(image_index, kspace_index), + **kwargs) if isinstance(scale_initializer, (float, int)): self.scale_initializer = tf.keras.initializers.Constant(scale_initializer) else: self.scale_initializer = tf.keras.initializers.get(scale_initializer) - - if self._operator_is_instance: - if dtype is not None: - if tf.as_dtype(dtype) != self.operator.dtype: - raise ValueError( - f"dtype must be the same as the operator's dtype, but got " - f"dtype: {dtype} and operator's dtype: {self.operator.dtype}") - else: - dtype = self.operator.dtype - - self.handle_channel_axis = handle_channel_axis - - super().__init__(dtype=dtype, **kwargs) + self.ignore_channels = ignore_channels def build(self, input_shape): + super().build(input_shape) self.scale = self.add_weight( name='scale', shape=(), @@ -74,56 +50,25 @@ def build(self, input_shape): initializer=self.scale_initializer, trainable=self.trainable, constraint=tf.keras.constraints.NonNeg()) - super().build(input_shape) def call(self, inputs): - x, b, args, kwargs = self._parse_inputs(inputs) - if self._operator_is_class: - # operator is a class. Instantiate using any additional arguments. - operator = self.operator(*args, **kwargs) - else: - # operator is an instance, so we can use it directly. - if args or kwargs: - raise ValueError( - f"unexpected arguments in call when linear operator is a class " - f"instance: {args}, {kwargs}") - operator = self.operator - if self.handle_channel_axis: - x = tf.squeeze(x, axis=-1) - x -= tf.cast(self.scale, self.dtype) * operator.transform( - operator.transform(x) - b, adjoint=True) - if self.handle_channel_axis: - x = tf.expand_dims(x, axis=-1) - return x - - def _parse_inputs(self, inputs): - """Parses the inputs to the call method.""" - if isinstance(inputs, dict): - if 'x' not in inputs or 'b' not in inputs: - raise ValueError( - f"inputs dictionary must at least contain the keys 'x' and " - f"'b', but got keys: {inputs.keys()}") - x = inputs['x'] - b = inputs['b'] - args, kwargs = (), {k: v for k, v in inputs.items() - if k not in {'x', 'b'}} - elif isinstance(inputs, tuple): - if len(inputs) < 2: - raise ValueError( - f"inputs tuple must contain at least two elements, " - f"x and b, but got tuple with length: {len(inputs)}") - x = inputs[0] - b = inputs[1] - args, kwargs = inputs[2:], {} - else: - raise TypeError("inputs must be a tuple or a dictionary.") - return x, b, args, kwargs + (image, kspace), operator = self.parse_inputs(inputs) + if self.ignore_channels: + image = tf.squeeze(image, axis=-1) + image -= tf.cast(self.scale, self.dtype) * operator.transform( + operator.transform(image) - kspace, adjoint=True) + if self.ignore_channels: + image = tf.expand_dims(image, axis=-1) + return image def get_config(self): config = { - 'operator': self.operator, 'scale_initializer': tf.keras.initializers.serialize( - self.scale_initializer) + self.scale_initializer), + 'ignore_channels': self.ignore_channels } base_config = super().get_config() + image_index, kspace_index = base_config.pop('input_indices') + config['image_index'] = image_index + config['kspace_index'] = kspace_index return {**config, **base_config} diff --git a/tensorflow_mri/python/models/varnet.py b/tensorflow_mri/python/models/variational_network.py similarity index 52% rename from tensorflow_mri/python/models/varnet.py rename to tensorflow_mri/python/models/variational_network.py index 56232bfe..d97cd1a9 100644 --- a/tensorflow_mri/python/models/varnet.py +++ b/tensorflow_mri/python/models/variational_network.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. @@ -13,69 +13,77 @@ # limitations under the License. # ============================================================================== +import numpy as np import tensorflow as tf +from tensorflow_mri.python.layers import coil_sensitivities +from tensorflow_mri.python.layers import data_consistency from tensorflow_mri.python.layers import kspace_scaling +from tensorflow_mri.python.layers import recon_adjoint from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.util import model_util class VarNet(tf.keras.Model): def __init__(self, rank, - kspace_index=None, + num_iterations=10, + calib_region=0.1 * np.pi, + reg_network='UNet', scale_kspace=True, + estimate_sensitivities=True, + kspace_index=None, **kwargs): super().__init__(**kwargs) self.rank = rank - self.kspace_index = kspace_index + self.num_iterations = num_iterations + self.calib_region = calib_region + self.reg_network = reg_network self.scale_kspace = scale_kspace + self.estimate_sensitivities = estimate_sensitivities + self.kspace_index = kspace_index if self.scale_kspace: self._kspace_scaling_layer = kspace_scaling.KSpaceScaling( + calib_region=self.calib_region, kspace_index=self.kspace_index) else: self._kspace_scaling_layer = None + if self.estimate_sensitivities: + self._coil_sensitivities_layer = ( + coil_sensitivities.CoilSensitivityEstimation( + calib_region=self.calib_region, + kspace_index=self.kspace_index) + ) + self._recon_adjoint_layer = recon_adjoint.ReconAdjoint( + kspace_index=self.kspace_index) + + lsgd_layer_class = data_consistency.LeastSquaresGradientDescent() + reg_network_class = model_util.get_nd_model(self.reg_network, rank) + + reg_network_kwargs = {} + self._lsgd_layers = [lsgd_layer_class(name=f'lsgd_{i}') + for i in range(self.num_iterations)] + self._reg_layers = [reg_network_class(**reg_network_kwargs, name=f'reg_{i}') + for i in range(self.num_iterations)] def call(self, inputs): - if self.scale_kspace: - kspace = self._kspace_scaling_layer(inputs) + x = inputs if self.scale_kspace: - sensitivities = CoilSensitivityEstimation() - kwargs['sensitivities'] = CoilSensitivities()({'kspace': kspace, **kwargs}) + x['kspace'] = self._kspace_scaling_layer(x) + + if self.estimate_sensitivities: + x['sensitivities'] = self._coil_sensitivities_layer(x) - zfill = ReconAdjoint()({'kspace': kspace, **kwargs}) + zfill = self._recon_adjoint_layer(x) image = zfill - for i in range(num_iterations): - image = tfmri.models.UNet2D( - filters=[32, 64, 128], - kernel_size=3, - activation=tfmri.activations.complex_relu, - out_channels=1, - dtype=tf.complex64, - name=f'reg_{i}')(image) - image = tfmri.layers.LeastSquaresGradientDescent( - operator=tfmri.linalg.LinearOperatorMRI, - dtype=tf.complex64, - name=f'lsgd_{i}')( - {'x': image, 'b': kspace, **kwargs}) + for lsgd, reg in zip(self._lsgd_layers, self._reg_layers): + image = reg(image) + image = lsgd({'image': image, **x}) outputs = {'zfill': zfill, 'image': image} - return tf.keras.Model(inputs=inputs, outputs=outputs) - - def parse_inputs(self, inputs): - if isinstance(inputs, dict): - kspace = inputs[self.kspace_index] - args = () - kwargs = {k: inputs[k] for k in inputs.keys() if k != self.kspace_index} - elif isinstance(inputs, tuple): - kspace = inputs[0] - args = inputs[1:] - kwargs = {} - else: - raise TypeError( - f"inputs must be a dict or a tuple, but got type: {type(inputs)}") - return kspace, args, kwargs + return outputs @api_util.export("models.VarNet1D") diff --git a/tensorflow_mri/python/models/variational_network_test.py b/tensorflow_mri/python/models/variational_network_test.py new file mode 100644 index 00000000..e69de29b From b01eeebbd11bcd4e6ed14f8c3c07914f6133447a Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 18 Aug 2022 18:33:04 +0000 Subject: [PATCH 027/101] Variational network --- .../python/layers/data_consistency.py | 4 +- .../python/layers/kspace_scaling.py | 6 ++- .../python/layers/kspace_scaling_test.py | 2 + .../python/layers/linear_operator_layer.py | 6 +-- tensorflow_mri/python/layers/recon_adjoint.py | 19 ++++++-- .../python/models/variational_network.py | 48 ++++++++++++++++--- tensorflow_mri/python/util/keras_util.py | 19 ++++++++ 7 files changed, 87 insertions(+), 17 deletions(-) diff --git a/tensorflow_mri/python/layers/data_consistency.py b/tensorflow_mri/python/layers/data_consistency.py index 8e40a9c1..b327b76e 100644 --- a/tensorflow_mri/python/layers/data_consistency.py +++ b/tensorflow_mri/python/layers/data_consistency.py @@ -19,6 +19,7 @@ from tensorflow_mri.python.layers import linear_operator_layer from tensorflow_mri.python.linalg import linear_operator_mri from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.util import keras_util @api_util.export("layers.LeastSquaresGradientDescent") @@ -32,6 +33,7 @@ def __init__(self, image_index='image', kspace_index='kspace', **kwargs): + kwargs['dtype'] = kwargs.get('dtype') or keras_util.complexx() super().__init__(operator=operator, input_indices=(image_index, kspace_index), **kwargs) @@ -55,7 +57,7 @@ def call(self, inputs): (image, kspace), operator = self.parse_inputs(inputs) if self.ignore_channels: image = tf.squeeze(image, axis=-1) - image -= tf.cast(self.scale, self.dtype) * operator.transform( + image -= tf.cast(self.scale, image.dtype) * operator.transform( operator.transform(image) - kspace, adjoint=True) if self.ignore_channels: image = tf.expand_dims(image, axis=-1) diff --git a/tensorflow_mri/python/layers/kspace_scaling.py b/tensorflow_mri/python/layers/kspace_scaling.py index 515d9e06..8b5fd5b5 100644 --- a/tensorflow_mri/python/layers/kspace_scaling.py +++ b/tensorflow_mri/python/layers/kspace_scaling.py @@ -22,6 +22,7 @@ from tensorflow_mri.python.ops import signal_ops from tensorflow_mri.python.recon import recon_adjoint from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.util import keras_util @api_util.export("layers.KSpaceScaling") @@ -39,7 +40,10 @@ def __init__(self, kspace_index=None, **kwargs): """Initializes the layer.""" - super().__init__(operator=operator, input_indices=kspace_index, **kwargs) + kwargs['dtype'] = kwargs.get('dtype') or keras_util.complexx() + super().__init__(operator=operator, + input_indices=kspace_index, + **kwargs) self.calib_window = calib_window self.calib_region = calib_region diff --git a/tensorflow_mri/python/layers/kspace_scaling_test.py b/tensorflow_mri/python/layers/kspace_scaling_test.py index 2f31217b..08f53e4b 100644 --- a/tensorflow_mri/python/layers/kspace_scaling_test.py +++ b/tensorflow_mri/python/layers/kspace_scaling_test.py @@ -26,6 +26,8 @@ class KSpaceScalingTest(test_util.TestCase): def test_kspace_scaling(self): """Tests the k-space scaling layer.""" layer = kspace_scaling.KSpaceScaling() + self.assertEqual(layer.dtype, "complex64") + image_shape = tf.convert_to_tensor([4, 4]) kspace = tf.dtypes.complex( diff --git a/tensorflow_mri/python/layers/linear_operator_layer.py b/tensorflow_mri/python/layers/linear_operator_layer.py index f7abcd37..34e621db 100644 --- a/tensorflow_mri/python/layers/linear_operator_layer.py +++ b/tensorflow_mri/python/layers/linear_operator_layer.py @@ -66,13 +66,13 @@ def parse_inputs(self, inputs): input_indices = (tuple(inputs.keys())[0],) else: input_indices = self._input_indices - main = {k: inputs[k] for k in input_indices} + main = tuple(inputs[i] for i in input_indices) args = () kwargs = {k: v for k, v in inputs.items() if k not in input_indices} # Unpack single input. - if len(input_indices) == 1: - main = main[input_indices[0]] + if len(main) == 1: + main = main[0] # Create operator. if self._operator_instance is None: diff --git a/tensorflow_mri/python/layers/recon_adjoint.py b/tensorflow_mri/python/layers/recon_adjoint.py index 9ceca76f..e43638dc 100644 --- a/tensorflow_mri/python/layers/recon_adjoint.py +++ b/tensorflow_mri/python/layers/recon_adjoint.py @@ -20,6 +20,7 @@ from tensorflow_mri.python.linalg import linear_operator_mri from tensorflow_mri.python.recon import recon_adjoint from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.util import keras_util @api_util.export("layers.ReconAdjoint") @@ -30,11 +31,14 @@ class ReconAdjoint(linear_operator_layer.LinearOperatorLayer): This layer reconstructs a signal using the adjoint of the system operator. """ def __init__(self, + channel_dimension=True, operator=linear_operator_mri.LinearOperatorMRI, kspace_index=None, **kwargs): """Initializes the layer.""" + kwargs['dtype'] = kwargs.get('dtype') or keras_util.complexx() super().__init__(operator=operator, input_indices=kspace_index, **kwargs) + self.channel_dimension = channel_dimension def call(self, inputs): """Applies the layer. @@ -50,6 +54,8 @@ def call(self, inputs): """ kspace, operator = self.parse_inputs(inputs) image = recon_adjoint.recon_adjoint(kspace, operator) + if self.channel_dimension: + image = tf.expand_dims(image, axis=-1) return image def get_config(self): @@ -58,8 +64,11 @@ def get_config(self): Returns: A `dict` describing the layer configuration. """ - config = super().get_config() - kspace_index = config.pop('input_indices') - if kspace_index is not None: - kspace_index = kspace_index[0] - return config + config = { + 'channel_dimension': self.channel_dimension + } + base_config = super().get_config() + kspace_index = base_config.pop('input_indices') + config['kspace_index'] = ( + kspace_index[0] if kspace_index is not None else None) + return {**config, **base_config} diff --git a/tensorflow_mri/python/models/variational_network.py b/tensorflow_mri/python/models/variational_network.py index d97cd1a9..be85fd17 100644 --- a/tensorflow_mri/python/models/variational_network.py +++ b/tensorflow_mri/python/models/variational_network.py @@ -15,12 +15,15 @@ import numpy as np import tensorflow as tf +import warnings +from tensorflow_mri.python.activations import complex_activations from tensorflow_mri.python.layers import coil_sensitivities from tensorflow_mri.python.layers import data_consistency from tensorflow_mri.python.layers import kspace_scaling from tensorflow_mri.python.layers import recon_adjoint from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.util import keras_util from tensorflow_mri.python.util import model_util @@ -30,45 +33,76 @@ def __init__(self, num_iterations=10, calib_region=0.1 * np.pi, reg_network='UNet', + reg_network_kwargs=None, scale_kspace=True, estimate_sensitivities=True, + view_complex_as_real=False, kspace_index=None, **kwargs): + kwargs['dtype'] = kwargs.get('dtype') or keras_util.complexx() super().__init__(**kwargs) self.rank = rank self.num_iterations = num_iterations self.calib_region = calib_region self.reg_network = reg_network + self.reg_network_kwargs = reg_network_kwargs or {} self.scale_kspace = scale_kspace self.estimate_sensitivities = estimate_sensitivities + self.view_complex_as_real = view_complex_as_real self.kspace_index = kspace_index + if self.scale_kspace: self._kspace_scaling_layer = kspace_scaling.KSpaceScaling( calib_region=self.calib_region, kspace_index=self.kspace_index) else: self._kspace_scaling_layer = None + if self.estimate_sensitivities: self._coil_sensitivities_layer = ( coil_sensitivities.CoilSensitivityEstimation( calib_region=self.calib_region, kspace_index=self.kspace_index) ) + self._recon_adjoint_layer = recon_adjoint.ReconAdjoint( kspace_index=self.kspace_index) - lsgd_layer_class = data_consistency.LeastSquaresGradientDescent() - reg_network_class = model_util.get_nd_model(self.reg_network, rank) + lsgd_layer_class = data_consistency.LeastSquaresGradientDescent + lsgd_layers_kwargs = {} - reg_network_kwargs = {} - self._lsgd_layers = [lsgd_layer_class(name=f'lsgd_{i}') - for i in range(self.num_iterations)] - self._reg_layers = [reg_network_class(**reg_network_kwargs, name=f'reg_{i}') - for i in range(self.num_iterations)] + reg_network_class = model_util.get_nd_model(self.reg_network, rank) + reg_network_kwargs = dict( + filters=[32, 64, 128, 256], + kernel_size=3, + activation=complex_activations.complex_relu, + out_channels=2 if self.view_complex_as_real else 1, + dtype=tf.float32 if self.view_complex_as_real else tf.complex64 + ) + + self._lsgd_layers = [ + lsgd_layer_class(**lsgd_layers_kwargs, name=f'lsgd_{i}') + for i in range(self.num_iterations)] + self._reg_layers = [ + reg_network_class(**reg_network_kwargs, name=f'reg_{i}') + for i in range(self.num_iterations)] def call(self, inputs): x = inputs + if 'image_shape' in x: + image_shape = x['image_shape'] + if image_shape.shape.rank == 2: + warnings.warn( + f"Layer {self.name} got a batch of image shapes. " + f"It is not possible to reconstruct images with " + f"different shapes in the same batch. " + f"If the input batch has more than one element, " + f"only the first image shape will be used. " + f"It is up to you to verify if this behavior is correct.") + x['image_shape'] = tf.ensure_shape( + image_shape[0], image_shape.shape[1:]) + if self.scale_kspace: x['kspace'] = self._kspace_scaling_layer(x) diff --git a/tensorflow_mri/python/util/keras_util.py b/tensorflow_mri/python/util/keras_util.py index 5bce9c47..eafacf8a 100644 --- a/tensorflow_mri/python/util/keras_util.py +++ b/tensorflow_mri/python/util/keras_util.py @@ -68,3 +68,22 @@ def get_config(self): def is_tensor_or_variable(x): return tf.is_tensor(x) or isinstance(x, tf.Variable) + + +def complexx(): + """Returns the default complex dtype, as a string. + + The default complex dtype is the complex equivalent of the default + float type, which can be obtained as `tf.keras.backend.floatx()`. + + To change the default complex dtype, change the default float type via + `tf.keras.backend.set_floatx()`. + + Returns: + The current default complex dtype, as a string. + """ + complex_dtypes = { + 'float32': 'complex64', + 'float64': 'complex128' + } + return tf.dtypes.as_dtype(complex_dtypes[tf.keras.backend.floatx()]).name From 7a7d2c726112ec2fd83f0ea28f13dcfdc0896719 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Fri, 19 Aug 2022 18:18:43 +0000 Subject: [PATCH 028/101] Working on VarNet --- tensorflow_mri/_api/coils/__init__.py | 1 + tensorflow_mri/_api/layers/__init__.py | 2 + tensorflow_mri/_api/signal/__init__.py | 1 + tensorflow_mri/python/layers/concatenate.py | 39 +++++++++ tensorflow_mri/python/layers/padding.py | 84 +++++++++++++++++++ tensorflow_mri/python/models/conv_endec.py | 23 ++++- .../python/models/variational_network.py | 20 ++++- tensorflow_mri/python/ops/signal_ops.py | 2 +- tensorflow_mri/python/util/layer_util.py | 4 + tensorflow_mri/python/util/model_util.py | 14 ++++ tensorflow_mri/python/util/plot_util.py | 16 +++- 11 files changed, 197 insertions(+), 9 deletions(-) create mode 100644 tensorflow_mri/python/layers/concatenate.py create mode 100644 tensorflow_mri/python/layers/padding.py diff --git a/tensorflow_mri/_api/coils/__init__.py b/tensorflow_mri/_api/coils/__init__.py index 870f204b..4e7de206 100644 --- a/tensorflow_mri/_api/coils/__init__.py +++ b/tensorflow_mri/_api/coils/__init__.py @@ -2,6 +2,7 @@ # Do not edit. """Parallel imaging operations.""" +from tensorflow_mri.python.coils.coil_sensitivities import extract_calibration_data_and_estimate_sensitivities as extract_calibration_data_and_estimate_sensitivities from tensorflow_mri.python.coils.coil_sensitivities import estimate_coil_sensitivities as estimate_sensitivities from tensorflow_mri.python.ops.coil_ops import combine_coils as combine_coils from tensorflow_mri.python.ops.coil_ops import compress_coils as compress_coils diff --git a/tensorflow_mri/_api/layers/__init__.py b/tensorflow_mri/_api/layers/__init__.py index 6e058d6f..bd081a4e 100644 --- a/tensorflow_mri/_api/layers/__init__.py +++ b/tensorflow_mri/_api/layers/__init__.py @@ -11,6 +11,7 @@ from tensorflow_mri.python.layers.conv_blocks import ConvBlock as ConvBlock from tensorflow_mri.python.layers.conv_endec import UNet as UNet from tensorflow_mri.python.layers.data_consistency import LeastSquaresGradientDescent as LeastSquaresGradientDescent +from tensorflow_mri.python.layers.kspace_scaling import KSpaceScaling as KSpaceScaling from tensorflow_mri.python.layers.pooling import AveragePooling1D as AveragePooling1D from tensorflow_mri.python.layers.pooling import AveragePooling1D as AvgPool1D from tensorflow_mri.python.layers.pooling import AveragePooling2D as AveragePooling2D @@ -23,6 +24,7 @@ from tensorflow_mri.python.layers.pooling import MaxPooling2D as MaxPool2D from tensorflow_mri.python.layers.pooling import MaxPooling3D as MaxPooling3D from tensorflow_mri.python.layers.pooling import MaxPooling3D as MaxPool3D +from tensorflow_mri.python.layers.recon_adjoint import ReconAdjoint as ReconAdjoint from tensorflow_mri.python.layers.reshaping import UpSampling1D as UpSampling1D from tensorflow_mri.python.layers.reshaping import UpSampling2D as UpSampling2D from tensorflow_mri.python.layers.reshaping import UpSampling3D as UpSampling3D diff --git a/tensorflow_mri/_api/signal/__init__.py b/tensorflow_mri/_api/signal/__init__.py index fbe3cdc9..b6f632a6 100644 --- a/tensorflow_mri/_api/signal/__init__.py +++ b/tensorflow_mri/_api/signal/__init__.py @@ -16,5 +16,6 @@ from tensorflow_mri.python.ops.signal_ops import hamming as hamming from tensorflow_mri.python.ops.signal_ops import atanfilt as atanfilt from tensorflow_mri.python.ops.signal_ops import rect as rect +from tensorflow_mri.python.ops.signal_ops import separable_window as separable_window from tensorflow_mri.python.ops.signal_ops import filter_kspace as filter_kspace from tensorflow_mri.python.ops.signal_ops import crop_kspace as crop_kspace diff --git a/tensorflow_mri/python/layers/concatenate.py b/tensorflow_mri/python/layers/concatenate.py new file mode 100644 index 00000000..91123c9f --- /dev/null +++ b/tensorflow_mri/python/layers/concatenate.py @@ -0,0 +1,39 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== + +import tensorflow as tf + +from tensorflow_mri.python.ops import array_ops + + +@tf.keras.utils.register_keras_serializable(package="MRI") +class ResizeAndConcatenate(tf.keras.layers.Layer): + def __init__(self, axis=-1, **kwargs): + super().__init__(**kwargs) + self.axis = axis + + def call(self, inputs): + if not isinstance(inputs, (list, tuple)): + raise ValueError( + f"Layer {self.__class__.__name__} expects a list of inputs. " + f"Received: {inputs}") + + ref = inputs[0] + others = inputs[1:] + others = [tf.ensure_shape( + array_ops.resize_with_crop_or_pad(tensor, tf.shape(ref)), + ref.shape) for tensor in others] + + return tf.concat([ref] + others, axis=self.axis) diff --git a/tensorflow_mri/python/layers/padding.py b/tensorflow_mri/python/layers/padding.py new file mode 100644 index 00000000..8fe5aebc --- /dev/null +++ b/tensorflow_mri/python/layers/padding.py @@ -0,0 +1,84 @@ +# Copyright 2021 University College London. 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. +# ============================================================================== +"""Padding layers.""" + +import tensorflow as tf + + +class DivisorPadding(tf.keras.layers.Layer): + """Divisor padding layer. + + This layer pads the input tensor so that its spatial dimensions are a multiple + of the specified divisor. + + Args: + divisor: An `int` or a `tuple` of `int`. The divisor used to compute the + output shape. + """ + def __init__(self, rank, divisor=2, **kwargs): + super().__init__(**kwargs) + self.rank = rank + if isinstance(divisor, int): + self.divisor = (divisor,) * rank + elif hasattr(divisor, '__len__'): + if len(divisor) != rank: + raise ValueError(f'`divisor` should have {rank} elements. ' + f'Received: {divisor}') + self.divisor = divisor + else: + raise ValueError(f'`divisor` should be either an int or a ' + f'a tuple of {rank} ints. ' + f'Received: {divisor}') + self.input_spec = tf.keras.layers.InputSpec(ndim=rank + 2) + + def call(self, inputs): + static_input_shape = inputs.shape + static_output_shape = tuple( + ((s + d - 1) // d) * d if s is not None else None for s, d in zip( + static_input_shape[1:-1].as_list(), self.divisor)) + static_output_shape = static_input_shape[:1].concatenate( + static_output_shape).concatenate(static_input_shape[-1:]) + + input_shape = tf.shape(inputs)[1:-1] + output_shape = ((input_shape + self.divisor - 1) // self.divisor) * self.divisor + left_paddings = (output_shape - input_shape) // 2 + right_paddings = (output_shape - input_shape + 1) // 2 + paddings = tf.stack([left_paddings, right_paddings], axis=-1) + paddings = tf.pad(paddings, [[1, 1], [0, 0]]) + + return tf.ensure_shape(tf.pad(inputs, paddings), static_output_shape) + + def get_config(self): + config = {'divisor': self.divisor} + base_config = super().get_config() + return {**config, **base_config} + + +@tf.keras.utils.register_keras_serializable(package='MRI') +class DivisorPadding1D(DivisorPadding): + def __init__(self, *args, **kwargs): + super().__init__(1, *args, **kwargs) + + +@tf.keras.utils.register_keras_serializable(package='MRI') +class DivisorPadding2D(DivisorPadding): + def __init__(self, *args, **kwargs): + super().__init__(2, *args, **kwargs) + + +@tf.keras.utils.register_keras_serializable(package='MRI') +class DivisorPadding3D(DivisorPadding): + def __init__(self, *args, **kwargs): + super().__init__(3, *args, **kwargs) diff --git a/tensorflow_mri/python/models/conv_endec.py b/tensorflow_mri/python/models/conv_endec.py index f79799cf..688d6f16 100644 --- a/tensorflow_mri/python/models/conv_endec.py +++ b/tensorflow_mri/python/models/conv_endec.py @@ -19,6 +19,7 @@ import tensorflow as tf +from tensorflow_mri.python.layers import concatenate from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util from tensorflow_mri.python.util import model_util # pylint: disable=cyclic-import @@ -116,6 +117,7 @@ def __init__(self, dropout_rate=0.3, dropout_type='standard', use_tight_frame=False, + use_resize_and_concatenate=True, **kwargs): """Creates a UNet model.""" super().__init__(**kwargs) @@ -144,6 +146,7 @@ def __init__(self, self._dropout_type = check_util.validate_enum( dropout_type, {'standard', 'spatial'}, 'dropout_type') self._use_tight_frame = use_tight_frame + self._use_resize_and_concatenate = use_resize_and_concatenate self._dwt_kwargs = {} self._dwt_kwargs['format_dict'] = False self._scales = len(filters) @@ -206,6 +209,12 @@ def __init__(self, dtype=self.dtype) upsamp_layer = layer_util.get_nd_layer(upsamp_name, self._rank) + # Configure concatenation layer. + if self._use_resize_and_concatenate: + concat_layer = concatenate.ResizeAndConcatenate + else: + concat_layer = tf.keras.layers.Concatenate + if tf.keras.backend.image_data_format() == 'channels_last': self._channel_axis = -1 else: @@ -237,8 +246,7 @@ def __init__(self, # components for 3D. self._detail_upsamps.append([upsamp_layer(**upsamp_config) for _ in range(2 ** self._rank - 1)]) - self._concats.append( - tf.keras.layers.Concatenate(axis=self._channel_axis)) + self._concats.append(concat_layer(axis=self._channel_axis)) self._dec_blocks.append(block_layer(**block_config)) # Configure output block. @@ -284,7 +292,11 @@ def call(self, inputs, training=None): # pylint: disable=missing-param-doc,unuse # Decoder. for scale in range(self._scales - 2, -1, -1): x = self._upsamps[scale](x) - concat_inputs = [x, cache[scale]] + if self._use_resize_and_concatenate: + concat_inputs = [cache[scale], x] + else: + # For backwards compatibility. + concat_inputs = [x, cache[scale]] if self._use_tight_frame: # Upsample detail components too. d = [up(d) for d, up in zip( @@ -331,7 +343,8 @@ def get_config(self): 'use_dropout': self._use_dropout, 'dropout_rate': self._dropout_rate, 'dropout_type': self._dropout_type, - 'use_tight_frame': self._use_tight_frame + 'use_tight_frame': self._use_tight_frame, + 'use_resize_and_concatenate': self._use_resize_and_concatenate } base_config = super().get_config() return {**base_config, **config} @@ -342,6 +355,8 @@ def from_config(cls, config): # Old config format. Convert to new format. config['filters'] = [config.pop('base_filters') * (2 ** scale) for scale in config.pop('scales')] + if 'use_resize_and_concatenate' not in config: + config['use_resize_and_concatenate'] = False return super().from_config(config) diff --git a/tensorflow_mri/python/models/variational_network.py b/tensorflow_mri/python/models/variational_network.py index be85fd17..28d1fc27 100644 --- a/tensorflow_mri/python/models/variational_network.py +++ b/tensorflow_mri/python/models/variational_network.py @@ -27,7 +27,7 @@ from tensorflow_mri.python.util import model_util -class VarNet(tf.keras.Model): +class VarNet(model_util.GraphLikeModel): def __init__(self, rank, num_iterations=10, @@ -37,6 +37,9 @@ def __init__(self, scale_kspace=True, estimate_sensitivities=True, view_complex_as_real=False, + return_multicoil=False, + return_zerofilled=False, + return_sensitivities=False, kspace_index=None, **kwargs): kwargs['dtype'] = kwargs.get('dtype') or keras_util.complexx() @@ -49,6 +52,9 @@ def __init__(self, self.scale_kspace = scale_kspace self.estimate_sensitivities = estimate_sensitivities self.view_complex_as_real = view_complex_as_real + self.return_zerofilled = return_zerofilled + self.return_multicoil = return_multicoil + self.return_sensitivities = return_sensitivities self.kspace_index = kspace_index if self.scale_kspace: @@ -116,7 +122,17 @@ def call(self, inputs): image = reg(image) image = lsgd({'image': image, **x}) - outputs = {'zfill': zfill, 'image': image} + outputs = {'image': image} + + if self.return_zerofilled: + outputs['zerofilled'] = zfill + if self.return_multicoil: + outputs['multicoil'] = ( + tf.expand_dims(image, -(self.rank + 2)) * + tf.expand_dims(x['sensitivities'], -1)) + if self.return_sensitivities: + outputs['sensitivities'] = x['sensitivities'] + return outputs diff --git a/tensorflow_mri/python/ops/signal_ops.py b/tensorflow_mri/python/ops/signal_ops.py index bd8affa8..694ee555 100644 --- a/tensorflow_mri/python/ops/signal_ops.py +++ b/tensorflow_mri/python/ops/signal_ops.py @@ -158,7 +158,7 @@ def fn(accumulator, current): perm = tf.concat([[tf.rank(x) - 1], tf.range(0, tf.rank(x) - 1)], 0) x = tf.transpose(x, perm) # Initialize as 1.0. - initializer = tf.constant(1.0, dtype=x.dtype) + initializer = tf.ones_like(x[0, ...]) return tf.foldl(fn, (x, args, kwargs), initializer=initializer) return wrapper diff --git a/tensorflow_mri/python/util/layer_util.py b/tensorflow_mri/python/util/layer_util.py index 40a68286..a4064fb0 100644 --- a/tensorflow_mri/python/util/layer_util.py +++ b/tensorflow_mri/python/util/layer_util.py @@ -17,6 +17,7 @@ import tensorflow as tf from tensorflow_mri.python.layers import convolutional +from tensorflow_mri.python.layers import padding from tensorflow_mri.python.layers import pooling from tensorflow_mri.python.layers import reshaping from tensorflow_mri.python.layers import signal_layers @@ -60,6 +61,9 @@ def get_nd_layer(name, rank): ('Cropping', 3): tf.keras.layers.Cropping3D, ('DepthwiseConv', 1): tf.keras.layers.DepthwiseConv1D, ('DepthwiseConv', 2): tf.keras.layers.DepthwiseConv2D, + ('DivisorPadding', 1): padding.DivisorPadding1D, + ('DivisorPadding', 2): padding.DivisorPadding2D, + ('DivisorPadding', 3): padding.DivisorPadding3D, ('DWT', 1): signal_layers.DWT1D, ('DWT', 2): signal_layers.DWT2D, ('DWT', 3): signal_layers.DWT3D, diff --git a/tensorflow_mri/python/util/model_util.py b/tensorflow_mri/python/util/model_util.py index 4f8b2f3a..b5f7ea7a 100644 --- a/tensorflow_mri/python/util/model_util.py +++ b/tensorflow_mri/python/util/model_util.py @@ -14,10 +14,24 @@ # ============================================================================== """Model utilities.""" +import tensorflow as tf + from tensorflow_mri.python.models import conv_blocks from tensorflow_mri.python.models import conv_endec +class GraphLikeModel(tf.keras.Model): + """A model with graph-like structure. + + Adds a method `functional` that returns a functional model with the same + structure as the current model. Functional models have some advantages over + subclassing as described in + https://www.tensorflow.org/guide/keras/functional#when_to_use_the_functional_api. + """ + def functional(self, inputs): + return tf.keras.Model(inputs, self.call(inputs)) + + def get_nd_model(name, rank): """Get an N-D model object. diff --git a/tensorflow_mri/python/util/plot_util.py b/tensorflow_mri/python/util/plot_util.py index 0273d24e..80f2e7b2 100644 --- a/tensorflow_mri/python/util/plot_util.py +++ b/tensorflow_mri/python/util/plot_util.py @@ -16,6 +16,7 @@ import matplotlib as mpl import matplotlib.animation as ani +import matplotlib.colors as mcol import matplotlib.pyplot as plt import matplotlib.tight_bbox as tight_bbox import numpy as np @@ -245,7 +246,8 @@ def plot_tiled_image(images, aspect=1.77, # 16:9 grid_shape=None, fig_title=None, - subplot_titles=None): + subplot_titles=None, + show_colorbar=False): r"""Plots one or more images in a grid. Args: @@ -261,7 +263,9 @@ def plot_tiled_image(images, norm: A `matplotlib.colors.Normalize`_. Used to scale scalar data to the [0, 1] range before mapping to colors using `cmap`. By default, a linear scaling mapping the lowest value to 0 and the highest to 1 is used. This - parameter is ignored for RGB(A) data. + parameter is ignored for RGB(A) data. Can be set to `'global'`, in which + case a global `Normalize` instance is used for all of the images in the + tile. fig_size: A `tuple` of `float`s. Width and height of the figure in inches. dpi: A `float`. The resolution of the figure in dots per inch. bg_color: A `color`_. The background color. @@ -278,6 +282,7 @@ def plot_tiled_image(images, grid. If `None`, the grid shape is computed from `aspect`. fig_title: A `str`. The title of the figure. subplot_titles: A `list` of `str`s. The titles of the subplots. + show_colorbar: A `bool`. If `True`, a colorbar is displayed. Returns: A `list` of `matplotlib.image.AxesImage`_ objects. @@ -303,6 +308,10 @@ def plot_tiled_image(images, figsize=fig_size, dpi=dpi, facecolor=bg_color, layout=layout) + # Global normalization mode. + if norm == 'global': + norm = mcol.Normalize(vmin=images.min(), vmax=images.max()) + artists = [] for row, col in np.ndindex(grid_rows, grid_cols): # For each tile. tile_idx = row * grid_cols + col # Index of current tile. @@ -326,6 +335,9 @@ def plot_tiled_image(images, artists.append(artist) artists.append(artists) + if show_colorbar: + fig.colorbar(artists[0], ax=axs.ravel().tolist()) + if fig_title is not None: fig.suptitle(fig_title) From 51877e290cbd112d8b718bdf281cb4fd02d0acc0 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Fri, 19 Aug 2022 18:23:40 +0000 Subject: [PATCH 029/101] Document UNet's resize and concatenate feature --- tensorflow_mri/python/models/conv_endec.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tensorflow_mri/python/models/conv_endec.py b/tensorflow_mri/python/models/conv_endec.py index 688d6f16..e5b0be1d 100644 --- a/tensorflow_mri/python/models/conv_endec.py +++ b/tensorflow_mri/python/models/conv_endec.py @@ -77,6 +77,10 @@ `use_dropout` is `True`. Defaults to `'standard'`. use_tight_frame: A `boolean`. If `True`, creates a tight frame U-Net as described in [2]. Defaults to `False`. + use_resize_and_concatenate: A `boolean`. If `True`, the upsampled feature + maps are resized (by cropping) to match the shape of the incoming + skip connection prior to concatenation. This enables more flexible input + shapes. Defaults to `True`. **kwargs: Additional keyword arguments to be passed to base class. References: From 864fc5c33703aac77c5948767ac7fc5c14137381 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Sat, 20 Aug 2022 11:19:29 +0000 Subject: [PATCH 030/101] Working on VarNet --- tensorflow_mri/_api/coils/__init__.py | 8 +- tensorflow_mri/_api/layers/__init__.py | 4 + tensorflow_mri/_api/signal/__init__.py | 6 +- tensorflow_mri/python/coils/__init__.py | 1 + .../python/coils/coil_compression.py | 338 ++++++++++++++++++ .../python/coils/coil_compression_test.py | 15 + .../python/coils/coil_sensitivities.py | 57 ++- .../python/layers/coil_compression.py | 99 +++++ .../python/layers/coil_sensitivities.py | 68 +++- .../python/models/variational_network.py | 43 ++- tensorflow_mri/python/ops/coil_ops.py | 251 ------------- tensorflow_mri/python/util/layer_util.py | 6 + 12 files changed, 585 insertions(+), 311 deletions(-) create mode 100644 tensorflow_mri/python/coils/coil_compression.py create mode 100644 tensorflow_mri/python/coils/coil_compression_test.py create mode 100644 tensorflow_mri/python/layers/coil_compression.py diff --git a/tensorflow_mri/_api/coils/__init__.py b/tensorflow_mri/_api/coils/__init__.py index 4e7de206..28b90a4b 100644 --- a/tensorflow_mri/_api/coils/__init__.py +++ b/tensorflow_mri/_api/coils/__init__.py @@ -2,8 +2,10 @@ # Do not edit. """Parallel imaging operations.""" -from tensorflow_mri.python.coils.coil_sensitivities import extract_calibration_data_and_estimate_sensitivities as extract_calibration_data_and_estimate_sensitivities +from tensorflow_mri.python.coils.coil_compression import compress_coils_with_calibration_data as compress_coils_with_calibration_data +from tensorflow_mri.python.coils.coil_compression import compress_coils as compress_coils +from tensorflow_mri.python.coils.coil_compression import CoilCompressorSVD as CoilCompressorSVD +from tensorflow_mri.python.coils.coil_compression import get_coil_compressor as get_coil_compressor +from tensorflow_mri.python.coils.coil_sensitivities import estimate_sensitivities_with_calibration_data as estimate_sensitivities_with_calibration_data from tensorflow_mri.python.coils.coil_sensitivities import estimate_coil_sensitivities as estimate_sensitivities from tensorflow_mri.python.ops.coil_ops import combine_coils as combine_coils -from tensorflow_mri.python.ops.coil_ops import compress_coils as compress_coils -from tensorflow_mri.python.ops.coil_ops import CoilCompressorSVD as CoilCompressorSVD diff --git a/tensorflow_mri/_api/layers/__init__.py b/tensorflow_mri/_api/layers/__init__.py index bd081a4e..1f4454b5 100644 --- a/tensorflow_mri/_api/layers/__init__.py +++ b/tensorflow_mri/_api/layers/__init__.py @@ -8,6 +8,8 @@ from tensorflow_mri.python.layers.convolutional import Conv2D as Convolution2D from tensorflow_mri.python.layers.convolutional import Conv3D as Conv3D from tensorflow_mri.python.layers.convolutional import Conv3D as Convolution3D +from tensorflow_mri.python.layers.coil_sensitivities import CoilSensitivityEstimation2D as CoilSensitivityEstimation2D +from tensorflow_mri.python.layers.coil_sensitivities import CoilSensitivityEstimation3D as CoilSensitivityEstimation3D from tensorflow_mri.python.layers.conv_blocks import ConvBlock as ConvBlock from tensorflow_mri.python.layers.conv_endec import UNet as UNet from tensorflow_mri.python.layers.data_consistency import LeastSquaresGradientDescent as LeastSquaresGradientDescent @@ -34,3 +36,5 @@ from tensorflow_mri.python.layers.signal_layers import IDWT1D as IDWT1D from tensorflow_mri.python.layers.signal_layers import IDWT2D as IDWT2D from tensorflow_mri.python.layers.signal_layers import IDWT3D as IDWT3D +from tensorflow_mri.python.layers.coil_compression import CoilCompression2D as CoilCompression2D +from tensorflow_mri.python.layers.coil_compression import CoilCompression3D as CoilCompression3D diff --git a/tensorflow_mri/_api/signal/__init__.py b/tensorflow_mri/_api/signal/__init__.py index b6f632a6..fb4161e1 100644 --- a/tensorflow_mri/_api/signal/__init__.py +++ b/tensorflow_mri/_api/signal/__init__.py @@ -9,9 +9,6 @@ from tensorflow_mri.python.ops.wavelet_ops import dwt_max_level as max_wavelet_level from tensorflow_mri.python.ops.wavelet_ops import coeffs_to_tensor as wavelet_coeffs_to_tensor from tensorflow_mri.python.ops.wavelet_ops import tensor_to_coeffs as tensor_to_wavelet_coeffs -from tensorflow_mri.python.ops.fft_ops import fftn as fft -from tensorflow_mri.python.ops.fft_ops import ifftn as ifft -from tensorflow_nufft.python.ops.nufft_ops import nufft as nufft from tensorflow_mri.python.ops.signal_ops import hann as hann from tensorflow_mri.python.ops.signal_ops import hamming as hamming from tensorflow_mri.python.ops.signal_ops import atanfilt as atanfilt @@ -19,3 +16,6 @@ from tensorflow_mri.python.ops.signal_ops import separable_window as separable_window from tensorflow_mri.python.ops.signal_ops import filter_kspace as filter_kspace from tensorflow_mri.python.ops.signal_ops import crop_kspace as crop_kspace +from tensorflow_mri.python.ops.fft_ops import fftn as fft +from tensorflow_mri.python.ops.fft_ops import ifftn as ifft +from tensorflow_nufft.python.ops.nufft_ops import nufft as nufft diff --git a/tensorflow_mri/python/coils/__init__.py b/tensorflow_mri/python/coils/__init__.py index 77758f16..08c989db 100644 --- a/tensorflow_mri/python/coils/__init__.py +++ b/tensorflow_mri/python/coils/__init__.py @@ -14,4 +14,5 @@ # ============================================================================== """Operators for coil arrays.""" +from tensorflow_mri.python.coils import coil_compression from tensorflow_mri.python.coils import coil_sensitivities diff --git a/tensorflow_mri/python/coils/coil_compression.py b/tensorflow_mri/python/coils/coil_compression.py new file mode 100644 index 00000000..320b3bbe --- /dev/null +++ b/tensorflow_mri/python/coils/coil_compression.py @@ -0,0 +1,338 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Coil sensitivity estimation.""" + +import abc + +import numpy as np +import tensorflow as tf + +from tensorflow_mri.python.ops import signal_ops +from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.util import check_util + + +@api_util.export("coils.compress_coils_with_calibration_data") +def compress_coils_with_calibration_data( + kspace, + operator, + calib_data=None, + calib_window='rect', + calib_region=0.1 * np.pi, + method='svd', + **kwargs): + # For convenience. + rank = operator.rank + + if calib_data is None: + # Calibration data was not provided. Get calibration data by low-pass + # filtering the input k-space. + calib_data = signal_ops.filter_kspace( + kspace, + trajectory=operator.trajectory, + filter_fn=calib_window, + filter_rank=rank, + filter_kwargs=dict( + cutoff=calib_region + ), + separable=isinstance(calib_region, (list, tuple))) + + # Reshape to single batch dimension. + coil_axis = -2 if operator.is_non_cartesian else -(rank + 1) + batch_shape_static = calib_data.shape[:coil_axis] + batch_shape = tf.shape(calib_data)[:coil_axis] + calib_shape = tf.shape(calib_data)[coil_axis:] + calib_data = tf.reshape(calib_data, tf.concat([[-1], calib_shape], 0)) + kspace_shape = tf.shape(kspace)[coil_axis:] + kspace = tf.reshape(kspace, tf.concat([[-1], kspace_shape], 0)) + + # Apply compression for each element in batch. + def compress_coils_fn(inputs): + ksp, cal = inputs + return get_coil_compressor(method, + coil_axis=coil_axis, + **kwargs).fit(cal).transform(ksp) + output_shape = [kwargs.get('out_coils')] + kspace.shape[2:].as_list() + fn_output_signature = tf.TensorSpec(shape=output_shape, dtype=kspace.dtype) + kspace = tf.map_fn(compress_coils_fn, (kspace, calib_data), + fn_output_signature=fn_output_signature) + + # Restore batch shape. + output_shape = tf.shape(kspace)[1:] + output_shape_static = kspace.shape[1:] + kspace = tf.reshape(kspace, + tf.concat([batch_shape, output_shape], 0)) + kspace = tf.ensure_shape( + kspace, batch_shape_static.concatenate(output_shape_static)) + + return kspace + + +@api_util.export("coils.compress_coils") +def compress_coils(kspace, + coil_axis=-1, + out_coils=None, + method='svd', + **kwargs): + """Coil compression gateway. + + This function estimates a coil compression matrix and uses it to compress + `kspace`. If you would like to reuse a coil compression matrix or need to + calibrate the compression using different data, use + `tfmri.coils.get_coil_compressor`. + + This function supports the following coil compression methods: + + * **SVD**: Based on direct singular-value decomposition (SVD) of *k*-space + data [1]_. This coil compression method supports Cartesian and + non-Cartesian data. This method is resilient to noise, but does not + achieve optimal compression if there are fully-sampled dimensions. + + .. * **Geometric**: Performs local compression along fully-sampled dimensions + .. to improve compression. This method only supports Cartesian data. This + .. method can suffer from low SNR in sections of k-space. + .. * **ESPIRiT**: Performs local compression along fully-sampled dimensions + .. and is robust to noise. This method only supports Cartesian data. + + Args: + kspace: A `Tensor`. The multi-coil *k*-space data. Must have type + `complex64` or `complex128`. Must have shape `[..., Cin]`, where `...` are + the encoding dimensions and `Cin` is the number of coils. Alternatively, + the position of the coil axis may be different as long as the `coil_axis` + argument is set accordingly. If `method` is `"svd"`, `kspace` can be + Cartesian or non-Cartesian. If `method` is `"geometric"` or `"espirit"`, + `kspace` must be Cartesian. + coil_axis: An `int`. Defaults to -1. + out_coils: An `int`. The desired number of virtual output coils. + method: A `string`. The coil compression algorithm. Must be `"svd"`. + **kwargs: Additional method-specific keyword arguments to be passed to the + coil compressor. + + Returns: + A `Tensor` containing the compressed *k*-space data. Has shape + `[..., Cout]`, where `Cout` is determined based on `out_coils` or + other inputs and `...` are the unmodified encoding dimensions. + + References: + .. [1] Huang, F., Vijayakumar, S., Li, Y., Hertel, S. and Duensing, G.R. + (2008). A software channel compression technique for faster reconstruction + with many channels. Magn Reson Imaging, 26(1): 133-141. + .. [2] Zhang, T., Pauly, J.M., Vasanawala, S.S. and Lustig, M. (2013), Coil + compression for accelerated imaging with Cartesian sampling. Magn + Reson Med, 69: 571-582. https://doi.org/10.1002/mrm.24267 + .. [3] Bahri, D., Uecker, M., & Lustig, M. (2013). ESPIRIT-based coil + compression for cartesian sampling. In Proceedings of the 21st + Annual Meeting of ISMRM, Salt Lake City, Utah, USA (Vol. 47). + """ + return get_coil_compressor(method, + coil_axis=coil_axis, + out_coils=out_coils, + **kwargs).fit_transform(kspace) + + +class CoilCompressor(): + """Base class for coil compressors. + + Args: + coil_axis: An `int`. The axis of the coil dimension. + out_coils: An `int`. The desired number of virtual output coils. + """ + def __init__(self, coil_axis=-1, out_coils=None): + self._coil_axis = coil_axis + self._out_coils = out_coils + + @abc.abstractmethod + def fit(self, kspace): + pass + + @abc.abstractmethod + def transform(self, kspace): + pass + + def fit_transform(self, kspace): + return self.fit(kspace).transform(kspace) + + +@api_util.export("coils.CoilCompressorSVD") +class CoilCompressorSVD(CoilCompressor): + """SVD-based coil compression. + + This class implements the SVD-based coil compression method [1]_. + + Use this class to compress multi-coil *k*-space data. The method `fit` must + be used first to calculate the coil compression matrix. The method `transform` + can then be used to compress *k*-space data. If the data to be used for + fitting is the same data to be transformed, you can also use the method + `fit_transform` to fit and transform the data in one step. + + Args: + coil_axis: An `int`. Defaults to -1. + out_coils: An `int`. The desired number of virtual output coils. Cannot be + used together with `variance_ratio`. + variance_ratio: A `float` between 0.0 and 1.0. The percentage of total + variance to be retained. The number of virtual coils is automatically + selected to retain at least this percentage of variance. Cannot be used + together with `out_coils`. + + References: + .. [1] Huang, F., Vijayakumar, S., Li, Y., Hertel, S. and Duensing, G.R. + (2008). A software channel compression technique for faster reconstruction + with many channels. Magn Reson Imaging, 26(1): 133-141. + """ + def __init__(self, coil_axis=-1, out_coils=None, variance_ratio=None): + if out_coils is not None and variance_ratio is not None: + raise ValueError("Cannot specify both `out_coils` and `variance_ratio`.") + super().__init__(coil_axis=coil_axis, out_coils=out_coils) + self._variance_ratio = variance_ratio + self._singular_values = None + self._explained_variance = None + self._explained_variance_ratio = None + + def fit(self, kspace): + """Fits the coil compression matrix. + + Args: + kspace: A `Tensor`. The multi-coil *k*-space data. Must have type + `complex64` or `complex128`. + + Returns: + The fitted `CoilCompressorSVD` object. + """ + kspace = tf.convert_to_tensor(kspace) + + # Move coil axis to innermost dimension if not already there. + kspace, _ = self._permute_coil_axis(kspace) + + # Flatten the encoding dimensions. + num_coils = tf.shape(kspace)[-1] + kspace = tf.reshape(kspace, [-1, num_coils]) + num_samples = tf.shape(kspace)[0] + + # Compute singular-value decomposition. + s, u, v = tf.linalg.svd(kspace) + + # Compresion matrix. + self._matrix = tf.cond(num_samples > num_coils, lambda: v, lambda: u) + + # Get variance. + self._singular_values = s + self._explained_variance = s ** 2 / tf.cast(num_samples - 1, s.dtype) + total_variance = tf.math.reduce_sum(self._explained_variance) + self._explained_variance_ratio = self._explained_variance / total_variance + + # Get output coils from variance ratio. + if self._variance_ratio is not None: + cum_variance = tf.math.cumsum(self._explained_variance_ratio, axis=0) + self._out_coils = tf.math.count_nonzero( + cum_variance <= self._variance_ratio) + + # Remove unnecessary virtual coils. + if self._out_coils is not None: + self._matrix = self._matrix[:, :self._out_coils] + + # If possible, set static number of output coils. + if isinstance(self._out_coils, int): + self._matrix = tf.ensure_shape(self._matrix, [None, self._out_coils]) + + return self + + def transform(self, kspace): + """Applies the coil compression matrix to the input *k*-space. + + Args: + kspace: A `Tensor`. The multi-coil *k*-space data. Must have type + `complex64` or `complex128`. + + Returns: + The transformed k-space. + """ + kspace = tf.convert_to_tensor(kspace) + kspace, inv_perm = self._permute_coil_axis(kspace) + + # Some info. + encoding_dimensions = tf.shape(kspace)[:-1] + num_coils = tf.shape(kspace)[-1] + out_coils = tf.shape(self._matrix)[-1] + + # Flatten the encoding dimensions. + kspace = tf.reshape(kspace, [-1, num_coils]) + + # Apply compression. + kspace = tf.linalg.matmul(kspace, self._matrix) + + # Restore data shape. + kspace = tf.reshape( + kspace, + tf.concat([encoding_dimensions, [out_coils]], 0)) + + if inv_perm is not None: + kspace = tf.transpose(kspace, inv_perm) + + return kspace + + def _permute_coil_axis(self, kspace): + """Permutes the coil axis to the last dimension. + + Args: + kspace: A `Tensor`. The multi-coil *k*-space data. + + Returns: + A tuple of the permuted k-space and the inverse permutation. + """ + if self._coil_axis != -1: + rank = kspace.shape.rank # Rank must be known statically. + canonical_coil_axis = ( + self._coil_axis + rank if self._coil_axis < 0 else self._coil_axis) + perm = ( + [ax for ax in range(rank) if not ax == canonical_coil_axis] + + [canonical_coil_axis]) + kspace = tf.transpose(kspace, perm) + inv_perm = tf.math.invert_permutation(perm) + return kspace, inv_perm + return kspace, None + + @property + def singular_values(self): + """The singular values associated with each virtual coil.""" + return self._singular_values + + @property + def explained_variance(self): + """The variance explained by each virtual coil.""" + return self._explained_variance + + @property + def explained_variance_ratio(self): + """The percentage of variance explained by each virtual coil.""" + return self._explained_variance_ratio + + +@api_util.export("coils.get_coil_compressor") +def get_coil_compressor(method, **kwargs): + """Creates a coil compressor based on the specified method. + + Args: + method: A `string`. The coil compression algorithm. Must be `"svd"`. + **kwargs: Additional method-specific keyword arguments to be passed to the + coil compressor. + + Returns: + A `CoilCompressor` object. + """ + method = check_util.validate_enum( + method, {'svd', 'geometric', 'espirit'}, name='method') + if method == 'svd': + return CoilCompressorSVD(**kwargs) + raise NotImplementedError(f"Method {method} not implemented.") diff --git a/tensorflow_mri/python/coils/coil_compression_test.py b/tensorflow_mri/python/coils/coil_compression_test.py new file mode 100644 index 00000000..7a89a420 --- /dev/null +++ b/tensorflow_mri/python/coils/coil_compression_test.py @@ -0,0 +1,15 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Tests for coil compression.""" diff --git a/tensorflow_mri/python/coils/coil_sensitivities.py b/tensorflow_mri/python/coils/coil_sensitivities.py index f16a4431..4f748136 100644 --- a/tensorflow_mri/python/coils/coil_sensitivities.py +++ b/tensorflow_mri/python/coils/coil_sensitivities.py @@ -27,36 +27,39 @@ from tensorflow_mri.python.util import check_util -@api_util.export("coils.extract_calibration_data_and_estimate_sensitivities") -def extract_calibration_data_and_estimate_sensitivities( +@api_util.export("coils.estimate_sensitivities_with_calibration_data") +def estimate_sensitivities_with_calibration_data( kspace, operator, + calib_data=None, calib_window='rect', calib_region=0.1 * np.pi, - calib_method='walsh', - calib_kwargs=None): + method='walsh', + **kwargs): # For convenience. rank = operator.rank - # Low-pass filtering. - kspace = signal_ops.filter_kspace( - kspace, - trajectory=operator.trajectory, - filter_fn=calib_window, - filter_rank=rank, - filter_kwargs=dict( - cutoff=calib_region - ), - separable=isinstance(calib_region, (list, tuple))) + if calib_data is None: + # Calibration data was not provided. Get calibration data by low-pass + # filtering the input k-space. + calib_data = signal_ops.filter_kspace( + kspace, + trajectory=operator.trajectory, + filter_fn=calib_window, + filter_rank=rank, + filter_kwargs=dict( + cutoff=calib_region + ), + separable=isinstance(calib_region, (list, tuple))) # Reconstruct image. - calib_data = recon_adjoint.recon_adjoint(kspace, operator) + calib_data = recon_adjoint.recon_adjoint(calib_data, operator) # ESPIRiT method takes in k-space data, so convert back to k-space in this # case. - if calib_method == 'espirit': + if method == 'espirit': axes = list(range(-rank, 0)) - inputs = fft_ops.fftn(inputs, axes=axes, norm='ortho', shift=True) + calib_data = fft_ops.fftn(calib_data, axes=axes, norm='ortho', shift=True) # Reshape to single batch dimension. batch_shape_static = calib_data.shape[:-(rank + 1)] @@ -68,8 +71,8 @@ def extract_calibration_data_and_estimate_sensitivities( sensitivities = tf.map_fn( functools.partial(estimate_coil_sensitivities, coil_axis=-(rank + 1), - method=calib_method, - **(calib_kwargs or {})), + method=method, + **kwargs), calib_data) # Restore batch shape. @@ -83,22 +86,6 @@ def extract_calibration_data_and_estimate_sensitivities( return sensitivities -def canonicalize_calib_region(calib_region, rank): - if isinstance(calib_region, float): - calib_region = (calib_region,) * rank - if isinstance(calib_region, list): - calib_region = tuple(calib_region) - if not isinstance(calib_region, tuple): - raise TypeError( - f"calib_region must be a float or a tuple, " - f"but got {type(calib_region)}") - if len(calib_region) != rank: - raise ValueError( - f"calib_region has length {len(calib_region)}, " - f"but expected length {rank}") - return calib_region - - @api_util.export("coils.estimate_sensitivities") def estimate_coil_sensitivities(input_, coil_axis=-1, diff --git a/tensorflow_mri/python/layers/coil_compression.py b/tensorflow_mri/python/layers/coil_compression.py new file mode 100644 index 00000000..6ae3e426 --- /dev/null +++ b/tensorflow_mri/python/layers/coil_compression.py @@ -0,0 +1,99 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Coil compression layers.""" + +import numpy as np +import tensorflow as tf + +from tensorflow_mri.python.coils import coil_compression +from tensorflow_mri.python.layers import linear_operator_layer +from tensorflow_mri.python.linalg import linear_operator_mri +from tensorflow_mri.python.util import api_util + + +class CoilCompression(linear_operator_layer.LinearOperatorLayer): + """Coil compression layer. + + This layer extracts a calibration region and compresses the coils. + """ + def __init__(self, + rank, + calib_window='rect', + calib_region=0.1 * np.pi, + coil_compression_method='svd', + coil_compression_kwargs=None, + operator=linear_operator_mri.LinearOperatorMRI, + kspace_index=None, + **kwargs): + """Initializes the layer.""" + super().__init__(operator=operator, input_indices=kspace_index, **kwargs) + self.rank = rank + self.calib_window = calib_window + self.calib_region = calib_region + self.coil_compression_method = coil_compression_method + self.coil_compression_kwargs = coil_compression_kwargs or {} + + def call(self, inputs): + """Applies the layer. + + Args: + inputs: A `tuple` or `dict` containing the *k*-space data as defined by + `kspace_index`. If `operator` is a class not an instance, then `inputs` + must also contain any other arguments to be passed to the constructor of + `operator`. + + Returns: + The scaled k-space data. + """ + kspace, operator = self.parse_inputs(inputs) + return coil_compression.compress_coils_with_calibration_data( + kspace, + operator, + calib_window=self.calib_window, + calib_region=self.calib_region, + method=self.coil_compression_method, + **self.coil_compression_kwargs) + + def get_config(self): + """Returns the config of the layer. + + Returns: + A `dict` describing the layer configuration. + """ + config = { + 'calib_window': self.calib_window, + 'calib_region': self.calib_region, + 'coil_compression_method': self.coil_compression_method, + 'coil_compression_kwargs': self.coil_compression_kwargs + } + base_config = super().get_config() + kspace_index = base_config.pop('input_indices') + config['kspace_index'] = ( + kspace_index[0] if kspace_index is not None else None) + return {**config, **base_config} + + +@api_util.export("layers.CoilCompression2D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class CoilCompression2D(CoilCompression): + def __init__(self, *args, **kwargs): + super().__init__(2, *args, **kwargs) + + +@api_util.export("layers.CoilCompression3D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class CoilCompression3D(CoilCompression): + def __init__(self, *args, **kwargs): + super().__init__(3, *args, **kwargs) diff --git a/tensorflow_mri/python/layers/coil_sensitivities.py b/tensorflow_mri/python/layers/coil_sensitivities.py index fffde7b6..6f053f9a 100644 --- a/tensorflow_mri/python/layers/coil_sensitivities.py +++ b/tensorflow_mri/python/layers/coil_sensitivities.py @@ -12,13 +12,17 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== -"""*k*-space scaling layer.""" +"""Coil sensitivities layers.""" import numpy as np +import tensorflow as tf +from tensorflow_mri.python.activations import complex_activations +from tensorflow_mri.python.coils import coil_sensitivities from tensorflow_mri.python.layers import linear_operator_layer from tensorflow_mri.python.linalg import linear_operator_mri -from tensorflow_mri.python.coils import coil_sensitivities +from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.util import model_util class CoilSensitivityEstimation(linear_operator_layer.LinearOperatorLayer): @@ -28,19 +32,34 @@ class CoilSensitivityEstimation(linear_operator_layer.LinearOperatorLayer): maps. """ def __init__(self, + rank, calib_window='rect', calib_region=0.1 * np.pi, calib_method='walsh', calib_kwargs=None, + sens_network='UNet', + sens_network_kwargs=None, operator=linear_operator_mri.LinearOperatorMRI, kspace_index=None, **kwargs): """Initializes the layer.""" super().__init__(operator=operator, input_indices=kspace_index, **kwargs) + self.rank = rank self.calib_window = calib_window self.calib_region = calib_region self.calib_method = calib_method - self.calib_kwargs = calib_kwargs + self.calib_kwargs = calib_kwargs or {} + self.sens_network = sens_network + self.sens_network_kwargs = sens_network_kwargs or {} + + sens_network_kwargs = _default_sens_network_kwargs(self.sens_network) + sens_network_kwargs.update(self.sens_network_kwargs) + + if self.sens_network is not None: + sens_network_class = model_util.get_nd_model(self.sens_network, rank) + sens_network_kwargs = sens_network_kwargs.copy() + self._sens_network_layer = tf.keras.layers.TimeDistributed( + sens_network_class(**sens_network_kwargs)) def call(self, inputs): """Applies the layer. @@ -55,16 +74,21 @@ def call(self, inputs): The scaled k-space data. """ kspace, operator = self.parse_inputs(inputs) - return ( - coil_sensitivities.extract_calibration_data_and_estimate_sensitivities( + sensitivities = ( + coil_sensitivities.estimate_sensitivities_with_calibration_data( kspace, operator, calib_window=self.calib_window, calib_region=self.calib_region, - calib_method=self.calib_method, - calib_kwargs=self.calib_kwargs + method=self.calib_method, + **self.calib_kwargs ) ) + if self.sens_network is not None: + sensitivities = tf.expand_dims(sensitivities, axis=-1) + sensitivities = self._sens_network_layer(sensitivities) + sensitivities = tf.squeeze(sensitivities, axis=-1) + return sensitivities def get_config(self): """Returns the config of the layer. @@ -76,10 +100,38 @@ def get_config(self): 'calib_window': self.calib_window, 'calib_region': self.calib_region, 'calib_method': self.calib_method, - 'calib_kwargs': self.calib_kwargs + 'calib_kwargs': self.calib_kwargs, + 'sens_network': self.sens_network, + 'sens_network_kwargs': self.sens_network_kwargs } base_config = super().get_config() kspace_index = base_config.pop('input_indices') config['kspace_index'] = ( kspace_index[0] if kspace_index is not None else None) return {**config, **base_config} + + +@api_util.export("layers.CoilSensitivityEstimation2D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class CoilSensitivityEstimation2D(CoilSensitivityEstimation): + def __init__(self, *args, **kwargs): + super().__init__(2, *args, **kwargs) + + +@api_util.export("layers.CoilSensitivityEstimation3D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class CoilSensitivityEstimation3D(CoilSensitivityEstimation): + def __init__(self, *args, **kwargs): + super().__init__(3, *args, **kwargs) + + +def _default_sens_network_kwargs(name): + return { + 'UNet': dict( + filters=[32, 64, 128], + kernel_size=3, + activation=complex_activations.complex_relu, + out_channels=1, + dtype=tf.complex64 + ) + }.get(name, {}) diff --git a/tensorflow_mri/python/models/variational_network.py b/tensorflow_mri/python/models/variational_network.py index 28d1fc27..05f2ce25 100644 --- a/tensorflow_mri/python/models/variational_network.py +++ b/tensorflow_mri/python/models/variational_network.py @@ -24,6 +24,7 @@ from tensorflow_mri.python.layers import recon_adjoint from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import keras_util +from tensorflow_mri.python.util import layer_util from tensorflow_mri.python.util import model_util @@ -34,6 +35,10 @@ def __init__(self, calib_region=0.1 * np.pi, reg_network='UNet', reg_network_kwargs=None, + sens_network='UNet', + sens_network_kwargs=None, + compress_coils=True, + coil_compression_kwargs=None, scale_kspace=True, estimate_sensitivities=True, view_complex_as_real=False, @@ -49,6 +54,10 @@ def __init__(self, self.calib_region = calib_region self.reg_network = reg_network self.reg_network_kwargs = reg_network_kwargs or {} + self.sens_network = sens_network + self.sens_network_kwargs = sens_network_kwargs or {} + self.compress_coils = compress_coils + self.coil_compression_kwargs = coil_compression_kwargs or {} self.scale_kspace = scale_kspace self.estimate_sensitivities = estimate_sensitivities self.view_complex_as_real = view_complex_as_real @@ -57,6 +66,15 @@ def __init__(self, self.return_sensitivities = return_sensitivities self.kspace_index = kspace_index + if self.compress_coils: + coil_compression_kwargs = _get_default_coil_compression_kwargs() + coil_compression_kwargs.update(self.coil_compression_kwargs) + self._coil_compression_layer = layer_util.get_nd_layer( + 'CoilCompression', self.rank)( + calib_region=self.calib_region, + coil_compression_kwargs=coil_compression_kwargs, + kspace_index=self.kspace_index) + if self.scale_kspace: self._kspace_scaling_layer = kspace_scaling.KSpaceScaling( calib_region=self.calib_region, @@ -65,11 +83,12 @@ def __init__(self, self._kspace_scaling_layer = None if self.estimate_sensitivities: - self._coil_sensitivities_layer = ( - coil_sensitivities.CoilSensitivityEstimation( + self._coil_sensitivities_layer = layer_util.get_nd_layer( + 'CoilSensitivityEstimation', self.rank)( calib_region=self.calib_region, + sens_network=self.sens_network, + sens_network_kwargs=self.sens_network_kwargs, kspace_index=self.kspace_index) - ) self._recon_adjoint_layer = recon_adjoint.ReconAdjoint( kspace_index=self.kspace_index) @@ -79,7 +98,7 @@ def __init__(self, reg_network_class = model_util.get_nd_model(self.reg_network, rank) reg_network_kwargs = dict( - filters=[32, 64, 128, 256], + filters=[32, 64, 128], kernel_size=3, activation=complex_activations.complex_relu, out_channels=2 if self.view_complex_as_real else 1, @@ -109,6 +128,9 @@ def call(self, inputs): x['image_shape'] = tf.ensure_shape( image_shape[0], image_shape.shape[1:]) + if self.compress_coils: + x['kspace'] = self._coil_compression_layer(x) + if self.scale_kspace: x['kspace'] = self._kspace_scaling_layer(x) @@ -136,13 +158,6 @@ def call(self, inputs): return outputs -@api_util.export("models.VarNet1D") -@tf.keras.utils.register_keras_serializable(package='MRI') -class VarNet1D(VarNet): - def __init__(self, *args, **kwargs): - super().__init__(1, *args, **kwargs) - - @api_util.export("models.VarNet2D") @tf.keras.utils.register_keras_serializable(package='MRI') class VarNet2D(VarNet): @@ -155,3 +170,9 @@ def __init__(self, *args, **kwargs): class VarNet3D(VarNet): def __init__(self, *args, **kwargs): super().__init__(3, *args, **kwargs) + + +def _get_default_coil_compression_kwargs(): + return { + 'out_coils': 12 + } diff --git a/tensorflow_mri/python/ops/coil_ops.py b/tensorflow_mri/python/ops/coil_ops.py index 480c2c55..617abec7 100755 --- a/tensorflow_mri/python/ops/coil_ops.py +++ b/tensorflow_mri/python/ops/coil_ops.py @@ -76,254 +76,3 @@ def combine_coils(images, maps=None, coil_axis=-1, keepdims=False): axis=coil_axis, keepdims=keepdims)) return combined - - -@api_util.export("coils.compress_coils") -def compress_coils(kspace, - coil_axis=-1, - out_coils=None, - method='svd', - **kwargs): - """Coil compression gateway. - - This function estimates a coil compression matrix and uses it to compress - `kspace`. If you would like to reuse a coil compression matrix or need to - calibrate the compression using different data, use - `tfmri.coils.CoilCompressorSVD`. - - This function supports the following coil compression methods: - - * **SVD**: Based on direct singular-value decomposition (SVD) of *k*-space - data [1]_. This coil compression method supports Cartesian and - non-Cartesian data. This method is resilient to noise, but does not - achieve optimal compression if there are fully-sampled dimensions. - - .. * **Geometric**: Performs local compression along fully-sampled dimensions - .. to improve compression. This method only supports Cartesian data. This - .. method can suffer from low SNR in sections of k-space. - .. * **ESPIRiT**: Performs local compression along fully-sampled dimensions - .. and is robust to noise. This method only supports Cartesian data. - - Args: - kspace: A `Tensor`. The multi-coil *k*-space data. Must have type - `complex64` or `complex128`. Must have shape `[..., Cin]`, where `...` are - the encoding dimensions and `Cin` is the number of coils. Alternatively, - the position of the coil axis may be different as long as the `coil_axis` - argument is set accordingly. If `method` is `"svd"`, `kspace` can be - Cartesian or non-Cartesian. If `method` is `"geometric"` or `"espirit"`, - `kspace` must be Cartesian. - coil_axis: An `int`. Defaults to -1. - out_coils: An `int`. The desired number of virtual output coils. - method: A `string`. The coil compression algorithm. Must be `"svd"`. - **kwargs: Additional method-specific keyword arguments to be passed to the - coil compressor. - - Returns: - A `Tensor` containing the compressed *k*-space data. Has shape - `[..., Cout]`, where `Cout` is determined based on `out_coils` or - other inputs and `...` are the unmodified encoding dimensions. - - References: - .. [1] Huang, F., Vijayakumar, S., Li, Y., Hertel, S. and Duensing, G.R. - (2008). A software channel compression technique for faster reconstruction - with many channels. Magn Reson Imaging, 26(1): 133-141. - .. [2] Zhang, T., Pauly, J.M., Vasanawala, S.S. and Lustig, M. (2013), Coil - compression for accelerated imaging with Cartesian sampling. Magn - Reson Med, 69: 571-582. https://doi.org/10.1002/mrm.24267 - .. [3] Bahri, D., Uecker, M., & Lustig, M. (2013). ESPIRIT-based coil - compression for cartesian sampling. In Proceedings of the 21st - Annual Meeting of ISMRM, Salt Lake City, Utah, USA (Vol. 47). - """ - # pylint: disable=missing-raises-doc - kspace = tf.convert_to_tensor(kspace) - tf.debugging.assert_rank_at_least(kspace, 2, message=( - f"Argument `kspace` must have rank of at least 2, but got shape: " - f"{kspace.shape}")) - coil_axis = check_util.validate_type(coil_axis, int, name='coil_axis') - method = check_util.validate_enum( - method, {'svd', 'geometric', 'espirit'}, name='method') - - # Calculate the compression matrix, unless one was already provided. - if method == 'svd': - return CoilCompressorSVD(coil_axis=coil_axis, - out_coils=out_coils, - **kwargs).fit_transform(kspace) - - raise NotImplementedError(f"Method {method} not implemented.") - - -class _CoilCompressor(): - """Base class for coil compressors. - - Args: - coil_axis: An `int`. The axis of the coil dimension. - out_coils: An `int`. The desired number of virtual output coils. - """ - def __init__(self, coil_axis=-1, out_coils=None): - self._coil_axis = coil_axis - self._out_coils = out_coils - - @abc.abstractmethod - def fit(self, kspace): - pass - - @abc.abstractmethod - def transform(self, kspace): - pass - - def fit_transform(self, kspace): - return self.fit(kspace).transform(kspace) - - -@api_util.export("coils.CoilCompressorSVD") -class CoilCompressorSVD(_CoilCompressor): - """SVD-based coil compression. - - This class implements the SVD-based coil compression method [1]_. - - Use this class to compress multi-coil *k*-space data. The method `fit` must - be used first to calculate the coil compression matrix. The method `transform` - can then be used to compress *k*-space data. If the data to be used for - fitting is the same data to be transformed, you can also use the method - `fit_transform` to fit and transform the data in one step. - - Args: - coil_axis: An `int`. Defaults to -1. - out_coils: An `int`. The desired number of virtual output coils. Cannot be - used together with `variance_ratio`. - variance_ratio: A `float` between 0.0 and 1.0. The percentage of total - variance to be retained. The number of virtual coils is automatically - selected to retain at least this percentage of variance. Cannot be used - together with `out_coils`. - - References: - .. [1] Huang, F., Vijayakumar, S., Li, Y., Hertel, S. and Duensing, G.R. - (2008). A software channel compression technique for faster reconstruction - with many channels. Magn Reson Imaging, 26(1): 133-141. - """ - def __init__(self, coil_axis=-1, out_coils=None, variance_ratio=None): - if out_coils is not None and variance_ratio is not None: - raise ValueError("Cannot specify both `out_coils` and `variance_ratio`.") - super().__init__(coil_axis=coil_axis, out_coils=out_coils) - self._variance_ratio = variance_ratio - self._singular_values = None - self._explained_variance = None - self._explained_variance_ratio = None - - def fit(self, kspace): - """Fits the coil compression matrix. - - Args: - kspace: A `Tensor`. The multi-coil *k*-space data. Must have type - `complex64` or `complex128`. - - Returns: - The fitted `CoilCompressorSVD` object. - """ - kspace = tf.convert_to_tensor(kspace) - - # Move coil axis to innermost dimension if not already there. - kspace, _ = self._permute_coil_axis(kspace) - - # Flatten the encoding dimensions. - num_coils = tf.shape(kspace)[-1] - kspace = tf.reshape(kspace, [-1, num_coils]) - num_samples = tf.shape(kspace)[0] - - # Compute singular-value decomposition. - s, u, v = tf.linalg.svd(kspace) - - # Compresion matrix. - self._matrix = tf.cond(num_samples > num_coils, lambda: v, lambda: u) - - # Get variance. - self._singular_values = s - self._explained_variance = s ** 2 / tf.cast(num_samples - 1, s.dtype) - total_variance = tf.math.reduce_sum(self._explained_variance) - self._explained_variance_ratio = self._explained_variance / total_variance - - # Get output coils from variance ratio. - if self._variance_ratio is not None: - cum_variance = tf.math.cumsum(self._explained_variance_ratio, axis=0) - self._out_coils = tf.math.count_nonzero( - cum_variance <= self._variance_ratio) - - # Remove unnecessary virtual coils. - if self._out_coils is not None: - self._matrix = self._matrix[:, :self._out_coils] - - # If possible, set static number of output coils. - if isinstance(self._out_coils, int): - self._matrix = tf.ensure_shape(self._matrix, [None, self._out_coils]) - - return self - - def transform(self, kspace): - """Applies the coil compression matrix to the input *k*-space. - - Args: - kspace: A `Tensor`. The multi-coil *k*-space data. Must have type - `complex64` or `complex128`. - - Returns: - The transformed k-space. - """ - kspace = tf.convert_to_tensor(kspace) - kspace, inv_perm = self._permute_coil_axis(kspace) - - # Some info. - encoding_dimensions = tf.shape(kspace)[:-1] - num_coils = tf.shape(kspace)[-1] - out_coils = tf.shape(self._matrix)[-1] - - # Flatten the encoding dimensions. - kspace = tf.reshape(kspace, [-1, num_coils]) - - # Apply compression. - kspace = tf.linalg.matmul(kspace, self._matrix) - - # Restore data shape. - kspace = tf.reshape( - kspace, - tf.concat([encoding_dimensions, [out_coils]], 0)) - - if inv_perm is not None: - kspace = tf.transpose(kspace, inv_perm) - - return kspace - - def _permute_coil_axis(self, kspace): - """Permutes the coil axis to the last dimension. - - Args: - kspace: A `Tensor`. The multi-coil *k*-space data. - - Returns: - A tuple of the permuted k-space and the inverse permutation. - """ - if self._coil_axis != -1: - rank = kspace.shape.rank # Rank must be known statically. - canonical_coil_axis = ( - self._coil_axis + rank if self._coil_axis < 0 else self._coil_axis) - perm = ( - [ax for ax in range(rank) if not ax == canonical_coil_axis] + - [canonical_coil_axis]) - kspace = tf.transpose(kspace, perm) - inv_perm = tf.math.invert_permutation(perm) - return kspace, inv_perm - return kspace, None - - @property - def singular_values(self): - """The singular values associated with each virtual coil.""" - return self._singular_values - - @property - def explained_variance(self): - """The variance explained by each virtual coil.""" - return self._explained_variance - - @property - def explained_variance_ratio(self): - """The percentage of variance explained by each virtual coil.""" - return self._explained_variance_ratio diff --git a/tensorflow_mri/python/util/layer_util.py b/tensorflow_mri/python/util/layer_util.py index a4064fb0..dae9fe0e 100644 --- a/tensorflow_mri/python/util/layer_util.py +++ b/tensorflow_mri/python/util/layer_util.py @@ -16,6 +16,8 @@ import tensorflow as tf +from tensorflow_mri.python.layers import coil_compression +from tensorflow_mri.python.layers import coil_sensitivities from tensorflow_mri.python.layers import convolutional from tensorflow_mri.python.layers import padding from tensorflow_mri.python.layers import pooling @@ -47,6 +49,10 @@ def get_nd_layer(name, rank): ('AveragePooling', 1): pooling.AveragePooling1D, ('AveragePooling', 2): pooling.AveragePooling2D, ('AveragePooling', 3): pooling.AveragePooling3D, + ('CoilCompression', 2): coil_compression.CoilCompression2D, + ('CoilCompression', 3): coil_compression.CoilCompression3D, + ('CoilSensitivityEstimation', 2): coil_sensitivities.CoilSensitivityEstimation2D, + ('CoilSensitivityEstimation', 3): coil_sensitivities.CoilSensitivityEstimation3D, ('Conv', 1): convolutional.Conv1D, ('Conv', 2): convolutional.Conv2D, ('Conv', 3): convolutional.Conv3D, From b168badc26fee06bd94624b07b948f52ea26ad31 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Sat, 20 Aug 2022 16:24:48 +0000 Subject: [PATCH 031/101] Working on VarNet --- tensorflow_mri/_api/layers/__init__.py | 6 +++-- .../python/layers/kspace_scaling.py | 18 +++++++++++-- tensorflow_mri/python/layers/recon_adjoint.py | 18 +++++++++++-- .../python/models/variational_network.py | 16 ++++++------ tensorflow_mri/python/util/layer_util.py | 6 +++++ tensorflow_mri/python/util/plot_util.py | 26 ++++++++++++++----- 6 files changed, 70 insertions(+), 20 deletions(-) diff --git a/tensorflow_mri/_api/layers/__init__.py b/tensorflow_mri/_api/layers/__init__.py index 1f4454b5..d9815ca0 100644 --- a/tensorflow_mri/_api/layers/__init__.py +++ b/tensorflow_mri/_api/layers/__init__.py @@ -13,7 +13,8 @@ from tensorflow_mri.python.layers.conv_blocks import ConvBlock as ConvBlock from tensorflow_mri.python.layers.conv_endec import UNet as UNet from tensorflow_mri.python.layers.data_consistency import LeastSquaresGradientDescent as LeastSquaresGradientDescent -from tensorflow_mri.python.layers.kspace_scaling import KSpaceScaling as KSpaceScaling +from tensorflow_mri.python.layers.kspace_scaling import KSpaceScaling2D as KSpaceScaling2D +from tensorflow_mri.python.layers.kspace_scaling import KSpaceScaling3D as KSpaceScaling3D from tensorflow_mri.python.layers.pooling import AveragePooling1D as AveragePooling1D from tensorflow_mri.python.layers.pooling import AveragePooling1D as AvgPool1D from tensorflow_mri.python.layers.pooling import AveragePooling2D as AveragePooling2D @@ -26,7 +27,8 @@ from tensorflow_mri.python.layers.pooling import MaxPooling2D as MaxPool2D from tensorflow_mri.python.layers.pooling import MaxPooling3D as MaxPooling3D from tensorflow_mri.python.layers.pooling import MaxPooling3D as MaxPool3D -from tensorflow_mri.python.layers.recon_adjoint import ReconAdjoint as ReconAdjoint +from tensorflow_mri.python.layers.recon_adjoint import ReconAdjoint2D as ReconAdjoint2D +from tensorflow_mri.python.layers.recon_adjoint import ReconAdjoint3D as ReconAdjoint3D from tensorflow_mri.python.layers.reshaping import UpSampling1D as UpSampling1D from tensorflow_mri.python.layers.reshaping import UpSampling2D as UpSampling2D from tensorflow_mri.python.layers.reshaping import UpSampling3D as UpSampling3D diff --git a/tensorflow_mri/python/layers/kspace_scaling.py b/tensorflow_mri/python/layers/kspace_scaling.py index 8b5fd5b5..c45d7dd6 100644 --- a/tensorflow_mri/python/layers/kspace_scaling.py +++ b/tensorflow_mri/python/layers/kspace_scaling.py @@ -25,8 +25,6 @@ from tensorflow_mri.python.util import keras_util -@api_util.export("layers.KSpaceScaling") -@tf.keras.utils.register_keras_serializable(package="MRI") class KSpaceScaling(linear_operator_layer.LinearOperatorLayer): """K-space scaling layer. @@ -34,6 +32,7 @@ class KSpaceScaling(linear_operator_layer.LinearOperatorLayer): magnitude values in the approximate `[0, 1]` range. """ def __init__(self, + rank, calib_window='rect', calib_region=0.1 * np.pi, operator=linear_operator_mri.LinearOperatorMRI, @@ -44,6 +43,7 @@ def __init__(self, super().__init__(operator=operator, input_indices=kspace_index, **kwargs) + self.rank = rank self.calib_window = calib_window self.calib_region = calib_region @@ -88,3 +88,17 @@ def get_config(self): config['kspace_index'] = ( kspace_index[0] if kspace_index is not None else None) return {**config, **base_config} + + +@api_util.export("layers.KSpaceScaling2D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class KSpaceScaling2D(KSpaceScaling): + def __init__(self, *args, **kwargs): + super().__init__(2, *args, **kwargs) + + +@api_util.export("layers.KSpaceScaling3D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class KSpaceScaling3D(KSpaceScaling): + def __init__(self, *args, **kwargs): + super().__init__(3, *args, **kwargs) diff --git a/tensorflow_mri/python/layers/recon_adjoint.py b/tensorflow_mri/python/layers/recon_adjoint.py index e43638dc..7161869c 100644 --- a/tensorflow_mri/python/layers/recon_adjoint.py +++ b/tensorflow_mri/python/layers/recon_adjoint.py @@ -23,14 +23,13 @@ from tensorflow_mri.python.util import keras_util -@api_util.export("layers.ReconAdjoint") -@tf.keras.utils.register_keras_serializable(package="MRI") class ReconAdjoint(linear_operator_layer.LinearOperatorLayer): """Adjoint reconstruction layer. This layer reconstructs a signal using the adjoint of the system operator. """ def __init__(self, + rank, channel_dimension=True, operator=linear_operator_mri.LinearOperatorMRI, kspace_index=None, @@ -38,6 +37,7 @@ def __init__(self, """Initializes the layer.""" kwargs['dtype'] = kwargs.get('dtype') or keras_util.complexx() super().__init__(operator=operator, input_indices=kspace_index, **kwargs) + self.rank = rank self.channel_dimension = channel_dimension def call(self, inputs): @@ -72,3 +72,17 @@ def get_config(self): config['kspace_index'] = ( kspace_index[0] if kspace_index is not None else None) return {**config, **base_config} + + +@api_util.export("layers.ReconAdjoint2D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class ReconAdjoint2D(ReconAdjoint): + def __init__(self, *args, **kwargs): + super().__init__(2, *args, **kwargs) + + +@api_util.export("layers.ReconAdjoint3D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class ReconAdjoint3D(ReconAdjoint): + def __init__(self, *args, **kwargs): + super().__init__(3, *args, **kwargs) diff --git a/tensorflow_mri/python/models/variational_network.py b/tensorflow_mri/python/models/variational_network.py index 05f2ce25..1b851b21 100644 --- a/tensorflow_mri/python/models/variational_network.py +++ b/tensorflow_mri/python/models/variational_network.py @@ -76,11 +76,10 @@ def __init__(self, kspace_index=self.kspace_index) if self.scale_kspace: - self._kspace_scaling_layer = kspace_scaling.KSpaceScaling( - calib_region=self.calib_region, - kspace_index=self.kspace_index) - else: - self._kspace_scaling_layer = None + self._kspace_scaling_layer = layer_util.get_nd_layer( + 'KSpaceScaling', self.rank)( + calib_region=self.calib_region, + kspace_index=self.kspace_index) if self.estimate_sensitivities: self._coil_sensitivities_layer = layer_util.get_nd_layer( @@ -90,8 +89,9 @@ def __init__(self, sens_network_kwargs=self.sens_network_kwargs, kspace_index=self.kspace_index) - self._recon_adjoint_layer = recon_adjoint.ReconAdjoint( - kspace_index=self.kspace_index) + self._recon_adjoint_layer = layer_util.get_nd_layer( + 'ReconAdjoint', self.rank)( + kspace_index=self.kspace_index) lsgd_layer_class = data_consistency.LeastSquaresGradientDescent lsgd_layers_kwargs = {} @@ -113,7 +113,7 @@ def __init__(self, for i in range(self.num_iterations)] def call(self, inputs): - x = inputs + x = {k: v for k, v in inputs.items()} if 'image_shape' in x: image_shape = x['image_shape'] diff --git a/tensorflow_mri/python/util/layer_util.py b/tensorflow_mri/python/util/layer_util.py index dae9fe0e..4629fee5 100644 --- a/tensorflow_mri/python/util/layer_util.py +++ b/tensorflow_mri/python/util/layer_util.py @@ -19,8 +19,10 @@ from tensorflow_mri.python.layers import coil_compression from tensorflow_mri.python.layers import coil_sensitivities from tensorflow_mri.python.layers import convolutional +from tensorflow_mri.python.layers import kspace_scaling from tensorflow_mri.python.layers import padding from tensorflow_mri.python.layers import pooling +from tensorflow_mri.python.layers import recon_adjoint from tensorflow_mri.python.layers import reshaping from tensorflow_mri.python.layers import signal_layers @@ -82,11 +84,15 @@ def get_nd_layer(name, rank): ('IDWT', 1): signal_layers.IDWT1D, ('IDWT', 2): signal_layers.IDWT2D, ('IDWT', 3): signal_layers.IDWT3D, + ('KSpaceScaling', 2): kspace_scaling.KSpaceScaling2D, + ('KSpaceScaling', 3): kspace_scaling.KSpaceScaling3D, ('LocallyConnected', 1): tf.keras.layers.LocallyConnected1D, ('LocallyConnected', 2): tf.keras.layers.LocallyConnected2D, ('MaxPool', 1): pooling.MaxPooling1D, ('MaxPool', 2): pooling.MaxPooling2D, ('MaxPool', 3): pooling.MaxPooling3D, + ('ReconAdjoint', 2): recon_adjoint.ReconAdjoint2D, + ('ReconAdjoint', 3): recon_adjoint.ReconAdjoint3D, ('SeparableConv', 1): tf.keras.layers.SeparableConv1D, ('SeparableConv', 2): tf.keras.layers.SeparableConv2D, ('SpatialDropout', 1): tf.keras.layers.SpatialDropout1D, diff --git a/tensorflow_mri/python/util/plot_util.py b/tensorflow_mri/python/util/plot_util.py index 80f2e7b2..8cecff66 100644 --- a/tensorflow_mri/python/util/plot_util.py +++ b/tensorflow_mri/python/util/plot_util.py @@ -125,7 +125,7 @@ def plot_tiled_image_sequence(images, layout=None, bbox_inches=None, pad_inches=0.1, - aspect=1.77, # 16:9 + aspect=None, grid_shape=None, fig_title=None, subplot_titles=None): @@ -157,8 +157,9 @@ def plot_tiled_image_sequence(images, try to figure out the tight bbox of the figure. pad_inches: A `float`. Amount of padding around the figure when bbox_inches is `'tight'`. Defaults to 0.1. - aspect: A `float`. The desired aspect ratio of the overall figure. Ignored - if `grid_shape` is specified. + aspect: A `float`. The desired aspect ratio of the overall figure. If + `None`, defaults to the aspect ratio of `fig_size`. Ignored if + `grid_shape` is specified. grid_shape: A `tuple` of `float`s. The number of rows and columns in the grid. If `None`, the grid shape is computed from `aspect`. fig_title: A `str`. The title of the figure. @@ -177,6 +178,12 @@ def plot_tiled_image_sequence(images, images = _preprocess_image(images, part=part, expected_ndim=(4, 5)) num_tiles, num_frames, image_rows, image_cols = images.shape[:4] + if fig_size is None: + fig_size = mpl.rcParams['figure.figsize'] + + if aspect is None: + aspect = fig_size[0] / fig_size[1] + # Compute the number of rows and cols for tile. if grid_shape is not None: grid_rows, grid_cols = grid_shape @@ -243,7 +250,7 @@ def plot_tiled_image(images, layout=None, bbox_inches=None, pad_inches=0.1, - aspect=1.77, # 16:9 + aspect=None, grid_shape=None, fig_title=None, subplot_titles=None, @@ -276,8 +283,9 @@ def plot_tiled_image(images, try to figure out the tight bbox of the figure. pad_inches: A `float`. Amount of padding around the figure when bbox_inches is `'tight'`. Defaults to 0.1. - aspect: A `float`. The desired aspect ratio of the overall figure. Ignored - if `grid_shape` is specified. + aspect: A `float`. The desired aspect ratio of the overall figure. If + `None`, defaults to the aspect ratio of `fig_size`. Ignored if + `grid_shape` is specified. grid_shape: A `tuple` of `float`s. The number of rows and columns in the grid. If `None`, the grid shape is computed from `aspect`. fig_title: A `str`. The title of the figure. @@ -297,6 +305,12 @@ def plot_tiled_image(images, images = _preprocess_image(images, part=part, expected_ndim=(3, 4)) num_tiles, image_rows, image_cols = images.shape[:3] + if fig_size is None: + fig_size = mpl.rcParams['figure.figsize'] + + if aspect is None: + aspect = fig_size[0] / fig_size[1] + # Compute the number of rows and cols for tile. if grid_shape is not None: grid_rows, grid_cols = grid_shape From fd1a4e1e4ff7572da8874c1f1d0a60a8becb10d3 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Sat, 20 Aug 2022 16:26:54 +0000 Subject: [PATCH 032/101] Fixed a bug in TensorBoard images callback --- tensorflow_mri/python/callbacks/tensorboard_callbacks.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/tensorflow_mri/python/callbacks/tensorboard_callbacks.py b/tensorflow_mri/python/callbacks/tensorboard_callbacks.py index 9de96d8d..6fbafbcf 100644 --- a/tensorflow_mri/python/callbacks/tensorboard_callbacks.py +++ b/tensorflow_mri/python/callbacks/tensorboard_callbacks.py @@ -146,8 +146,10 @@ def _write_image_summaries(self, step=0): if len(images) >= self.max_images: break - # Stack all the images. - images = tf.stack(images) + # Stack all the images. Converting to tensor is required to avoid unexpected + # casting (e.g., without it, a list of NumPy arrays of uint8 inputs returns + # an int32 tensor). + images = tf.stack([tf.convert_to_tensor(image) for image in images]) # Keep only selected slice, if requested. if isinstance(self.volume_mode, int): From ba6433b0bda910b445d6a0523f016ac69a3f0b4b Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Sat, 20 Aug 2022 17:33:58 +0000 Subject: [PATCH 033/101] Add docs for ReconAdjoint --- .../python/layers/linear_operator_layer.py | 41 ++++----- tensorflow_mri/python/layers/recon_adjoint.py | 86 +++++++++++++------ tensorflow_mri/python/util/__init__.py | 1 + tensorflow_mri/python/util/doc_util.py | 25 ++++++ 4 files changed, 101 insertions(+), 52 deletions(-) create mode 100644 tensorflow_mri/python/util/doc_util.py diff --git a/tensorflow_mri/python/layers/linear_operator_layer.py b/tensorflow_mri/python/layers/linear_operator_layer.py index 34e621db..a959efa5 100644 --- a/tensorflow_mri/python/layers/linear_operator_layer.py +++ b/tensorflow_mri/python/layers/linear_operator_layer.py @@ -49,42 +49,33 @@ def parse_inputs(self, inputs): method. It returns the inputs and an instance of the linear operator to be used. """ - if isinstance(inputs, tuple): - # Parse inputs if passed a tuple. - if self._input_indices is None: - input_indices = (0,) - else: - input_indices = self._input_indices - main = tuple(inputs[i] for i in input_indices) - args = tuple(inputs[i] for i in range(len(inputs)) - if i not in input_indices) - kwargs = {} + if self._operator_instance is None: + # operator is a class. + if not isinstance(inputs, dict): + raise ValueError( + f"Layer {self.name} expected a mapping. " + f"Received: {inputs}") - elif isinstance(inputs, dict): - # Parse inputs if passed a dict. if self._input_indices is None: input_indices = (tuple(inputs.keys())[0],) else: input_indices = self._input_indices + main = tuple(inputs[i] for i in input_indices) - args = () kwargs = {k: v for k, v in inputs.items() if k not in input_indices} - # Unpack single input. - if len(main) == 1: - main = main[0] + # Unpack single input. + if len(main) == 1: + main = main[0] + + # Instantiate the operator. + operator = self._operator_class(**kwargs) - # Create operator. - if self._operator_instance is None: - # No instance was provided, so create one. - operator = self._operator_class(*args, **kwargs) else: - # Instance was provided, so use it. - if args or kwargs: - raise ValueError( - "`args` and `kwargs` cannot be used when an instance of " - "`tfmri.linalg.LinearOperator` was provided. Check your inputs.") + # Inputs. + main = inputs operator = self._operator_instance + return main, operator def get_config(self): diff --git a/tensorflow_mri/python/layers/recon_adjoint.py b/tensorflow_mri/python/layers/recon_adjoint.py index 7161869c..487305ae 100644 --- a/tensorflow_mri/python/layers/recon_adjoint.py +++ b/tensorflow_mri/python/layers/recon_adjoint.py @@ -14,63 +14,85 @@ # ============================================================================== """Adjoint reconstruction layer.""" +import string + import tensorflow as tf from tensorflow_mri.python.layers import linear_operator_layer from tensorflow_mri.python.linalg import linear_operator_mri from tensorflow_mri.python.recon import recon_adjoint from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.util import doc_util from tensorflow_mri.python.util import keras_util -class ReconAdjoint(linear_operator_layer.LinearOperatorLayer): - """Adjoint reconstruction layer. +DOCSTRING = string.Template( + """${rank}-D adjoint reconstruction layer. + + This layer reconstructs a signal using the adjoint of the specified system + operator. + + This layer's `inputs` differ depending on whether `operator` is a class or an + instance. + + - If `operator` is a class, then `inputs` must be a `dict` containing both + the inputs to the operator's constructor (e.g., *k*-space mask, trajectory, + coil sensitivities, etc...) and the input to the operator's `transform` + method (usually, the *k*-space data). The value at `kspace_index` will be + passed to the operator's `transform` method. Any other values in `inputs` + will be passed to the operator's constructor. + + - If `operator` is an instance, then `inputs` only contains the input to the + operator's `transform` method (usually, the *k*-space data). In this case, + `inputs` must be a `tf.Tensor` which will be passed unmodified to the + operator's `transform` method. + + Args: + expand_channel_dim: A `boolean`. Whether to expand the channel dimension. + If `True`, the output has shape `[*batch_shape, ${dim_names}, 1]`. + If `False`, the output has shape `[*batch_shape, ${dim_names}]`. + Defaults to `True`. + operator: A subclass of `tfmri.linalg.LinearOperator` or an instance + thereof. The system operator. This object may be a class or an instance. + + - If `operator` is a class, then a new instance will be created during + each evaluation of `call`. The constructor will be passed the arguments + in `inputs` except `kspace_index`. + - If `operator` is an instance, then it will be used as is. + + Defaults to `tfmri.linalg.LinearOperatorMRI`. + kspace_index: A `str`. The key of `inputs` containing the *k*-space data. + Defaults to `None`, which takes the first element of `inputs`. + """) - This layer reconstructs a signal using the adjoint of the system operator. - """ + +class ReconAdjoint(linear_operator_layer.LinearOperatorLayer): def __init__(self, rank, - channel_dimension=True, + expand_channel_dim=True, operator=linear_operator_mri.LinearOperatorMRI, kspace_index=None, **kwargs): - """Initializes the layer.""" kwargs['dtype'] = kwargs.get('dtype') or keras_util.complexx() super().__init__(operator=operator, input_indices=kspace_index, **kwargs) self.rank = rank - self.channel_dimension = channel_dimension + self.expand_channel_dim = expand_channel_dim def call(self, inputs): - """Applies the layer. - - Args: - inputs: A `tuple` or `dict` containing the *k*-space data as defined by - `kspace_index`. If `operator` is a class not an instance, then `inputs` - must also contain any other arguments to be passed to the constructor of - `operator`. - - Returns: - The reconstructed k-space data. - """ kspace, operator = self.parse_inputs(inputs) image = recon_adjoint.recon_adjoint(kspace, operator) - if self.channel_dimension: + if self.expand_channel_dim: image = tf.expand_dims(image, axis=-1) return image def get_config(self): - """Returns the config of the layer. - - Returns: - A `dict` describing the layer configuration. - """ config = { - 'channel_dimension': self.channel_dimension + 'expand_channel_dim': self.expand_channel_dim } base_config = super().get_config() - kspace_index = base_config.pop('input_indices') + input_indices = base_config.pop('input_indices') config['kspace_index'] = ( - kspace_index[0] if kspace_index is not None else None) + input_indices[0] if input_indices is not None else None) return {**config, **base_config} @@ -86,3 +108,13 @@ def __init__(self, *args, **kwargs): class ReconAdjoint3D(ReconAdjoint): def __init__(self, *args, **kwargs): super().__init__(3, *args, **kwargs) + + +ReconAdjoint2D.__doc__ = DOCSTRING.substitute( + rank=2, dim_names='height, width') +ReconAdjoint3D.__doc__ = DOCSTRING.substitute( + rank=3, dim_names='depth, height, width') + + +ReconAdjoint2D.__signature__ = doc_util.get_nd_layer_signature(ReconAdjoint) +ReconAdjoint3D.__signature__ = doc_util.get_nd_layer_signature(ReconAdjoint) diff --git a/tensorflow_mri/python/util/__init__.py b/tensorflow_mri/python/util/__init__.py index 9a30f059..4586b2dd 100644 --- a/tensorflow_mri/python/util/__init__.py +++ b/tensorflow_mri/python/util/__init__.py @@ -17,6 +17,7 @@ from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util from tensorflow_mri.python.util import deprecation +from tensorflow_mri.python.util import doc_util from tensorflow_mri.python.util import import_util from tensorflow_mri.python.util import io_util from tensorflow_mri.python.util import keras_util diff --git a/tensorflow_mri/python/util/doc_util.py b/tensorflow_mri/python/util/doc_util.py new file mode 100644 index 00000000..9b5879ba --- /dev/null +++ b/tensorflow_mri/python/util/doc_util.py @@ -0,0 +1,25 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Utilities for documentation.""" + +import inspect + + +def get_nd_layer_signature(base): + signature = inspect.signature(base.__init__) + parameters = signature.parameters + parameters = [v for k, v in parameters.items() if k not in ('self', 'rank')] + signature = signature.replace(parameters=parameters) + return signature From a1b5038372e9d03f821cb24adaa340fe0199b25e Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Sun, 21 Aug 2022 18:47:14 +0000 Subject: [PATCH 034/101] Added mask functions --- tensorflow_mri/python/ops/traj_ops.py | 177 +++++++++++++++++++++ tensorflow_mri/python/ops/traj_ops_test.py | 83 ++++++++++ 2 files changed, 260 insertions(+) diff --git a/tensorflow_mri/python/ops/traj_ops.py b/tensorflow_mri/python/ops/traj_ops.py index 21374506..553ac310 100755 --- a/tensorflow_mri/python/ops/traj_ops.py +++ b/tensorflow_mri/python/ops/traj_ops.py @@ -193,6 +193,183 @@ def random_sampling_mask(shape, density=1.0, seed=None, rng=None, name=None): return tf.cast(mask, tf.bool) +@api_util.export("sampling.central_mask") +def central_mask(shape, center_size, name=None): + """Returns a central sampling mask. + + This function returns a boolean tensor of zeros with a central region of ones. + + .. tip:: + Use this function to extract the calibration region from a Cartesian + *k*-space. + + .. tip:: + In MRI, one of the spatial frequency dimensions (readout dimension) is + typically fully sampled. In this case, you might want to create a mask that + has one less dimension than the corresponding *k*-space (e.g., 1D mask for + 2D images or 2D mask for 3D images). + + .. note:: + The central region is always evenly shaped for even mask dimensions and + oddly shaped for odd mask dimensions. This avoids phase artefacts when + using the resulting mask to sample the frequency domain. + + Example: + >>> import tensorflow as tfmri + >>> mask = tfmri.sampling.central_mask([8], [4]) + >>> mask.numpy() + array([False, False, True, True, True, True, False, False]) + + Args: + shape: A 1D integer `tf.Tensor`. The shape of the output mask. + center_size: A 1D `tf.Tensor` of integer or floating point dtype. The size + of the center region. If `center_size` has integer dtype, its i-th value + must be in the range `[0, shape[i]]` and will be interpreted as the number + of samples in the center region along axis `i`. If `center_size` has + floating point dtype, its i-th value must be in the range `[0, 1]` and + will be interpreted as the fraction of samples in the center region along + axis `i`. + name: A `str`. A name for this op. + + Returns: + A boolean `tf.Tensor` containing the sampling mask. + + Raises: + TypeError: If `center_size` is not of integer or floating point dtype. + """ + with tf.name_scope(name or 'central_mask'): + shape = tf.convert_to_tensor(shape, dtype=tf.int32) + center_size = tf.convert_to_tensor(center_size) + + if not center_size.dtype.is_integer and not center_size.dtype.is_floating: + raise TypeError( + "`center_size` must be of integer of floating point dtype.") + + if center_size.dtype.is_floating: + # Input is floating point, interpret as fraction and convert to integer. + center_size = center_size * tf.cast(shape, center_size.dtype) + center_size = tf.cast(center_size + 0.5, tf.int32) + + # Make sure that `center_size` is even for even shape and odd for odd shape. + center_size = (center_size // 2) * 2 + shape % 2 + # Make sure that `center_size` is not bigger than the shape. + center_size = tf.math.minimum(center_size, shape) + + # Create mask by first creating a central region of ones, and then padding + # with zeros to the specified shape. + mask = tf.ones(center_size, dtype=tf.bool) + paddings = tf.stack([(shape - center_size) // 2, + (shape - center_size) // 2], axis=-1) + mask = tf.pad(mask, paddings, constant_values=False) + return mask + + +@api_util.export("sampling.biphasic_mask") +def biphasic_mask(shape, + acceleration, + central_size, + mask_type='equispaced', + offset=0, + rng=None, + name=None): + """Returns a biphasic sampling mask. + + A biphasic sampling mask has a fully sampled central region and a partially + sampled peripheral region. The peripheral may be sampled uniformly or + randomly. + + .. tip:: + This type of mask describes the most commonly used sampling patterns in + Cartesian MRI. + + .. tip:: + In MRI, one of the spatial frequency dimensions (readout dimension) is + typically fully sampled. In this case, you might want to create a mask that + has one less dimension than the corresponding *k*-space (e.g., 1D mask for + 2D images or 2D mask for 3D images). + + .. note:: + The central region is always evenly shaped for even mask dimensions and + oddly shaped for odd mask dimensions. This avoids phase artefacts when + using the resulting mask to sample the frequency domain. + + Example: + >>> import tensorflow as tfmri + >>> mask = tfmri.sampling.biphasic_mask([8], [2], [2]) + >>> mask.numpy() + array([True, False, True, True, True, False, True, False]) + + Args: + shape: A 1D integer `tf.Tensor`. The shape of the output mask. + acceleration: A 1D integer `tf.Tensor`. The acceleration factor on the + peripheral region along each axis. + central_size: A 1D integer `tf.Tensor`. The size of the central region + along each axis. + mask_type: A `str`. The type of sampling to use on the peripheral region. + Must be one of `'equispaced'` or `'random'`. If `'equispaced'`, the + peripheral region is sampled uniformly. If `'random'`, the peripheral + region is sampled randomly with the expected acceleration value. Defaults + to `'equispaced'`. + offset: A 1D integer `tf.Tensor`. The offset of the first sample along + each axis. Only relevant when `mask_type` is `'equispaced'`. Can also + have the value `'random'`, in which case the offset is selected randomly. + Defaults to 0. + rng: A `tf.random.Generator`. The random number generator to use. If not + provided, the global random number generator will be used. + name: A `str`. A name for this op. + + Returns: + A boolean `tf.Tensor` containing the sampling mask. + + Raises: + ValueError: If `mask_type` is not one of `'equispaced'` or `'random'`. + """ + with tf.name_scope(name or 'biphasic_mask'): + shape = tf.convert_to_tensor(shape, dtype=tf.int32) + acceleration = tf.convert_to_tensor(acceleration) + rank = tf.size(shape) + + # If no RNG was passed, use the global RNG. + with tf.init_scope(): + rng = rng or tf.random.get_global_generator().split(1)[0] + + # Allow scalar ints as offset. + if isinstance(offset, int): + offset = tf.ones([rank], dtype=tf.int32) * offset + elif offset == 'random': + offset = tf.map_fn(lambda maxval: rng.uniform([], minval=0, maxval=maxval, + dtype=tf.int32), + acceleration, dtype=tf.int32) + else: + offset = tf.convert_to_tensor(offset, dtype=tf.int32) + + def fn(accum, elems): + axis, mask = accum + size, accel, off = elems + + if mask_type == 'equispaced': + mask_1d = tf.tile(tf.scatter_nd([[off]], [True], [accel]), + multiples=[(size + accel - 1) // accel])[:size] + + elif mask_type == 'random': + density = 1.0 / tf.cast(accel, tf.float32) + mask_1d = rng.uniform(shape=[size], dtype=tf.float32) < density + + else: + raise ValueError(f"Unknown mask type: {mask_type}") + + bcast_shape = tf.tensor_scatter_nd_update( + tf.ones([rank], dtype=tf.int32), [[axis]], [size]) + mask_1d = tf.reshape(mask_1d, bcast_shape) + mask &= mask_1d + return axis + 1, mask + + _, mask = tf.foldl(fn, (shape, acceleration, offset), + initializer=(0, tf.ones(shape, dtype=tf.bool))) + + return tf.math.logical_or(mask, central_mask(shape, central_size)) + + @api_util.export("sampling.radial_trajectory") def radial_trajectory(base_resolution, views=1, diff --git a/tensorflow_mri/python/ops/traj_ops_test.py b/tensorflow_mri/python/ops/traj_ops_test.py index be595d76..12794c6b 100755 --- a/tensorflow_mri/python/ops/traj_ops_test.py +++ b/tensorflow_mri/python/ops/traj_ops_test.py @@ -102,6 +102,89 @@ def test_frequency_grid_2d(self): self.assertAllClose(expected, result) +class CentralMaskTest(test_util.TestCase): + def test_central_mask(self): + result = traj_ops.central_mask([8], [4]) + expected = [0, 0, 1, 1, 1, 1, 0, 0] + self.assertAllClose(expected, result) + + result = traj_ops.central_mask([9], [5]) + expected = [0, 0, 1, 1, 1, 1, 1, 0, 0] + self.assertAllClose(expected, result) + + result = traj_ops.central_mask([8], [0.5]) + expected = [0, 0, 1, 1, 1, 1, 0, 0] + self.assertAllClose(expected, result) + + result = traj_ops.central_mask([9], [0.5]) + expected = [0, 0, 1, 1, 1, 1, 1, 0, 0] + self.assertAllClose(expected, result) + + result = traj_ops.central_mask([8], [5]) + expected = [0, 0, 1, 1, 1, 1, 0, 0] + self.assertAllClose(expected, result) + + result = traj_ops.central_mask([4, 8], [2, 4]) + expected = [[0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 1, 1, 1, 1, 0, 0], + [0, 0, 1, 1, 1, 1, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0]] + self.assertAllClose(expected, result) + + +class BiphasicMaskTest(test_util.TestCase): + def test_biphasic_mask(self): + result = traj_ops.biphasic_mask([16], [4], [0]) + expected = [1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0] + self.assertAllClose(expected, result) + + result = traj_ops.biphasic_mask([16], [4], [4]) + expected = [1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0] + self.assertAllClose(expected, result) + + result = traj_ops.biphasic_mask([16], [2], [6]) + expected = [1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0] + self.assertAllClose(expected, result) + + result = traj_ops.biphasic_mask([16], [2], [6]) + expected = [1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0] + self.assertAllClose(expected, result) + + result = traj_ops.biphasic_mask([16], [4], [0], offset=1) + expected = [0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0] + self.assertAllClose(expected, result) + + result = traj_ops.biphasic_mask([4, 8], [2, 2], [0, 0]) + expected = [[1, 0, 1, 0, 1, 0, 1, 0], + [0, 0, 0, 0, 0, 0, 0, 0], + [1, 0, 1, 0, 1, 0, 1, 0], + [0, 0, 0, 0, 0, 0, 0, 0]] + self.assertAllClose(expected, result) + + result = traj_ops.biphasic_mask([4, 8], [2, 2], [0, 0], offset=[1, 0]) + expected = [[0, 0, 0, 0, 0, 0, 0, 0], + [1, 0, 1, 0, 1, 0, 1, 0], + [0, 0, 0, 0, 0, 0, 0, 0], + [1, 0, 1, 0, 1, 0, 1, 0]] + self.assertAllClose(expected, result) + + result = traj_ops.biphasic_mask([4, 8], [2, 3], [0, 0], offset=[1, 0]) + expected = [[0, 0, 0, 0, 0, 0, 0, 0], + [1, 0, 0, 1, 0, 0, 1, 0], + [0, 0, 0, 0, 0, 0, 0, 0], + [1, 0, 0, 1, 0, 0, 1, 0]] + self.assertAllClose(expected, result) + + result = traj_ops.biphasic_mask([4, 8], [2, 2], [2, 2]) + expected = [[1, 0, 1, 0, 1, 0, 1, 0], + [0, 0, 0, 1, 1, 0, 0, 0], + [1, 0, 1, 1, 1, 0, 1, 0], + [0, 0, 0, 0, 0, 0, 0, 0]] + self.assertAllClose(expected, result) + + result = traj_ops.biphasic_mask([16], [4], [0], mask_type='random') + + class RadialTrajectoryTest(test_util.TestCase): """Radial trajectory tests.""" @classmethod From 3ba2b14210c0f650842257c67449d1735d8d5f62 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Mon, 22 Aug 2022 15:41:00 +0000 Subject: [PATCH 035/101] Working on variational network --- tensorflow_mri/_api/layers/__init__.py | 2 +- tensorflow_mri/_api/models/__init__.py | 2 + tensorflow_mri/_api/sampling/__init__.py | 2 + .../python/callbacks/tensorboard_callbacks.py | 41 +++++---- .../python/coils/coil_compression.py | 8 +- .../python/coils/coil_sensitivities.py | 13 +-- .../python/coils/coil_sensitivities_test.py | 3 +- .../python/layers/coil_compression.py | 6 +- .../python/layers/coil_sensitivities.py | 6 +- .../python/layers/data_consistency.py | 10 ++- .../python/layers/kspace_scaling.py | 13 +-- .../python/layers/linear_operator_layer.py | 21 ++++- tensorflow_mri/python/layers/recon_adjoint.py | 10 ++- tensorflow_mri/python/models/__init__.py | 2 + .../python/models/graph_like_model.py | 28 +++++++ .../python/models/variational_network.py | 83 ++++++++++++------- tensorflow_mri/python/ops/traj_ops.py | 8 +- tensorflow_mri/python/ops/traj_ops_test.py | 7 ++ tensorflow_mri/python/util/model_util.py | 12 --- 19 files changed, 179 insertions(+), 98 deletions(-) create mode 100644 tensorflow_mri/python/models/graph_like_model.py diff --git a/tensorflow_mri/_api/layers/__init__.py b/tensorflow_mri/_api/layers/__init__.py index d9815ca0..e83235de 100644 --- a/tensorflow_mri/_api/layers/__init__.py +++ b/tensorflow_mri/_api/layers/__init__.py @@ -8,11 +8,11 @@ from tensorflow_mri.python.layers.convolutional import Conv2D as Convolution2D from tensorflow_mri.python.layers.convolutional import Conv3D as Conv3D from tensorflow_mri.python.layers.convolutional import Conv3D as Convolution3D +from tensorflow_mri.python.layers.data_consistency import LeastSquaresGradientDescent as LeastSquaresGradientDescent from tensorflow_mri.python.layers.coil_sensitivities import CoilSensitivityEstimation2D as CoilSensitivityEstimation2D from tensorflow_mri.python.layers.coil_sensitivities import CoilSensitivityEstimation3D as CoilSensitivityEstimation3D from tensorflow_mri.python.layers.conv_blocks import ConvBlock as ConvBlock from tensorflow_mri.python.layers.conv_endec import UNet as UNet -from tensorflow_mri.python.layers.data_consistency import LeastSquaresGradientDescent as LeastSquaresGradientDescent from tensorflow_mri.python.layers.kspace_scaling import KSpaceScaling2D as KSpaceScaling2D from tensorflow_mri.python.layers.kspace_scaling import KSpaceScaling3D as KSpaceScaling3D from tensorflow_mri.python.layers.pooling import AveragePooling1D as AveragePooling1D diff --git a/tensorflow_mri/_api/models/__init__.py b/tensorflow_mri/_api/models/__init__.py index b32ce647..ec86562f 100644 --- a/tensorflow_mri/_api/models/__init__.py +++ b/tensorflow_mri/_api/models/__init__.py @@ -8,3 +8,5 @@ from tensorflow_mri.python.models.conv_endec import UNet1D as UNet1D from tensorflow_mri.python.models.conv_endec import UNet2D as UNet2D from tensorflow_mri.python.models.conv_endec import UNet3D as UNet3D +from tensorflow_mri.python.models.variational_network import VarNet2D as VarNet2D +from tensorflow_mri.python.models.variational_network import VarNet3D as VarNet3D diff --git a/tensorflow_mri/_api/sampling/__init__.py b/tensorflow_mri/_api/sampling/__init__.py index ad827d32..4c0629a9 100644 --- a/tensorflow_mri/_api/sampling/__init__.py +++ b/tensorflow_mri/_api/sampling/__init__.py @@ -5,6 +5,8 @@ from tensorflow_mri.python.ops.traj_ops import density_grid as density_grid from tensorflow_mri.python.ops.traj_ops import frequency_grid as frequency_grid from tensorflow_mri.python.ops.traj_ops import random_sampling_mask as random_mask +from tensorflow_mri.python.ops.traj_ops import central_mask as central_mask +from tensorflow_mri.python.ops.traj_ops import biphasic_mask as biphasic_mask from tensorflow_mri.python.ops.traj_ops import radial_trajectory as radial_trajectory from tensorflow_mri.python.ops.traj_ops import spiral_trajectory as spiral_trajectory from tensorflow_mri.python.ops.traj_ops import radial_density as radial_density diff --git a/tensorflow_mri/python/callbacks/tensorboard_callbacks.py b/tensorflow_mri/python/callbacks/tensorboard_callbacks.py index 6fbafbcf..7b641957 100644 --- a/tensorflow_mri/python/callbacks/tensorboard_callbacks.py +++ b/tensorflow_mri/python/callbacks/tensorboard_callbacks.py @@ -53,7 +53,10 @@ class TensorBoardImages(tf.keras.callbacks.Callback): logs. Defaults to 1. max_images: Maximum number of images to be written at each step. Defaults to 3. - summary_name: Name for the image summaries. Defaults to `'val_images'`. + summary_name: Name for the image summaries. Defaults to `'val_images'`. Can + be a list of names if you wish to write multiple image summaries for each + example. In this case, you must also specify a list of display functions + in the `display_fn` parameter. volume_mode: Specifies how to save 3D images. Must be `None`, `'gif'` or an integer. If `None` (default), inputs are expected to be 2D images. In `'gif'` mode, each 3D volume is stored as an animated GIF. If an integer, @@ -63,7 +66,9 @@ class TensorBoardImages(tf.keras.callbacks.Callback): image to be written to TensorBoard. Overrides the default function, which concatenates selected features, labels and predictions according to `concat_axis`, `feature_keys`, `label_keys`, `prediction_keys` and - `complex_part`. + `complex_part`. Can be a list of callables if you wish to write multiple + image summaries for each example. In this case, you must also specify a + list of summary names in the `summary_name` parameter. concat_axis: An `int`. The axis along which to concatenate features/labels/predictions. Defaults to -2. feature_keys: A list of `str` or `int` specifying which features to @@ -105,6 +110,13 @@ def __init__(self, self.label_keys = label_keys self.prediction_keys = prediction_keys self.complex_part = complex_part + if not isinstance(self.summary_name, (list, tuple)): + self.summary_name = (self.summary_name,) + if not isinstance(self.display_fn, (list, tuple)): + self.display_fn = (self.display_fn,) + if len(self.summary_name) != len(self.display_fn): + raise ValueError( + "The number of summary names and display functions must be the same.") def on_epoch_end(self, epoch, logs=None): # pylint: disable=unused-argument """Called at the end of an epoch.""" @@ -122,7 +134,7 @@ def _write_image_summaries(self, step=0): image_dir = os.path.join(self.log_dir, 'image') self.file_writer = tf.summary.create_file_writer(image_dir) - images = [] + images = {k: [] for k in self.summary_name} # For each batch. for batch in self.x: @@ -140,31 +152,30 @@ def _write_image_summaries(self, step=0): y_pred = nest_util.unstack_nested_tensors(y_pred) # Create display images. - images.extend(list(map(self.display_fn, x, y, y_pred))) + for name, func in zip(self.summary_name, self.display_fn): + images[name].extend(list(map(func, x, y, y_pred))) # Check how many outputs we have processed. - if len(images) >= self.max_images: + if len(images[tuple(images.keys())[0]]) >= self.max_images: break # Stack all the images. Converting to tensor is required to avoid unexpected # casting (e.g., without it, a list of NumPy arrays of uint8 inputs returns # an int32 tensor). - images = tf.stack([tf.convert_to_tensor(image) for image in images]) + images = {k: tf.stack([tf.convert_to_tensor(image) for image in v]) + for k, v in images.items()} # Keep only selected slice, if requested. if isinstance(self.volume_mode, int): - images = images[:, self.volume_mode, ...] + images = {k: v[:, self.volume_mode, ...] for k, v in images.items()} # Write images. with self.file_writer.as_default(step=step): - if self.volume_mode == 'gif': - image_summary.gif(self.summary_name, - images, - max_outputs=self.max_images) - else: - tf.summary.image(self.summary_name, - images, - max_outputs=self.max_images) + for name, image in images.items(): + if self.volume_mode == 'gif': + image_summary.gif(name, image, max_outputs=self.max_images) + else: + tf.summary.image(name, image, max_outputs=self.max_images) # Close writer. self.file_writer.close() diff --git a/tensorflow_mri/python/coils/coil_compression.py b/tensorflow_mri/python/coils/coil_compression.py index 320b3bbe..2ee08716 100644 --- a/tensorflow_mri/python/coils/coil_compression.py +++ b/tensorflow_mri/python/coils/coil_compression.py @@ -29,8 +29,7 @@ def compress_coils_with_calibration_data( kspace, operator, calib_data=None, - calib_window='rect', - calib_region=0.1 * np.pi, + calib_window=None, method='svd', **kwargs): # For convenience. @@ -44,10 +43,7 @@ def compress_coils_with_calibration_data( trajectory=operator.trajectory, filter_fn=calib_window, filter_rank=rank, - filter_kwargs=dict( - cutoff=calib_region - ), - separable=isinstance(calib_region, (list, tuple))) + separable=True) # Reshape to single batch dimension. coil_axis = -2 if operator.is_non_cartesian else -(rank + 1) diff --git a/tensorflow_mri/python/coils/coil_sensitivities.py b/tensorflow_mri/python/coils/coil_sensitivities.py index 4f748136..bd7b887e 100644 --- a/tensorflow_mri/python/coils/coil_sensitivities.py +++ b/tensorflow_mri/python/coils/coil_sensitivities.py @@ -32,10 +32,11 @@ def estimate_sensitivities_with_calibration_data( kspace, operator, calib_data=None, - calib_window='rect', - calib_region=0.1 * np.pi, + calib_window=None, method='walsh', **kwargs): + method = 'lowpass' + # For convenience. rank = operator.rank @@ -47,14 +48,14 @@ def estimate_sensitivities_with_calibration_data( trajectory=operator.trajectory, filter_fn=calib_window, filter_rank=rank, - filter_kwargs=dict( - cutoff=calib_region - ), - separable=isinstance(calib_region, (list, tuple))) + separable=True) # Reconstruct image. calib_data = recon_adjoint.recon_adjoint(calib_data, operator) + if method == 'lowpass': + return calib_data + # ESPIRiT method takes in k-space data, so convert back to k-space in this # case. if method == 'espirit': diff --git a/tensorflow_mri/python/coils/coil_sensitivities_test.py b/tensorflow_mri/python/coils/coil_sensitivities_test.py index 0b2e3997..f33f20ca 100644 --- a/tensorflow_mri/python/coils/coil_sensitivities_test.py +++ b/tensorflow_mri/python/coils/coil_sensitivities_test.py @@ -49,8 +49,7 @@ def test_coil_sensitivities(self): image_shape=image_shape, mask=mask) sens = coil_sensitivities.coil_sensitivities(kspace, - operator, - calib_region=0.1 * np.pi) + operator) expected = [ [[0.43218857-4.6583355e-09j, 0.43218845-8.7869850e-11j, diff --git a/tensorflow_mri/python/layers/coil_compression.py b/tensorflow_mri/python/layers/coil_compression.py index 6ae3e426..19a18695 100644 --- a/tensorflow_mri/python/layers/coil_compression.py +++ b/tensorflow_mri/python/layers/coil_compression.py @@ -30,8 +30,7 @@ class CoilCompression(linear_operator_layer.LinearOperatorLayer): """ def __init__(self, rank, - calib_window='rect', - calib_region=0.1 * np.pi, + calib_window, coil_compression_method='svd', coil_compression_kwargs=None, operator=linear_operator_mri.LinearOperatorMRI, @@ -41,7 +40,6 @@ def __init__(self, super().__init__(operator=operator, input_indices=kspace_index, **kwargs) self.rank = rank self.calib_window = calib_window - self.calib_region = calib_region self.coil_compression_method = coil_compression_method self.coil_compression_kwargs = coil_compression_kwargs or {} @@ -62,7 +60,6 @@ def call(self, inputs): kspace, operator, calib_window=self.calib_window, - calib_region=self.calib_region, method=self.coil_compression_method, **self.coil_compression_kwargs) @@ -74,7 +71,6 @@ def get_config(self): """ config = { 'calib_window': self.calib_window, - 'calib_region': self.calib_region, 'coil_compression_method': self.coil_compression_method, 'coil_compression_kwargs': self.coil_compression_kwargs } diff --git a/tensorflow_mri/python/layers/coil_sensitivities.py b/tensorflow_mri/python/layers/coil_sensitivities.py index 6f053f9a..ca7f65bd 100644 --- a/tensorflow_mri/python/layers/coil_sensitivities.py +++ b/tensorflow_mri/python/layers/coil_sensitivities.py @@ -33,8 +33,7 @@ class CoilSensitivityEstimation(linear_operator_layer.LinearOperatorLayer): """ def __init__(self, rank, - calib_window='rect', - calib_region=0.1 * np.pi, + calib_window, calib_method='walsh', calib_kwargs=None, sens_network='UNet', @@ -46,7 +45,6 @@ def __init__(self, super().__init__(operator=operator, input_indices=kspace_index, **kwargs) self.rank = rank self.calib_window = calib_window - self.calib_region = calib_region self.calib_method = calib_method self.calib_kwargs = calib_kwargs or {} self.sens_network = sens_network @@ -79,7 +77,6 @@ def call(self, inputs): kspace, operator, calib_window=self.calib_window, - calib_region=self.calib_region, method=self.calib_method, **self.calib_kwargs ) @@ -98,7 +95,6 @@ def get_config(self): """ config = { 'calib_window': self.calib_window, - 'calib_region': self.calib_region, 'calib_method': self.calib_method, 'calib_kwargs': self.calib_kwargs, 'sens_network': self.sens_network, diff --git a/tensorflow_mri/python/layers/data_consistency.py b/tensorflow_mri/python/layers/data_consistency.py index b327b76e..b1d5059d 100644 --- a/tensorflow_mri/python/layers/data_consistency.py +++ b/tensorflow_mri/python/layers/data_consistency.py @@ -18,6 +18,7 @@ from tensorflow_mri.python.layers import linear_operator_layer from tensorflow_mri.python.linalg import linear_operator_mri +from tensorflow_mri.python.ops import math_ops from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import keras_util @@ -29,6 +30,7 @@ class LeastSquaresGradientDescent(linear_operator_layer.LinearOperatorLayer): def __init__(self, scale_initializer=1.0, ignore_channels=True, + reinterpret_complex=False, operator=linear_operator_mri.LinearOperatorMRI, image_index='image', kspace_index='kspace', @@ -42,6 +44,7 @@ def __init__(self, else: self.scale_initializer = tf.keras.initializers.get(scale_initializer) self.ignore_channels = ignore_channels + self.reinterpret_complex = reinterpret_complex def build(self, input_shape): super().build(input_shape) @@ -55,19 +58,24 @@ def build(self, input_shape): def call(self, inputs): (image, kspace), operator = self.parse_inputs(inputs) + if self.reinterpret_complex: + image = math_ops.view_as_complex(image, stacked=False) if self.ignore_channels: image = tf.squeeze(image, axis=-1) image -= tf.cast(self.scale, image.dtype) * operator.transform( operator.transform(image) - kspace, adjoint=True) if self.ignore_channels: image = tf.expand_dims(image, axis=-1) + if self.reinterpret_complex: + image = math_ops.view_as_real(image, stacked=False) return image def get_config(self): config = { 'scale_initializer': tf.keras.initializers.serialize( self.scale_initializer), - 'ignore_channels': self.ignore_channels + 'ignore_channels': self.ignore_channels, + 'reinterpret_complex': self.reinterpret_complex } base_config = super().get_config() image_index, kspace_index = base_config.pop('input_indices') diff --git a/tensorflow_mri/python/layers/kspace_scaling.py b/tensorflow_mri/python/layers/kspace_scaling.py index c45d7dd6..a8816ddd 100644 --- a/tensorflow_mri/python/layers/kspace_scaling.py +++ b/tensorflow_mri/python/layers/kspace_scaling.py @@ -14,7 +14,6 @@ # ============================================================================== """*k*-space scaling layer.""" -import numpy as np import tensorflow as tf from tensorflow_mri.python.layers import linear_operator_layer @@ -33,8 +32,7 @@ class KSpaceScaling(linear_operator_layer.LinearOperatorLayer): """ def __init__(self, rank, - calib_window='rect', - calib_region=0.1 * np.pi, + calib_window, operator=linear_operator_mri.LinearOperatorMRI, kspace_index=None, **kwargs): @@ -45,7 +43,6 @@ def __init__(self, **kwargs) self.rank = rank self.calib_window = calib_window - self.calib_region = calib_region def call(self, inputs): """Applies the layer. @@ -65,10 +62,7 @@ def call(self, inputs): operator.trajectory, filter_fn=self.calib_window, filter_rank=operator.rank, - filter_kwargs=dict( - cutoff=self.calib_region - ), - separable=isinstance(self.calib_region, (list, tuple))) + separable=True) image = recon_adjoint.recon_adjoint(filtered_kspace, operator) return kspace / tf.cast(tf.math.reduce_max(tf.math.abs(image)), kspace.dtype) @@ -80,8 +74,7 @@ def get_config(self): A `dict` describing the layer configuration. """ config = { - 'calib_window': self.calib_window, - 'calib_region': self.calib_region + 'calib_window': self.calib_window } base_config = super().get_config() kspace_index = base_config.pop('input_indices') diff --git a/tensorflow_mri/python/layers/linear_operator_layer.py b/tensorflow_mri/python/layers/linear_operator_layer.py index a959efa5..48fff6c5 100644 --- a/tensorflow_mri/python/layers/linear_operator_layer.py +++ b/tensorflow_mri/python/layers/linear_operator_layer.py @@ -19,11 +19,15 @@ import tensorflow as tf from tensorflow_mri.python.linalg import linear_operator +from tensorflow_mri.python.linalg import linear_operator_mri class LinearOperatorLayer(tf.keras.layers.Layer): """A layer that uses a linear operator (abstract base class).""" - def __init__(self, operator, input_indices, **kwargs): + def __init__(self, + operator=linear_operator_mri.LinearOperatorMRI, + input_indices=None, + **kwargs): super().__init__(**kwargs) if isinstance(operator, linear_operator.LinearOperator): @@ -93,3 +97,18 @@ def get_input_operator(self): else: operator = self._operator_instance return operator + + +class LinearTransform(LinearOperatorLayer): + """A layer that applies a linear transform to its inputs.""" + def __init__(self, + adjoint=False, + operator=linear_operator_mri.LinearOperatorMRI, + input_indices=None, + **kwargs): + super().__init__(operator=operator, input_indices=input_indices, **kwargs) + self.adjoint = adjoint + + def call(self, inputs): + main, operator = self.parse_inputs(inputs) + return operator.transform(main, adjoint=self.adjoint) diff --git a/tensorflow_mri/python/layers/recon_adjoint.py b/tensorflow_mri/python/layers/recon_adjoint.py index 487305ae..0937b9ce 100644 --- a/tensorflow_mri/python/layers/recon_adjoint.py +++ b/tensorflow_mri/python/layers/recon_adjoint.py @@ -20,6 +20,7 @@ from tensorflow_mri.python.layers import linear_operator_layer from tensorflow_mri.python.linalg import linear_operator_mri +from tensorflow_mri.python.ops import math_ops from tensorflow_mri.python.recon import recon_adjoint from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import doc_util @@ -52,6 +53,8 @@ If `True`, the output has shape `[*batch_shape, ${dim_names}, 1]`. If `False`, the output has shape `[*batch_shape, ${dim_names}]`. Defaults to `True`. + reinterpret_complex: A `boolean`. Whether to reinterpret a complex-valued + output image as a dual-channel real image. Defaults to `False`. operator: A subclass of `tfmri.linalg.LinearOperator` or an instance thereof. The system operator. This object may be a class or an instance. @@ -70,6 +73,7 @@ class ReconAdjoint(linear_operator_layer.LinearOperatorLayer): def __init__(self, rank, expand_channel_dim=True, + reinterpret_complex=False, operator=linear_operator_mri.LinearOperatorMRI, kspace_index=None, **kwargs): @@ -77,17 +81,21 @@ def __init__(self, super().__init__(operator=operator, input_indices=kspace_index, **kwargs) self.rank = rank self.expand_channel_dim = expand_channel_dim + self.reinterpret_complex = reinterpret_complex def call(self, inputs): kspace, operator = self.parse_inputs(inputs) image = recon_adjoint.recon_adjoint(kspace, operator) if self.expand_channel_dim: image = tf.expand_dims(image, axis=-1) + if self.reinterpret_complex: + image = math_ops.view_as_real(image, stacked=False) return image def get_config(self): config = { - 'expand_channel_dim': self.expand_channel_dim + 'expand_channel_dim': self.expand_channel_dim, + 'reinterpret_complex': self.reinterpret_complex } base_config = super().get_config() input_indices = base_config.pop('input_indices') diff --git a/tensorflow_mri/python/models/__init__.py b/tensorflow_mri/python/models/__init__.py index c5f8e166..68d6a4a4 100644 --- a/tensorflow_mri/python/models/__init__.py +++ b/tensorflow_mri/python/models/__init__.py @@ -16,3 +16,5 @@ from tensorflow_mri.python.models import conv_blocks from tensorflow_mri.python.models import conv_endec +from tensorflow_mri.python.models import graph_like_model +from tensorflow_mri.python.models import variational_network diff --git a/tensorflow_mri/python/models/graph_like_model.py b/tensorflow_mri/python/models/graph_like_model.py new file mode 100644 index 00000000..3206ba45 --- /dev/null +++ b/tensorflow_mri/python/models/graph_like_model.py @@ -0,0 +1,28 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== + +import tensorflow as tf + + +class GraphLikeModel(tf.keras.Model): + """A model with graph-like structure. + + Adds a method `functional` that returns a functional model with the same + structure as the current model. Functional models have some advantages over + subclassing as described in + https://www.tensorflow.org/guide/keras/functional#when_to_use_the_functional_api. + """ + def functional(self, inputs): + return tf.keras.Model(inputs, self.call(inputs)) diff --git a/tensorflow_mri/python/models/variational_network.py b/tensorflow_mri/python/models/variational_network.py index 1b851b21..3b23de85 100644 --- a/tensorflow_mri/python/models/variational_network.py +++ b/tensorflow_mri/python/models/variational_network.py @@ -18,32 +18,31 @@ import warnings from tensorflow_mri.python.activations import complex_activations -from tensorflow_mri.python.layers import coil_sensitivities -from tensorflow_mri.python.layers import data_consistency -from tensorflow_mri.python.layers import kspace_scaling -from tensorflow_mri.python.layers import recon_adjoint +from tensorflow_mri.python.layers import data_consistency, linear_operator_layer +from tensorflow_mri.python.models import graph_like_model +from tensorflow_mri.python.ops import coil_ops, math_ops from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import keras_util from tensorflow_mri.python.util import layer_util from tensorflow_mri.python.util import model_util -class VarNet(model_util.GraphLikeModel): +class VarNet(graph_like_model.GraphLikeModel): def __init__(self, rank, num_iterations=10, - calib_region=0.1 * np.pi, - reg_network='UNet', - reg_network_kwargs=None, + calib_window=None, + reg_network='auto', sens_network='UNet', sens_network_kwargs=None, compress_coils=True, coil_compression_kwargs=None, scale_kspace=True, estimate_sensitivities=True, - view_complex_as_real=False, + reinterpret_complex=False, + return_rss=False, return_multicoil=False, - return_zerofilled=False, + return_zfill=False, return_sensitivities=False, kspace_index=None, **kwargs): @@ -51,17 +50,17 @@ def __init__(self, super().__init__(**kwargs) self.rank = rank self.num_iterations = num_iterations - self.calib_region = calib_region + self.calib_window = calib_window self.reg_network = reg_network - self.reg_network_kwargs = reg_network_kwargs or {} self.sens_network = sens_network self.sens_network_kwargs = sens_network_kwargs or {} self.compress_coils = compress_coils self.coil_compression_kwargs = coil_compression_kwargs or {} self.scale_kspace = scale_kspace self.estimate_sensitivities = estimate_sensitivities - self.view_complex_as_real = view_complex_as_real - self.return_zerofilled = return_zerofilled + self.reinterpret_complex = reinterpret_complex + self.return_rss = return_rss + self.return_zfill = return_zfill self.return_multicoil = return_multicoil self.return_sensitivities = return_sensitivities self.kspace_index = kspace_index @@ -71,40 +70,47 @@ def __init__(self, coil_compression_kwargs.update(self.coil_compression_kwargs) self._coil_compression_layer = layer_util.get_nd_layer( 'CoilCompression', self.rank)( - calib_region=self.calib_region, + calib_window=self.calib_window, coil_compression_kwargs=coil_compression_kwargs, kspace_index=self.kspace_index) if self.scale_kspace: self._kspace_scaling_layer = layer_util.get_nd_layer( 'KSpaceScaling', self.rank)( - calib_region=self.calib_region, + calib_window=self.calib_window, kspace_index=self.kspace_index) if self.estimate_sensitivities: self._coil_sensitivities_layer = layer_util.get_nd_layer( 'CoilSensitivityEstimation', self.rank)( - calib_region=self.calib_region, + calib_window=self.calib_window, sens_network=self.sens_network, sens_network_kwargs=self.sens_network_kwargs, kspace_index=self.kspace_index) self._recon_adjoint_layer = layer_util.get_nd_layer( 'ReconAdjoint', self.rank)( + reinterpret_complex=self.reinterpret_complex, kspace_index=self.kspace_index) lsgd_layer_class = data_consistency.LeastSquaresGradientDescent - lsgd_layers_kwargs = {} - - reg_network_class = model_util.get_nd_model(self.reg_network, rank) - reg_network_kwargs = dict( - filters=[32, 64, 128], - kernel_size=3, - activation=complex_activations.complex_relu, - out_channels=2 if self.view_complex_as_real else 1, - dtype=tf.float32 if self.view_complex_as_real else tf.complex64 + lsgd_layers_kwargs = dict( + reinterpret_complex=self.reinterpret_complex ) + if reg_network == 'auto': + reg_network_class = model_util.get_nd_model('UNet', rank) + reg_network_kwargs = dict( + filters=[32, 64, 128], + kernel_size=3, + activation=('relu' if self.reinterpret_complex + else complex_activations.complex_relu), + out_channels=2 if self.reinterpret_complex else 1, + use_deconv=True, + dtype=(tf.as_dtype(self.dtype).real_dtype.name + if self.reinterpret_complex else self.dtype) + ) + self._lsgd_layers = [ lsgd_layer_class(**lsgd_layers_kwargs, name=f'lsgd_{i}') for i in range(self.num_iterations)] @@ -112,6 +118,9 @@ def __init__(self, reg_network_class(**reg_network_kwargs, name=f'reg_{i}') for i in range(self.num_iterations)] + self._forward_layer = linear_operator_layer.LinearTransform(adjoint=False) + self._adjoint_layer = linear_operator_layer.LinearTransform(adjoint=True) + def call(self, inputs): x = {k: v for k, v in inputs.items()} @@ -144,14 +153,26 @@ def call(self, inputs): image = reg(image) image = lsgd({'image': image, **x}) + if self.reinterpret_complex: + zfill = math_ops.view_as_complex(image, stacked=False) + image = math_ops.view_as_complex(image, stacked=False) + + if self.return_multicoil or self.return_rss: + multicoil = (tf.expand_dims(image, -(self.rank + 2)) * + tf.expand_dims(x['sensitivities'], -1)) + + if self.return_rss: + rss = tf.math.abs( + coil_ops.combine_coils(multicoil, coil_axis=-(self.rank + 2))) + outputs = {'image': image} - if self.return_zerofilled: - outputs['zerofilled'] = zfill + if self.return_rss: + outputs['rss'] = rss + if self.return_zfill: + outputs['zfill'] = zfill if self.return_multicoil: - outputs['multicoil'] = ( - tf.expand_dims(image, -(self.rank + 2)) * - tf.expand_dims(x['sensitivities'], -1)) + outputs['multicoil'] = multicoil if self.return_sensitivities: outputs['sensitivities'] = x['sensitivities'] diff --git a/tensorflow_mri/python/ops/traj_ops.py b/tensorflow_mri/python/ops/traj_ops.py index 553ac310..b5e31936 100755 --- a/tensorflow_mri/python/ops/traj_ops.py +++ b/tensorflow_mri/python/ops/traj_ops.py @@ -343,6 +343,10 @@ def biphasic_mask(shape, else: offset = tf.convert_to_tensor(offset, dtype=tf.int32) + # Initialize mask. + mask = tf.ones(shape, dtype=tf.bool) + static_shape = mask.shape + def fn(accum, elems): axis, mask = accum size, accel, off = elems @@ -362,10 +366,10 @@ def fn(accum, elems): tf.ones([rank], dtype=tf.int32), [[axis]], [size]) mask_1d = tf.reshape(mask_1d, bcast_shape) mask &= mask_1d - return axis + 1, mask + return axis + 1, tf.ensure_shape(mask, static_shape) _, mask = tf.foldl(fn, (shape, acceleration, offset), - initializer=(0, tf.ones(shape, dtype=tf.bool))) + initializer=(0, mask)) return tf.math.logical_or(mask, central_mask(shape, central_size)) diff --git a/tensorflow_mri/python/ops/traj_ops_test.py b/tensorflow_mri/python/ops/traj_ops_test.py index 12794c6b..fb5cdfc9 100755 --- a/tensorflow_mri/python/ops/traj_ops_test.py +++ b/tensorflow_mri/python/ops/traj_ops_test.py @@ -131,6 +131,13 @@ def test_central_mask(self): [0, 0, 0, 0, 0, 0, 0, 0]] self.assertAllClose(expected, result) + result = traj_ops.central_mask([4, 8], [1.0, 0.5]) + expected = [[0, 0, 1, 1, 1, 1, 0, 0], + [0, 0, 1, 1, 1, 1, 0, 0], + [0, 0, 1, 1, 1, 1, 0, 0], + [0, 0, 1, 1, 1, 1, 0, 0]] + self.assertAllClose(expected, result) + class BiphasicMaskTest(test_util.TestCase): def test_biphasic_mask(self): diff --git a/tensorflow_mri/python/util/model_util.py b/tensorflow_mri/python/util/model_util.py index b5f7ea7a..fa71889b 100644 --- a/tensorflow_mri/python/util/model_util.py +++ b/tensorflow_mri/python/util/model_util.py @@ -20,18 +20,6 @@ from tensorflow_mri.python.models import conv_endec -class GraphLikeModel(tf.keras.Model): - """A model with graph-like structure. - - Adds a method `functional` that returns a functional model with the same - structure as the current model. Functional models have some advantages over - subclassing as described in - https://www.tensorflow.org/guide/keras/functional#when_to_use_the_functional_api. - """ - def functional(self, inputs): - return tf.keras.Model(inputs, self.call(inputs)) - - def get_nd_model(name, rank): """Get an N-D model object. From 97169ef52ee922b12e9fe5e3c5b036035d262b9f Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Mon, 22 Aug 2022 15:42:08 +0000 Subject: [PATCH 036/101] Add compute_output_shape for UNet --- tensorflow_mri/python/models/conv_endec.py | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/tensorflow_mri/python/models/conv_endec.py b/tensorflow_mri/python/models/conv_endec.py index e5b0be1d..8d942222 100644 --- a/tensorflow_mri/python/models/conv_endec.py +++ b/tensorflow_mri/python/models/conv_endec.py @@ -14,7 +14,6 @@ # ============================================================================== """Convolutional encoder-decoder models.""" -import inspect import string import tensorflow as tf @@ -22,6 +21,7 @@ from tensorflow_mri.python.layers import concatenate from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util +from tensorflow_mri.python.util import doc_util from tensorflow_mri.python.util import model_util # pylint: disable=cyclic-import from tensorflow_mri.python.util import layer_util @@ -322,6 +322,14 @@ def call(self, inputs, training=None): # pylint: disable=missing-param-doc,unuse return x + def compute_output_shape(self, input_shape): + input_shape = tf.TensorShape(input_shape) + if self._out_channels is not None: + out_channels = self._out_channels + else: + out_channels = self._filters[0] + return input_shape[:-1].concatenate([out_channels]) + def get_config(self): """Returns model configuration for serialization.""" config = { @@ -390,12 +398,6 @@ def __init__(self, *args, **kwargs): UNet3D.__doc__ = UNET_DOC_TEMPLATE.substitute(rank=3) -# Set explicit signatures for the UNetND objects. Otherwise they will appear as -# (*args, **kwargs) in the docs. -signature = inspect.signature(UNet.__init__) -parameters = signature.parameters -parameters = [v for k, v in parameters.items() if k not in ('self', 'rank')] -signature = signature.replace(parameters=parameters) -UNet1D.__signature__ = signature -UNet2D.__signature__ = signature -UNet3D.__signature__ = signature +UNet1D.__signature__ = doc_util.get_nd_layer_signature(UNet) +UNet2D.__signature__ = doc_util.get_nd_layer_signature(UNet) +UNet3D.__signature__ = doc_util.get_nd_layer_signature(UNet) From 3a2e80f4801423439d45155c6f89244531cad810 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Mon, 22 Aug 2022 17:50:18 +0000 Subject: [PATCH 037/101] WIP VN --- .../python/layers/coil_sensitivities.py | 54 +++++++++++-------- .../python/models/variational_network.py | 6 +-- 2 files changed, 34 insertions(+), 26 deletions(-) diff --git a/tensorflow_mri/python/layers/coil_sensitivities.py b/tensorflow_mri/python/layers/coil_sensitivities.py index ca7f65bd..ae80fabd 100644 --- a/tensorflow_mri/python/layers/coil_sensitivities.py +++ b/tensorflow_mri/python/layers/coil_sensitivities.py @@ -21,6 +21,7 @@ from tensorflow_mri.python.coils import coil_sensitivities from tensorflow_mri.python.layers import linear_operator_layer from tensorflow_mri.python.linalg import linear_operator_mri +from tensorflow_mri.python.ops import math_ops from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import model_util @@ -36,8 +37,9 @@ def __init__(self, calib_window, calib_method='walsh', calib_kwargs=None, - sens_network='UNet', - sens_network_kwargs=None, + sens_network='auto', + reinterpret_complex=False, + normalize=True, operator=linear_operator_mri.LinearOperatorMRI, kspace_index=None, **kwargs): @@ -48,16 +50,25 @@ def __init__(self, self.calib_method = calib_method self.calib_kwargs = calib_kwargs or {} self.sens_network = sens_network - self.sens_network_kwargs = sens_network_kwargs or {} + self.reinterpret_complex = reinterpret_complex + self.normalize = normalize - sens_network_kwargs = _default_sens_network_kwargs(self.sens_network) - sens_network_kwargs.update(self.sens_network_kwargs) - - if self.sens_network is not None: - sens_network_class = model_util.get_nd_model(self.sens_network, rank) - sens_network_kwargs = sens_network_kwargs.copy() + if self.sens_network == 'auto': + sens_network_class = model_util.get_nd_model('UNet', rank) + sens_network_kwargs = dict( + filters=[32, 64, 128], + kernel_size=3, + activation=('relu' if self.reinterpret_complex + else complex_activations.complex_relu), + out_channels=2 if self.reinterpret_complex else 1, + use_deconv=True, + dtype=(tf.as_dtype(self.dtype).real_dtype.name + if self.reinterpret_complex else self.dtype) + ) self._sens_network_layer = tf.keras.layers.TimeDistributed( sens_network_class(**sens_network_kwargs)) + else: + self._sens_network_layer = sens_network def call(self, inputs): """Applies the layer. @@ -81,10 +92,20 @@ def call(self, inputs): **self.calib_kwargs ) ) + if self.sens_network is not None: sensitivities = tf.expand_dims(sensitivities, axis=-1) + if self.reinterpret_complex: + sensitivities = math_ops.view_as_real(sensitivities, stacked=False) sensitivities = self._sens_network_layer(sensitivities) + if self.reinterpret_complex: + sensitivities = math_ops.view_as_complex(sensitivities, stacked=False) sensitivities = tf.squeeze(sensitivities, axis=-1) + + if self.normalize: + coil_axis = -(self.rank + 1) + sensitivities = math_ops.normalize_no_nan(sensitivities, axis=coil_axis) + return sensitivities def get_config(self): @@ -98,7 +119,8 @@ def get_config(self): 'calib_method': self.calib_method, 'calib_kwargs': self.calib_kwargs, 'sens_network': self.sens_network, - 'sens_network_kwargs': self.sens_network_kwargs + 'reinterpret_complex': self.reinterpret_complex, + 'normalize': self.normalize } base_config = super().get_config() kspace_index = base_config.pop('input_indices') @@ -119,15 +141,3 @@ def __init__(self, *args, **kwargs): class CoilSensitivityEstimation3D(CoilSensitivityEstimation): def __init__(self, *args, **kwargs): super().__init__(3, *args, **kwargs) - - -def _default_sens_network_kwargs(name): - return { - 'UNet': dict( - filters=[32, 64, 128], - kernel_size=3, - activation=complex_activations.complex_relu, - out_channels=1, - dtype=tf.complex64 - ) - }.get(name, {}) diff --git a/tensorflow_mri/python/models/variational_network.py b/tensorflow_mri/python/models/variational_network.py index 3b23de85..1e023599 100644 --- a/tensorflow_mri/python/models/variational_network.py +++ b/tensorflow_mri/python/models/variational_network.py @@ -33,8 +33,7 @@ def __init__(self, num_iterations=10, calib_window=None, reg_network='auto', - sens_network='UNet', - sens_network_kwargs=None, + sens_network='auto', compress_coils=True, coil_compression_kwargs=None, scale_kspace=True, @@ -53,7 +52,6 @@ def __init__(self, self.calib_window = calib_window self.reg_network = reg_network self.sens_network = sens_network - self.sens_network_kwargs = sens_network_kwargs or {} self.compress_coils = compress_coils self.coil_compression_kwargs = coil_compression_kwargs or {} self.scale_kspace = scale_kspace @@ -85,7 +83,7 @@ def __init__(self, 'CoilSensitivityEstimation', self.rank)( calib_window=self.calib_window, sens_network=self.sens_network, - sens_network_kwargs=self.sens_network_kwargs, + reinterpret_complex=self.reinterpret_complex, kspace_index=self.kspace_index) self._recon_adjoint_layer = layer_util.get_nd_layer( From 84bc1b73f6f8338b53659780e1379856983f8ed7 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Tue, 23 Aug 2022 17:06:14 +0000 Subject: [PATCH 038/101] WIP VN --- .devcontainer/Dockerfile | 9 ++++ .../python/layers/coil_sensitivities.py | 2 +- tensorflow_mri/python/models/conv_blocks.py | 22 ++++++-- tensorflow_mri/python/models/conv_endec.py | 4 ++ .../python/models/variational_network.py | 50 +++++++++++-------- 5 files changed, 61 insertions(+), 26 deletions(-) diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile index b862470a..175bc3f9 100644 --- a/.devcontainer/Dockerfile +++ b/.devcontainer/Dockerfile @@ -15,6 +15,15 @@ RUN for PYVER in ${PYVERSIONS}; do ${PYBIN}${PYVER} -m pip install ipykernel; do COPY requirements.txt /tmp/requirements.txt RUN for PYVER in ${PYVERSIONS}; do ${PYBIN}${PYVER} -m pip install -r /tmp/requirements.txt; done +# For `tf.keras.utils.plot_model`. +RUN apt-get update && \ + apt-get install -y graphviz && \ + for PYVER in ${PYVERSIONS}; do ${PYBIN}${PYVER} -m pip install pydot; done + +# Reinstall Tensorboard. +RUN for PYVER in ${PYVERSIONS}; do ${PYBIN}${PYVER} -m pip uninstall -y tensorboard tb-nightly; done && \ + for PYVER in ${PYVERSIONS}; do ${PYBIN}${PYVER} -m pip install tensorboard; done + # Create non-root user. ARG USERNAME=vscode ARG USER_UID=1000 diff --git a/tensorflow_mri/python/layers/coil_sensitivities.py b/tensorflow_mri/python/layers/coil_sensitivities.py index ae80fabd..fadfb4f8 100644 --- a/tensorflow_mri/python/layers/coil_sensitivities.py +++ b/tensorflow_mri/python/layers/coil_sensitivities.py @@ -68,7 +68,7 @@ def __init__(self, self._sens_network_layer = tf.keras.layers.TimeDistributed( sens_network_class(**sens_network_kwargs)) else: - self._sens_network_layer = sens_network + self._sens_network_layer = tf.keras.layers.TimeDistributed(sens_network) def call(self, inputs): """Applies the layer. diff --git a/tensorflow_mri/python/models/conv_blocks.py b/tensorflow_mri/python/models/conv_blocks.py index d92aa7f8..020dc6d1 100644 --- a/tensorflow_mri/python/models/conv_blocks.py +++ b/tensorflow_mri/python/models/conv_blocks.py @@ -33,9 +33,11 @@ import string import tensorflow as tf +import tensorflow_addons as tfa from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util +from tensorflow_mri.python.util import doc_util from tensorflow_mri.python.util import layer_util @@ -109,6 +111,7 @@ def __init__(self, bias_regularizer=None, use_batch_norm=False, use_sync_bn=False, + use_instance_norm=False, bn_momentum=0.99, bn_epsilon=0.001, use_residual=False, @@ -131,6 +134,7 @@ def __init__(self, self._bias_regularizer = bias_regularizer self._use_batch_norm = use_batch_norm self._use_sync_bn = use_sync_bn + self._use_instance_norm = use_instance_norm self._bn_momentum = bn_momentum self._bn_epsilon = bn_epsilon self._use_residual = use_residual @@ -140,6 +144,9 @@ def __init__(self, dropout_type, {'standard', 'spatial'}, 'dropout_type') self._num_layers = len(self._filters) + if use_batch_norm and use_instance_norm: + raise ValueError('Cannot use both batch and instance normalization.') + conv = layer_util.get_nd_layer('Conv', self._rank) if self._use_batch_norm: @@ -179,8 +186,11 @@ def __init__(self, if self._use_batch_norm: self._norms.append( bn(axis=self._channel_axis, - momentum=self._bn_momentum, - epsilon=self._bn_epsilon)) + momentum=self._bn_momentum, + epsilon=self._bn_epsilon)) + if self._use_instance_norm: + self._norms.append(tfa.layers.InstanceNormalization( + axis=self._channel_axis)) if self._use_dropout: self._dropouts.append(dropout(rate=self._dropout_rate)) @@ -199,7 +209,7 @@ def call(self, inputs, training=None): # pylint: disable=unused-argument, missin # Convolution. x = conv(x) # Batch normalization. - if self._use_batch_norm: + if self._use_batch_norm or self._use_instance_norm: x = norm(x, training=training) # Activation. if i == self._num_layers - 1: # Last layer. @@ -230,6 +240,7 @@ def get_config(self): 'bias_regularizer': self._bias_regularizer, 'use_batch_norm': self._use_batch_norm, 'use_sync_bn': self._use_sync_bn, + 'use_instance_norm': self._use_instance_norm, 'bn_momentum': self._bn_momentum, 'bn_epsilon': self._bn_epsilon, 'use_residual': self._use_residual, @@ -265,3 +276,8 @@ def __init__(self, *args, **kwargs): ConvBlock1D.__doc__ = CONV_BLOCK_DOC_TEMPLATE.substitute(rank=1) ConvBlock2D.__doc__ = CONV_BLOCK_DOC_TEMPLATE.substitute(rank=2) ConvBlock3D.__doc__ = CONV_BLOCK_DOC_TEMPLATE.substitute(rank=3) + + +ConvBlock1D.__signature__ = doc_util.get_nd_layer_signature(ConvBlock) +ConvBlock2D.__signature__ = doc_util.get_nd_layer_signature(ConvBlock) +ConvBlock3D.__signature__ = doc_util.get_nd_layer_signature(ConvBlock) diff --git a/tensorflow_mri/python/models/conv_endec.py b/tensorflow_mri/python/models/conv_endec.py index 8d942222..7db338ed 100644 --- a/tensorflow_mri/python/models/conv_endec.py +++ b/tensorflow_mri/python/models/conv_endec.py @@ -111,6 +111,7 @@ def __init__(self, bias_regularizer=None, use_batch_norm=False, use_sync_bn=False, + use_instance_norm=False, bn_momentum=0.99, bn_epsilon=0.001, out_channels=None, @@ -139,6 +140,7 @@ def __init__(self, self._bias_regularizer = bias_regularizer self._use_batch_norm = use_batch_norm self._use_sync_bn = use_sync_bn + self._use_instance_norm = use_instance_norm self._bn_momentum = bn_momentum self._bn_epsilon = bn_epsilon self._out_channels = out_channels @@ -172,6 +174,7 @@ def __init__(self, bias_regularizer=self._bias_regularizer, use_batch_norm=self._use_batch_norm, use_sync_bn=self._use_sync_bn, + use_instance_norm=self._use_instance_norm, bn_momentum=self._bn_momentum, bn_epsilon=self._bn_epsilon, use_dropout=self._use_dropout, @@ -346,6 +349,7 @@ def get_config(self): 'bias_regularizer': self._bias_regularizer, 'use_batch_norm': self._use_batch_norm, 'use_sync_bn': self._use_sync_bn, + 'use_instance_norm': self._use_instance_norm, 'bn_momentum': self._bn_momentum, 'bn_epsilon': self._bn_epsilon, 'out_channels': self._out_channels, diff --git a/tensorflow_mri/python/models/variational_network.py b/tensorflow_mri/python/models/variational_network.py index 1e023599..a017e05d 100644 --- a/tensorflow_mri/python/models/variational_network.py +++ b/tensorflow_mri/python/models/variational_network.py @@ -30,7 +30,7 @@ class VarNet(graph_like_model.GraphLikeModel): def __init__(self, rank, - num_iterations=10, + num_iterations=12, calib_window=None, reg_network='auto', sens_network='auto', @@ -63,6 +63,30 @@ def __init__(self, self.return_sensitivities = return_sensitivities self.kspace_index = kspace_index + lsgd_layer_class = data_consistency.LeastSquaresGradientDescent + lsgd_layers_kwargs = dict( + reinterpret_complex=self.reinterpret_complex + ) + + if self.reg_network == 'auto': + reg_network_class = model_util.get_nd_model('UNet', rank) + reg_network_kwargs = dict( + filters=[32, 64, 128], + kernel_size=3, + activation=(tf.keras.layers.LeakyReLU(alpha=0.2) + if self.reinterpret_complex + else complex_activations.complex_relu), + out_channels=2 if self.reinterpret_complex else 1, + kernel_initializer='he_uniform', + use_deconv=True, + use_instance_norm=True, + dtype=(tf.as_dtype(self.dtype).real_dtype.name + if self.reinterpret_complex else self.dtype) + ) + + if self.sens_network == 'auto': + sens_network = reg_network_class(**reg_network_kwargs) + if self.compress_coils: coil_compression_kwargs = _get_default_coil_compression_kwargs() coil_compression_kwargs.update(self.coil_compression_kwargs) @@ -82,7 +106,7 @@ def __init__(self, self._coil_sensitivities_layer = layer_util.get_nd_layer( 'CoilSensitivityEstimation', self.rank)( calib_window=self.calib_window, - sens_network=self.sens_network, + sens_network=sens_network, reinterpret_complex=self.reinterpret_complex, kspace_index=self.kspace_index) @@ -91,24 +115,6 @@ def __init__(self, reinterpret_complex=self.reinterpret_complex, kspace_index=self.kspace_index) - lsgd_layer_class = data_consistency.LeastSquaresGradientDescent - lsgd_layers_kwargs = dict( - reinterpret_complex=self.reinterpret_complex - ) - - if reg_network == 'auto': - reg_network_class = model_util.get_nd_model('UNet', rank) - reg_network_kwargs = dict( - filters=[32, 64, 128], - kernel_size=3, - activation=('relu' if self.reinterpret_complex - else complex_activations.complex_relu), - out_channels=2 if self.reinterpret_complex else 1, - use_deconv=True, - dtype=(tf.as_dtype(self.dtype).real_dtype.name - if self.reinterpret_complex else self.dtype) - ) - self._lsgd_layers = [ lsgd_layer_class(**lsgd_layers_kwargs, name=f'lsgd_{i}') for i in range(self.num_iterations)] @@ -116,8 +122,8 @@ def __init__(self, reg_network_class(**reg_network_kwargs, name=f'reg_{i}') for i in range(self.num_iterations)] - self._forward_layer = linear_operator_layer.LinearTransform(adjoint=False) - self._adjoint_layer = linear_operator_layer.LinearTransform(adjoint=True) + # self._forward_layer = linear_operator_layer.LinearTransform(adjoint=False) + # self._adjoint_layer = linear_operator_layer.LinearTransform(adjoint=True) def call(self, inputs): x = {k: v for k, v in inputs.items()} From 6c60dc2a525a6d7f156adcdc7787a1fc95fc8550 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 24 Aug 2022 18:56:40 +0000 Subject: [PATCH 039/101] Move docs to markdown --- .github/workflows/build-package.yml | 10 +- .gitignore | 2 +- README.rst => README.md | 110 ++- RELEASE.md | 20 + RELEASE.rst | 26 - setup.py | 8 +- tools/docs/api_docs.md | 3 + tools/docs/api_docs.rst | 2 - tools/docs/conf.py | 72 +- tools/docs/create_documents.py | 152 ++-- tools/docs/create_templates.py | 32 +- .../docs/extensions/myst_autodoc/__init__.py | 415 +++++++++++ .../extensions/myst_autosummary/__init__.py | 203 ++++++ .../extensions/myst_autosummary/generate.py | 660 ++++++++++++++++++ tools/docs/guide.md | 1 + tools/docs/guide.rst | 2 - tools/docs/guide/{faq.rst => faq.md} | 9 +- tools/docs/guide/install.md | 81 +++ tools/docs/guide/install.rst | 89 --- tools/docs/templates/index.md | 43 ++ tools/docs/templates/index.rst | 46 -- tools/docs/{tutorials.rst => tutorials.md} | 3 +- tools/docs/tutorials/recon.md | 8 + tools/docs/tutorials/recon.rst | 7 - tools/docs/tutorials/recon/cg_sense.ipynb | 10 - 25 files changed, 1606 insertions(+), 408 deletions(-) rename README.rst => README.md (68%) create mode 100644 RELEASE.md delete mode 100644 RELEASE.rst create mode 100644 tools/docs/api_docs.md delete mode 100644 tools/docs/api_docs.rst create mode 100644 tools/docs/extensions/myst_autodoc/__init__.py create mode 100644 tools/docs/extensions/myst_autosummary/__init__.py create mode 100644 tools/docs/extensions/myst_autosummary/generate.py create mode 100644 tools/docs/guide.md delete mode 100644 tools/docs/guide.rst rename tools/docs/guide/{faq.rst => faq.md} (73%) create mode 100644 tools/docs/guide/install.md delete mode 100644 tools/docs/guide/install.rst create mode 100644 tools/docs/templates/index.md delete mode 100644 tools/docs/templates/index.rst rename tools/docs/{tutorials.rst => tutorials.md} (87%) create mode 100644 tools/docs/tutorials/recon.md delete mode 100644 tools/docs/tutorials/recon.rst diff --git a/.github/workflows/build-package.yml b/.github/workflows/build-package.yml index 86e9b9a8..29c645ed 100644 --- a/.github/workflows/build-package.yml +++ b/.github/workflows/build-package.yml @@ -16,7 +16,7 @@ jobs: name: Build package runs-on: ubuntu-latest - + container: image: ghcr.io/mrphys/tensorflow-manylinux:1.12.0 @@ -56,7 +56,7 @@ jobs: - name: Build docs run: | make docs PY_VERSION=${{ matrix.py_version }} - + - name: Upload wheel if: startsWith(github.ref, 'refs/tags') uses: actions/upload-artifact@v2 @@ -81,12 +81,12 @@ jobs: release: - + name: Release needs: build runs-on: ubuntu-latest if: startsWith(github.ref, 'refs/tags') - + steps: - name: Checkout docs branch @@ -122,7 +122,7 @@ jobs: uses: softprops/action-gh-release@v1 with: name: TensorFlow MRI ${{ env.release }} - body_path: RELEASE.rst + body_path: RELEASE.md prerelease: ${{ contains(env.release, 'a') || contains(env.release, 'b') || contains(env.release, 'rc') }} fail_on_unmatched_files: true diff --git a/.gitignore b/.gitignore index 07840dd5..8c626152 100644 --- a/.gitignore +++ b/.gitignore @@ -10,4 +10,4 @@ third_party/spiral_waveform tools/docs/_build tools/docs/_templates tools/docs/api_docs -tools/docs/index.rst +tools/docs/index.md diff --git a/README.rst b/README.md similarity index 68% rename from README.rst rename to README.md index 18af1d93..78678bb1 100644 --- a/README.rst +++ b/README.md @@ -5,10 +5,7 @@ | -|pypi| |build| |docs| |doi| - -.. |pypi| image:: https://badge.fury.io/py/tensorflow-mri.svg - :target: https://badge.fury.io/py/tensorflow-mri +[![PyPI](https://badge.fury.io/py/tensorflow-mri) .. |build| image:: https://github.com/mrphys/tensorflow-mri/actions/workflows/build-package.yml/badge.svg :target: https://github.com/mrphys/tensorflow-mri/actions/workflows/build-package.yml .. |docs| image:: https://img.shields.io/badge/api-reference-blue.svg @@ -16,19 +13,19 @@ .. |doi| image:: https://zenodo.org/badge/388094708.svg :target: https://zenodo.org/badge/latestdoi/388094708 -.. start-intro +% start-intro TensorFlow MRI is a library of TensorFlow operators for computational MRI. The library has a Python interface and is mostly written in Python. However, computations are efficiently performed by the TensorFlow backend (implemented in C++/CUDA), which brings together the ease of use and fast prototyping of Python -with the speed and efficiency of optimized lower-level implementations. +with the speed and efficiency of optimized lower-level implementations. Being an extension of TensorFlow, TensorFlow MRI integrates seamlessly in ML applications. No additional interfacing is needed to include a SENSE operator within a neural network, or to use a trained prior as part of an iterative reconstruction. Therefore, the gap between ML and non-ML components of image -processing pipelines is eliminated. +processing pipelines is eliminated. Whether an application involves ML or not, TensorFlow MRI operators can take full advantage of the TensorFlow framework, with capabilities including @@ -36,81 +33,80 @@ automatic differentiation, multi-device support (CPUs and GPUs), automatic device placement and copying of tensor data, and conversion to fast, serializable graphs. -TensorFlow MRI contains operators for: +TensorFlow MRI contains operators for: -* Multicoil arrays - (`tfmri.coils `_): +- Multicoil arrays + ([`tfmri.coils`](https://mrphys.github.io/tensorflow-mri/api_docs/tfmri/coils)): coil combination, coil compression and estimation of coil sensitivity maps. -* Convex optimization - (`tfmri.convex `_): +- Convex optimization + ([`tfmri.convex`](https://mrphys.github.io/tensorflow-mri/api_docs/tfmri/convex)): convex functions (quadratic, L1, L2, Tikhonov, total variation, etc.) and optimizers (ADMM). -* Keras initializers - (`tfmri.initializers `_): +- Keras initializers + ([`tfmri.initializers`](https://mrphys.github.io/tensorflow-mri/api_docs/tfmri/initializers)): neural network initializers, including support for complex-valued weights. -* I/O (`tfmri.io `_): +- I/O (`tfmri.io`](https://mrphys.github.io/tensorflow-mri/api_docs/tfmri/io)): additional I/O functions potentially useful when working with MRI data. -* Keras layers - (`tfmri.layers `_): +- Keras layers + ([`tfmri.layers`](https://mrphys.github.io/tensorflow-mri/api_docs/tfmri/layers)): layers and building blocks for neural networks, including support for complex-valued weights, inputs and outputs. -* Linear algebra - (`tfmri.linalg `_): +- Linear algebra + ([`tfmri.linalg`](https://mrphys.github.io/tensorflow-mri/api_docs/tfmri/linalg)): linear operators specialized for image processing and MRI. -* Loss functions - (`tfmri.losses `_): +- Loss functions + ([`tfmri.losses`](https://mrphys.github.io/tensorflow-mri/api_docs/tfmri/losses)): for classification, segmentation and image restoration. -* Metrics - (`tfmri.metrics `_): +- Metrics + ([`tfmri.metrics`](https://mrphys.github.io/tensorflow-mri/api_docs/tfmri/metrics)): for classification, segmentation and image restoration. -* Image processing - (`tfmri.image `_): +- Image processing + ([`tfmri.image`](https://mrphys.github.io/tensorflow-mri/api_docs/tfmri/image)): filtering, gradients, phantoms, image quality assessment, etc. -* Image reconstruction - (`tfmri.recon `_): +- Image reconstruction + ([`tfmri.recon`](https://mrphys.github.io/tensorflow-mri/api_docs/tfmri/recon)): Cartesian/non-Cartesian, 2D/3D, parallel imaging, compressed sensing. -* *k*-space sampling - (`tfmri.sampling `_): +- *k*-space sampling + ([`tfmri.sampling`](https://mrphys.github.io/tensorflow-mri/api_docs/tfmri/sampling)): Cartesian masks, non-Cartesian trajectories, sampling density compensation, etc. -* Signal processing - (`tfmri.signal `_): +- Signal processing + ([`tfmri.signal`](https://mrphys.github.io/tensorflow-mri/api_docs/tfmri/signal)): N-dimensional fast Fourier transform (FFT), non-uniform FFT (NUFFT) - (see also `TensorFlow NUFFT `_), + ([see also `TensorFlow NUFFT`](https://github.com/mrphys/tensorflow-nufft)), discrete wavelet transform (DWT), *k*-space filtering, etc. -* Unconstrained optimization - (`tfmri.optimize `_): +- Unconstrained optimization + ([`tfmri.optimize`](https://mrphys.github.io/tensorflow-mri/api_docs/tfmri/optimize)): gradient descent, L-BFGS. -* And more, e.g., supporting array manipulation and math tasks. +- And more, e.g., supporting array manipulation and math tasks. -.. end-intro +% end-intro -Installation ------------- +## Installation -.. start-install +% start-install You can install TensorFlow MRI with ``pip``: -.. code-block:: console - - $ pip install tensorflow-mri +``` +pip install tensorflow-mri +``` Note that only Linux is currently supported. -TensorFlow Compatibility -^^^^^^^^^^^^^^^^^^^^^^^^ +### TensorFlow Compatibility Each TensorFlow MRI release is compiled against a specific version of TensorFlow. To ensure compatibility, it is recommended to install matching versions of TensorFlow and TensorFlow MRI according to the table below. -.. start-compatibility-table +% start-compatibility-table ====================== ======================== ============ TensorFlow MRI Version TensorFlow Compatibility Release Date ====================== ======================== ============ +v0.22.0 v2.9.x Jul 24, 2022 v0.21.0 v2.9.x Jul 24, 2022 v0.20.0 v2.9.x Jun 18, 2022 v0.19.0 v2.9.x Jun 1, 2022 @@ -133,25 +129,22 @@ v0.5.0 v2.6.x Aug 29, 2021 v0.4.0 v2.6.x Aug 18, 2021 ====================== ======================== ============ -.. end-compatibility-table +% end-compatibility-table -.. end-install +% end-install -Documentation -------------- +## Documentation -Visit the `docs `_ for guides, -tutorials and the API reference. +Visit the [docs](https://mrphys.github.io/tensorflow-mri/) for guides, +tutorials and the API reference. -Issues ------- +## Issues If you use this package and something does not work as you expected, please -`file an issue `_ +[file an issue](https://github.com/mrphys/tensorflow-mri/issues/new) describing your problem. We're here to help! -Credits -------- +## Credits If you like this software, star the repository! |stars| @@ -159,12 +152,11 @@ If you like this software, star the repository! |stars| :target: https://github.com/mrphys/tensorflow-mri/stargazers If you find this software useful in your research, you can cite TensorFlow MRI -using its `Zenodo record `_. +using its [Zenodo record](https://doi.org/10.5281/zenodo.5151590). In the above link, scroll down to the "Export" section and select your favorite export format to get an up-to-date citation. -Contributions -------------- +## Contributions Contributions of any kind are welcome! Open an issue or pull request to begin. diff --git a/RELEASE.md b/RELEASE.md new file mode 100644 index 00000000..9718ede0 --- /dev/null +++ b/RELEASE.md @@ -0,0 +1,20 @@ +# Release 0.22.0 + + + +## Breaking Changes + + + +## Major Features and Improvements + +- `tfmri.sampling`: + + - Added operator ``spiral_waveform`` to public API. + + +## Bug Fixes and Other Changes + +- `tfmri.recon`: + + - Improved error reporting for ``least_squares``. diff --git a/RELEASE.rst b/RELEASE.rst deleted file mode 100644 index 9b89b8dd..00000000 --- a/RELEASE.rst +++ /dev/null @@ -1,26 +0,0 @@ -Release 0.22.0 -============== - - - - -Breaking Changes ----------------- - - - - -Major Features and Improvements -------------------------------- - -* ``tfmri.sampling``: - - * Added operator ``spiral_waveform`` to public API. - - -Bug Fixes and Other Changes ---------------------------- - -* ``tfmri.recon``: - - * Improved error reporting for ``least_squares``. diff --git a/setup.py b/setup.py index e0f01d9a..28241a5d 100755 --- a/setup.py +++ b/setup.py @@ -26,7 +26,7 @@ with open(path.join(ROOT, "tensorflow_mri/__about__.py")) as f: exec(f.read(), ABOUT) -with open(path.join(ROOT, "README.rst"), encoding='utf-8') as f: +with open(path.join(ROOT, "README.md"), encoding='utf-8') as f: LONG_DESCRIPTION = f.read() with open(path.join(ROOT, "requirements.txt")) as f: @@ -42,7 +42,7 @@ class BinaryDistribution(Distribution): def has_ext_modules(self): return True - + def is_pure(self): return False @@ -51,7 +51,7 @@ def is_pure(self): version=ABOUT['__version__'], description=ABOUT['__summary__'], long_description=LONG_DESCRIPTION, - long_description_content_type="text/x-rst", + long_description_content_type="text/markdown", author=ABOUT['__author__'], author_email=ABOUT['__email__'], url=ABOUT['__uri__'], @@ -80,5 +80,5 @@ def is_pure(self): 'Topic :: Software Development :: Libraries :: Python Modules' ], license=ABOUT['__license__'], - keywords=['tensorflow', 'mri', 'machine learning', 'ml'] + keywords=['tensorflow', 'mri', 'machine learning', 'ml'] ) diff --git a/tools/docs/api_docs.md b/tools/docs/api_docs.md new file mode 100644 index 00000000..d832d0fa --- /dev/null +++ b/tools/docs/api_docs.md @@ -0,0 +1,3 @@ +# API documentation + +TensorFlow MRI has a Python API. This section contains the API documentation for TensorFlow MRI. diff --git a/tools/docs/api_docs.rst b/tools/docs/api_docs.rst deleted file mode 100644 index b8ec4dc3..00000000 --- a/tools/docs/api_docs.rst +++ /dev/null @@ -1,2 +0,0 @@ -TensorFlow MRI API documentation -================================ diff --git a/tools/docs/conf.py b/tools/docs/conf.py index d09d3726..bcd7c24e 100644 --- a/tools/docs/conf.py +++ b/tools/docs/conf.py @@ -37,6 +37,7 @@ # documentation root, use os.path.abspath to make it absolute, like shown here. # sys.path.insert(0, path.abspath('../..')) +sys.path.insert(0, path.abspath('extensions')) # -- Project information ----------------------------------------------------- @@ -61,12 +62,11 @@ # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ - 'sphinx.ext.autodoc', - 'sphinx.ext.napoleon', - 'sphinx.ext.autosummary', 'sphinx.ext.linkcode', 'sphinx.ext.autosectionlabel', 'myst_nb', + 'myst_autodoc', + 'myst_autosummary', 'sphinx_sitemap' ] @@ -76,7 +76,7 @@ # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This pattern also affects html_static_path and html_extra_path. -exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] +exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store', 'templates'] # Do not add full qualification to objects' signatures. add_module_names = False @@ -124,6 +124,7 @@ sitemap_url_scheme = '{link}' # For autosummary generation. +autosummary_generate = True autosummary_filename_map = conf_helper.AutosummaryFilenameMap() # -- Options for MyST ---------------------------------------------------------- @@ -134,6 +135,7 @@ "deflist", "dollarmath", "html_image", + "substitution" ] # https://myst-nb.readthedocs.io/en/latest/authoring/basics.html @@ -143,6 +145,11 @@ '.ipynb' ] +# https://myst-parser.readthedocs.io/en/latest/syntax/optional.html#substitutions-with-jinja2 +myst_substitutions = { + 'release': release +} + # Do not execute notebooks. # https://myst-nb.readthedocs.io/en/latest/computation/execute.html nb_execution_mode = "off" @@ -267,63 +274,6 @@ def linkcode_resolve(domain, info): def process_docstring(app, what, name, obj, options, lines): # pylint: disable=missing-param-doc,unused-argument """Process autodoc docstrings.""" - # Replace Note: and Warning: by RST equivalents. - rst_lines = [] - admonition_lines = None - for line in lines: - if admonition_lines is None: - # We are not in an admonition right now. Check if this line will start - # one. - if (line.strip().startswith('Warning:') or - line.strip().startswith('Note:')): - # This line starts an admonition. - label_position = line.index(':') - admonition_type = line[:label_position].strip().lower() - admonition_content = line[label_position + 1:].strip() - leading_whitespace = ' ' * (len(line) - len(line.lstrip())) - extra_indentation = ' ' - admonition_lines = [f"{leading_whitespace}.. {admonition_type}::"] - admonition_lines.append( - leading_whitespace + extra_indentation + admonition_content) - else: - # This line does not start an admonition. It's just a regular line. - # Add it to the new lines. - rst_lines.append(line) - else: - # Check if this is the end of the admonition. - if line.strip() == '': - # Line is empty, so the end of the admonition. Add admonition and - # finish. - rst_lines.extend(admonition_lines) - admonition_lines = None - else: - # This is an admonition line. Add to list of admonition lines. - admonition_lines.append(extra_indentation + line) - # If we reached the end and we are still in an admonition, add it. - if admonition_lines is not None: - rst_lines.extend(admonition_lines) - - # Replace markdown literal markers (`) by ReST literal markers (``). - myst = '\n'.join(rst_lines) - text = myst.replace('`', '``') - text = text.replace(':math:``', ':math:`') - - # Correct inline code followed by word characters. - text = CODE_LETTER_PATTERN.sub(CODE_LETTER_REPL, text) - # Add links to some common types. - for k in COMMON_TYPES_LINKS: - text = COMMON_TYPES_PATTERNS[k].sub(COMMON_TYPES_REPLACEMENTS[k], text) - # Add links to TFMRI objects. - for match in TFMRI_OBJECTS_PATTERN.finditer(text): - name = match.group('name') - url = get_doc_url(name) - pattern = rf"``{name}``" - repl = rf"`{name} <{url}>`_" - text = text.replace(pattern, repl) - - # Correct double quotes. - text = LINK_PATTERN.sub(LINK_REPL, text) - lines[:] = text.splitlines() def get_doc_url(name): diff --git a/tools/docs/create_documents.py b/tools/docs/create_documents.py index c3c53ede..01335628 100644 --- a/tools/docs/create_documents.py +++ b/tools/docs/create_documents.py @@ -34,78 +34,79 @@ os.makedirs(os.path.join(API_DOCS_PATH, 'tfmri'), exist_ok=True) # Read the index template. -with open(os.path.join(TEMPLATES_PATH, 'index.rst'), 'r') as f: +with open(os.path.join(TEMPLATES_PATH, 'index.md'), 'r') as f: INDEX_TEMPLATE = string.Template(f.read()) TFMRI_DOC_TEMPLATE = string.Template( -"""tfmri -===== - -.. automodule:: tensorflow_mri - -Modules -------- - -.. autosummary:: - :nosignatures: - - ${namespaces} - - -Classes -------- - -.. autosummary:: - :toctree: tfmri - :template: ops/class.rst - :nosignatures: - - - -Functions ---------- - -.. autosummary:: - :toctree: tfmri - :template: ops/function.rst - :nosignatures: - - broadcast_dynamic_shapes - broadcast_static_shapes - cartesian_product - central_crop - meshgrid - ravel_multi_index - resize_with_crop_or_pad - scale_by_min_max - unravel_index +"""# tfmri + +```{automodule} tensorflow_mri +``` + +## Modules + +```{autosummary} +--- +nosignatures: +--- +${namespaces} +``` + +## Classes + +```{autosummary} +--- +toctree: tfmri +nosignatures: +--- +``` + +## Functions + +```{autosummary} +--- +toctree: tfmri +nosignatures: +--- +broadcast_dynamic_shapes +broadcast_static_shapes +cartesian_product +central_crop +meshgrid +ravel_multi_index +resize_with_crop_or_pad +scale_by_min_max +unravel_index +``` """) MODULE_DOC_TEMPLATE = string.Template( -"""tfmri.${module} -======${underline} - -.. automodule:: tensorflow_mri.${module} - -Classes -------- - -.. autosummary:: - :toctree: ${module} - :template: ${module}/class.rst - :nosignatures: - - ${classes} - -Functions ---------- - -.. autosummary:: - :toctree: ${module} - :template: ${module}/function.rst - :nosignatures: - - ${functions} +"""# tfmri.${module} + +```{automodule} tensorflow_mri.${module} +``` + +## Classes + +```{autosummary} +--- +toctree: ${module} +template: ${module}/class.md +nosignatures: +--- +${classes} +``` + +## Functions + +```{autosummary} +--- +toctree: ${module} +template: ${module}/function.md +nosignatures: +--- +${functions} +``` """) @@ -128,28 +129,27 @@ class Module: # Write namespace templates. for name, module in modules.items(): - classes = '\n '.join(sorted(set(module.classes))) - functions = '\n '.join(sorted(set(module.functions))) + classes = '\n'.join(sorted(set(module.classes))) + functions = '\n'.join(sorted(set(module.functions))) - filename = os.path.join(API_DOCS_PATH, f'tfmri/{name}.rst') + filename = os.path.join(API_DOCS_PATH, f'tfmri/{name}.md') with open(filename, 'w') as f: f.write(MODULE_DOC_TEMPLATE.substitute( module=name, - underline='=' * len(name), classes=classes, functions=functions)) -# Write top-level API doc tfmri.rst. -filename = os.path.join(API_DOCS_PATH, 'tfmri.rst') +# Write top-level API doc tfmri.md. +filename = os.path.join(API_DOCS_PATH, 'tfmri.md') with open(filename, 'w') as f: namespaces = api_util.get_submodule_names() f.write(TFMRI_DOC_TEMPLATE.substitute( - namespaces='\n '.join(sorted(namespaces)))) + namespaces='\n'.join(sorted(namespaces)))) -# Write index.rst. -filename = os.path.join(DOCS_PATH, 'index.rst') +# Write index.md. +filename = os.path.join(DOCS_PATH, 'index.md') with open(filename, 'w') as f: namespaces = api_util.get_submodule_names() namespaces = ['api_docs/tfmri/' + namespace for namespace in namespaces] f.write(INDEX_TEMPLATE.substitute( - namespaces='\n '.join(sorted(namespaces)))) + namespaces='\n'.join(sorted(namespaces)))) diff --git a/tools/docs/create_templates.py b/tools/docs/create_templates.py index 55e651a5..b9ead5df 100644 --- a/tools/docs/create_templates.py +++ b/tools/docs/create_templates.py @@ -27,21 +27,27 @@ CLASS_TEMPLATE = string.Template( -"""${module}.{{ objname | escape | underline }}${underline} +"""# ${module}.{{ objname }} -.. currentmodule:: {{ module }} +```{currentmodule} {{ module }} +``` -.. auto{{ objtype }}:: {{ objname }} - :members: - :show-inheritance: +```{auto{{ objtype }}} {{ objname }} +--- +members: +show-inheritance: +--- +``` """) FUNCTION_TEMPLATE = string.Template( -"""${module}.{{ objname | escape | underline }}${underline} +"""# ${module}.{{ objname }} -.. currentmodule:: {{ module }} +```{currentmodule} {{ module }} +``` -.. auto{{ objtype }}:: {{ objname }} +```{auto{{ objtype }}} {{ objname }} +``` """) NAMESPACES = api_util.get_submodule_names() @@ -61,13 +67,11 @@ module = f'tfmri.{namespace}' # Substitute the templates for this module. - class_template = CLASS_TEMPLATE.substitute( - module=module, underline='=' * (len(module) + 1)) - function_template = FUNCTION_TEMPLATE.substitute( - module=module, underline='=' * (len(module) + 1)) + class_template = CLASS_TEMPLATE.substitute(module=module) + function_template = FUNCTION_TEMPLATE.substitute(module=module) # Write template files. - with open(os.path.join(TEMPLATE_PATH, namespace, 'class.rst'), 'w') as f: + with open(os.path.join(TEMPLATE_PATH, namespace, 'class.md'), 'w') as f: f.write(class_template) - with open(os.path.join(TEMPLATE_PATH, namespace, 'function.rst'), 'w') as f: + with open(os.path.join(TEMPLATE_PATH, namespace, 'function.md'), 'w') as f: f.write(function_template) diff --git a/tools/docs/extensions/myst_autodoc/__init__.py b/tools/docs/extensions/myst_autodoc/__init__.py new file mode 100644 index 00000000..f14e4ecd --- /dev/null +++ b/tools/docs/extensions/myst_autodoc/__init__.py @@ -0,0 +1,415 @@ +"""MyST-compatible drop-in replacement for Sphinx's Autodoc extension.""" +__version__ = '0.1.0' + +# This extension essentially overrides all content creation done by +# Autodoc so that the output is Markdown to be parsed by MyST, instead +# of the original reStructuredText parsed by Sphinx directly. It is +# therefore prone to breakage when there are upstream changes. +# +# Namely, the overridden methods are `add_line`, `add_directive_header`, +# and `generate` of Autodoc's `Documenter` class, as well as of all +# classes derived from it, implementing the various directives for +# modules, functions, etc. Code comments here only pertain to changes +# made to the original code for reST, the original comments from the +# Autodoc source were removed so as to not be a distraction. Type hints +# were also removed, but could easily be put back in. String interpolation +# was changed to f-strings. We use our own logger name, but could have +# kept using Autodoc's. Some variable names were shortened, like `source` +# instead of `sourcename`, to keep lines under 80 characters. + + +import sphinx +from sphinx.ext import autodoc +from sphinx.util import inspect +from sphinx.pycode import ModuleAnalyzer, PycodeError +from sphinx.ext.autodoc.mock import ismock +from sphinx.util.typing import get_type_hints, stringify, restify +import re + +logger = sphinx.util.logging.getLogger(__name__) + + +class Documenter(autodoc.Documenter): + """ + Mix-in to override content generation by `Documenter` class. + + All of Autodoc's documenter classes (for modules, functions, etc.) + derive from the `Documenter` base. Methods that generate reST will + have to be rewritten to output Markdown instead. They are defined + here to be mixed into the the various documenter classes. + """ + + def fence(self): + """ + Returns back-ticks fence corresponding to indentation level. + + The indentation level in the reST output corresponds to the scope + of the directive block in Markdown, which is delimited by back-ticks. + The further out the scope, the more back-ticks we have to put. This + helper function returns a string with the correct number of ticks + based on the indentation level in the original reStructuredText. + The indentation level is determined by the current indentation and + the length of indentation that would be used to nest content. + """ + unit = self.content_indent or ' ' + (scope, remainder) = divmod(len(self.indent), len(unit)) + if remainder: + raise RuntimeError(f'Indentation not a multiple of {len(unit)}.') + if scope > 1: + raise NotImplementedError('More than one nested scope in Autodoc ' + 'directive.') + backticks = '```' + '`'*(2 - scope) + return backticks + + def add_line(self, line, source, *lineno): + """Appends one line to the generated output.""" + # Add content, but without the original indentation. + self.directive.result.append(line, source, *lineno) + + def add_directive_header(self, signature): + """Adds directive header and options to the generated content.""" + domain = getattr(self, 'domain', 'py') + directive = getattr(self, 'directivetype', self.objtype) + name = self.format_name() + source = self.get_sourcename() + prefix = self.fence() + '{' + f'{domain}:{directive}' + '} ' + # This code dealing with multi-line signature was rewritten, for + # brevity, but is entirely untested. + (first, *rest) = signature.split('\n') + self.add_line(f'{prefix}{name}{first}', source) + for line in rest: + indent = ' '*len(prefix) + self.add_line(f'{indent}{name}{first}', source) + # Add field-list options, but drop the original indentation. + if self.options.noindex: + self.add_line(':noindex:', source) + if self.objpath: + self.add_line(f':module: {self.modname}', source) + + def generate(self, more_content=None, real_modname=None, + check_module=False, all_members=False): + """ + Generates the Markdown content replacing an Autodoc directive. + + We don't call the corresponding method from the parent class, + but rather rewrite it with Markdown output. This is done to + avoid parsing the generated reStructuredText, which is possible, + but might be error-prone. + """ + + # Until noted otherwise, code is the same as in the parent class. + # See source code comments there for clarification. + + if not self.parse_name(): + # Have parent class log the corresponding warning. + super().generate(more_content, real_modname, check_module, + all_members) + return + + if not self.import_object(): + return + + guess_modname = self.get_real_modname() + self.real_modname: str = real_modname or guess_modname + + try: + self.analyzer = ModuleAnalyzer.for_module(self.real_modname) + self.analyzer.find_attr_docs() + except PycodeError as exc: + logger.debug(f'[myst-docstring] module analyzer failed: {exc}') + self.analyzer = None + if hasattr(self.module, '__file__') and self.module.__file__: + self.directive.record_dependencies.add(self.module.__file__) + else: + self.directive.record_dependencies.add(self.analyzer.srcname) + + if self.real_modname != guess_modname: + try: + analyzer = ModuleAnalyzer.for_module(guess_modname) + self.directive.record_dependencies.add(analyzer.srcname) + except PycodeError: + pass + + docstrings = sum(self.get_doc() or [], []) + if ismock(self.object) and not docstrings: + logger.warning( + sphinx.locale.__(f'A mocked object is detected: {self.name}'), + type='myst-docstring') + if check_module: + if not self.check_module(): + return + + source = self.get_sourcename() + self.add_line('', source) + try: + signature = self.format_signature() + except Exception as exc: + logger.warning( + sphinx.locale.__('Error while formatting signature for ' + f'{self.fullname}: {exc}'), + type='myst-docstring') + return + + # From here on, we make changes to accommodate the Markdown syntax. + + # Generate the directive header and options. + self.add_directive_header(signature) + self.add_line('', source) + + # Some directives don't have body content, namely modules. Then + # there is nothing to indent in reST and the `content_indent` + # attribute of the corresponding Autodoc class will be an empty + # string. In Markdown, we have to close these directives right + # after the signature. The actual content, think members of a + # module, still follows, but is not syntactically part of the + # directive block. + fence = self.fence() + if not self.content_indent: + self.add_line(fence, source) + + # Document this object and its members. + save_indent = self.indent + self.indent += self.content_indent + self.add_content(more_content) + self.document_members(all_members) + self.indent = save_indent + + # Close directive block, unless closed previously. + if self.content_indent: + self.add_line(fence, source) + + +def mystify(cls): + """Convert Python class to a MyST reference.""" + # This helper function is entirely untested. + return re.sub(r':py:(\w+?):`(.+?)`', r'{py:\1}`\2`', restify(cls)) + + +# Mix the modified Documenter class back in with each directive defined +# by Autodoc, so that they all use the methods overridden above. Unless +# these classes override the same methods themselves, in which case we +# have to redefine them as well, since super() would otherwise resolve +# them incorrectly. (It may be possible to override the method resolution +# order by means of a meta class, but that's a lot of black magic.) + +class ModuleDocumenter(Documenter, autodoc.ModuleDocumenter): + + def add_directive_header(self, signature): + # Add field-list options, but drop the original indentation. + super().add_directive_header(signature) + source = self.get_sourcename() + if self.options.synopsis: + self.add_line(f':synopsis: {self.options.synopsis}', source) + if self.options.platform: + self.add_line(f':platform: {self.options.platform}', source) + if self.options.deprecated: + self.add_line(':deprecated:', source) + + +class FunctionDocumenter(Documenter, autodoc.FunctionDocumenter): + + def add_directive_header(self, signature): + # Add field-list options, but drop the original indentation. + source = self.get_sourcename() + super().add_directive_header(signature) + if (inspect.iscoroutinefunction(self.object) + or inspect.isasyncgenfunction(self.object)): + self.add_line(':async:', source) + + +class DecoratorDocumenter(Documenter, autodoc.DecoratorDocumenter): + pass + + +class ClassDocumenter(Documenter, autodoc.ClassDocumenter): + + def add_directive_header(self, signature): + # Add field-list options, but drop the original indentation. + source = self.get_sourcename() + if self.doc_as_attr: + self.directivetype = 'attribute' + super().add_directive_header(signature) + if self.analyzer and '.'.join(self.objpath) in self.analyzer.finals: + self.add_line(':final:', source) + canonical_fullname = self.get_canonical_fullname() + if (not self.doc_as_attr + and canonical_fullname + and self.fullname != canonical_fullname): + self.add_line(f':canonical: {canonical_fullname}', source) + if not self.doc_as_attr and self.options.show_inheritance: + if inspect.getorigbases(self.object): + bases = list(self.object.__orig_bases__) + elif (hasattr(self.object, '__bases__') + and len(self.object.__bases__)): + bases = list(self.object.__bases__) + else: + bases = [] + self.env.events.emit('autodoc-process-bases', self.fullname, + self.object, self.options, bases) + # Replaced `restify` with `mystify`. + base_classes = [mystify(cls) for cls in bases] + source = self.get_sourcename() + self.add_line('', source) + self.add_line( + sphinx.locale._(f'Bases: {", ".join(base_classes)}'), + source) + + def generate(self, more_content=None, real_modname=None, + check_module=False, all_members=False): + # Unchanged. See original source-code comment for clarification. + return super().generate(more_content=more_content, + check_module=check_module, + all_members=all_members) + + +class MethodDocumenter(Documenter, autodoc.MethodDocumenter): + + def add_directive_header(self, signature): + # Add field-list options, but drop the original indentation. + super().add_directive_header(signature) + source = self.get_sourcename() + obj = self.parent.__dict__.get(self.object_name, self.object) + if inspect.isabstractmethod(obj): + self.add_line(':abstractmethod:', source) + if inspect.iscoroutinefunction(obj) or inspect.isasyncgenfunction(obj): + self.add_line(':async:', source) + if inspect.isclassmethod(obj): + self.add_line(':classmethod:', source) + if inspect.isstaticmethod(obj, cls=self.parent, name=self.object_name): + self.add_line(':staticmethod:', source) + if self.analyzer and '.'.join(self.objpath) in self.analyzer.finals: + self.add_line(':final:', source) + + +class AttributeDocumenter(Documenter, autodoc.AttributeDocumenter): + + def add_directive_header(self, signature): + # Add field-list options, but drop the original indentation. + super().add_directive_header(signature) + source = self.get_sourcename() + if (self.options.annotation is autodoc.SUPPRESS + or self.should_suppress_directive_header()): + pass + elif self.options.annotation: + self.add_line(f':annotation: {self.options.annotation}', source) + else: + if self.config.autodoc_typehints != 'none': + annotations = get_type_hints(self.parent, None, + self.config.autodoc_type_aliases) + if self.objpath[-1] in annotations: + objrepr = stringify(annotations.get(self.objpath[-1])) + self.add_line(f':type: {objrepr}', source) + try: + if (self.options.no_value + or self.should_suppress_value_header() + or ismock(self.object)): + pass + else: + objrepr = inspect.object_description(self.object) + self.add_line(f':value: {objrepr}', source) + except ValueError: + pass + + +class NewTypeAttributeDocumenter(Documenter, + autodoc.NewTypeAttributeDocumenter): + pass + + +class PropertyDocumenter(Documenter, autodoc.PropertyDocumenter): + + def add_directive_header(self, signature): + # Add field-list options, but drop the original indentation. + super().add_directive_header(signature) + source = self.get_sourcename() + if inspect.isabstractmethod(self.object): + self.add_line(':abstractmethod:', source) + if self.isclassmethod: + self.add_line(':classmethod:', source) + if inspect.safe_getattr(self.object, 'fget', None): + func = self.object.fget + elif inspect.safe_getattr(self.object, 'func', None): + func = self.object.func + else: + func = None + if func and self.config.autodoc_typehints != 'none': + try: + signature = inspect.signature(func, + type_aliases=self.config.autodoc_type_aliases) + if signature.return_annotation is not inspect.Parameter.empty: + objrepr = stringify(signature.return_annotation) + self.add_line(f':type: {objrepr}', source) + except TypeError as exc: + logger.warning( + sphinx.locale.__('Failed to get a function signature for ' + f'{self.fullname}:{exc}'), + type='myst-docstring') + return None + except ValueError: + return None + + +class ExceptionDocumenter(Documenter, autodoc.ExceptionDocumenter): + pass + + +class DataDocumenter(Documenter, autodoc.DataDocumenter): + + def add_directive_header(self, signature): + # Add field-list options, but drop the original indentation. + super().add_directive_header(signature) + source = self.get_sourcename() + if (self.options.annotation is autodoc.SUPPRESS + or self.should_suppress_directive_header()): + pass + elif self.options.annotation: + self.add_line(f':annotation: {self.options.annotation}', source) + else: + if self.config.autodoc_typehints != 'none': + annotations = get_type_hints(self.parent, None, + self.config.autodoc_type_aliases) + if self.objpath[-1] in annotations: + objrepr = stringify(annotations.get(self.objpath[-1])) + self.add_line(f':type: {objrepr}', source) + try: + if (self.options.no_value + or self.should_suppress_value_header() + or ismock(self.object)): + pass + else: + objrepr = inspect.object_description(self.object) + # Added quotation marks to avoid errors with values + # that happen to contain curly braces. This does not + # seem to be necessary in reST, but apparently is + # in Markdown. + self.add_line(f':value: "{objrepr}"', source) + except ValueError: + pass + + +class NewTypeDataDocumenter(Documenter, autodoc.NewTypeDataDocumenter): + pass + + +def setup(app): + """ + Sets up the extension. + + Sphinx calls this function if the user named the extension in `conf.py`. + It then sets up the Autodoc extension that ships with Sphinx and + overrides whatever necessary to produce Markdown to be parsed by MyST + instead of reStructuredText parsed by Sphinx/Docutils. + """ + app.setup_extension('sphinx.ext.autodoc') + app.add_autodocumenter(ModuleDocumenter, override=True) + app.add_autodocumenter(FunctionDocumenter, override=True) + app.add_autodocumenter(DecoratorDocumenter, override=True) + app.add_autodocumenter(ClassDocumenter, override=True) + app.add_autodocumenter(MethodDocumenter, override=True) + app.add_autodocumenter(AttributeDocumenter, override=True) + app.add_autodocumenter(NewTypeAttributeDocumenter, override=True) + app.add_autodocumenter(PropertyDocumenter, override=True) + app.add_autodocumenter(ExceptionDocumenter, override=True) + app.add_autodocumenter(DataDocumenter, override=True) + app.add_autodocumenter(NewTypeDataDocumenter, override=True) + return {'version': __version__, 'parallel_read_safe': True} diff --git a/tools/docs/extensions/myst_autosummary/__init__.py b/tools/docs/extensions/myst_autosummary/__init__.py new file mode 100644 index 00000000..4826ea93 --- /dev/null +++ b/tools/docs/extensions/myst_autosummary/__init__.py @@ -0,0 +1,203 @@ +"""MyST-compatible drop-in replacement for Sphinx's Autosummary extension.""" +__version__ = '0.1.0' + +# This extension only overrides the Autosummary method that creates the +# summary table. The changes relative to the original code are minimal. +# Though it is possible some reST-specific content generation was +# overlooked elsewhere in Autosummary's code base. The stub generation +# was ignored. We would have to create .md files instead of .rst. + +import os +import posixpath +import re + +import docutils +from docutils import nodes + +import sphinx +from sphinx import addnodes +from sphinx.ext.autodoc.directive import DocumenterBridge, Options +from sphinx.ext import autosummary +from sphinx.ext.autodoc.mock import mock +from sphinx.locale import __ +from sphinx.util.matching import Matcher + +logger = sphinx.util.logging.getLogger(__name__) + + +class autosummary_toc(nodes.comment): + pass + + +class Autosummary(autosummary.Autosummary): + """Extends the `autosummary` directive provided by Autosummary.""" + + def run(self): + """Reimplements the run method of the parent class. + + Only one line has been changed with respect to the parent class, + indicated below. + """ + self.bridge = DocumenterBridge(self.env, self.state.document.reporter, + Options(), self.lineno, self.state) + + names = [x.strip().split()[0] for x in self.content + if x.strip() and re.search(r'^[~a-zA-Z_]', x.strip()[0])] + items = self.get_items(names) + nodes = self.get_table(items) + + if 'toctree' in self.options: + dirname = posixpath.dirname(self.env.docname) + + tree_prefix = self.options['toctree'].strip() + docnames = [] + excluded = Matcher(self.config.exclude_patterns) + filename_map = self.config.autosummary_filename_map + for _name, _sig, _summary, real_name in items: + real_name = filename_map.get(real_name, real_name) + docname = posixpath.join(tree_prefix, real_name) + docname = posixpath.normpath(posixpath.join(dirname, docname)) + if docname not in self.env.found_docs: + if excluded(self.env.doc2path(docname, False)): + msg = __('autosummary references excluded document %r. Ignored.') + else: + msg = __('autosummary: stub file not found %r. ' + 'Check your autosummary_generate setting.') + + logger.warning(msg, real_name, location=self.get_location()) + continue + + docnames.append(docname) + + if docnames: + tocnode = addnodes.toctree() + tocnode['includefiles'] = docnames + # This is the only line that is different from the parent class. + # This makes for cleaner TOC entries. + tocnode['entries'] = [(docn.split('/')[-1], docn) for docn in docnames] + tocnode['maxdepth'] = -1 + tocnode['glob'] = None + tocnode['caption'] = self.options.get('caption') + + nodes.append(autosummary_toc('', '', tocnode)) + + if 'toctree' not in self.options and 'caption' in self.options: + logger.warning(__('A captioned autosummary requires :toctree: option. ignored.'), + location=nodes[-1]) + + return nodes + + + def get_table(self, items): + """ + Reimplements the generation of the summary table. + + This new method returns Docutils nodes containing MyST-style + object references instead of standard Sphinx roles. It simply + regenerates the content. (It may also be possible to call the + method of the parent class and convert the syntax with a + regular expression after it's been generated.) + """ + logger.info('get_table') + table_spec = sphinx.addnodes.tabular_col_spec() + table_spec['spec'] = r'\X{1}{2}\X{1}{2}' + + table = autosummary.autosummary_table('') + real_table = docutils.nodes.table('', classes=['longtable']) + table.append(real_table) + group = docutils.nodes.tgroup('', cols=2) + real_table.append(group) + group.append(docutils.nodes.colspec('', colwidth=10)) + group.append(docutils.nodes.colspec('', colwidth=90)) + body = docutils.nodes.tbody('') + group.append(body) + + def append_row(*column_texts: str) -> None: + row = docutils.nodes.row('') + (source, line) = self.state_machine.get_source_and_line() + for text in column_texts: + node = docutils.nodes.paragraph('') + vl = docutils.statemachine.StringList() + vl.append(text, f'{source}:{line:d}:') + with sphinx.util.docutils.switch_source_input(self.state, vl): + self.state.nested_parse(vl, 0, node) + try: + if isinstance(node[0], docutils.nodes.paragraph): + node = node[0] + except IndexError: + pass + row.append(docutils.nodes.entry('', node)) + body.append(row) + + for (name, sig, summary, real_name) in items: + if 'nosignatures' not in self.options: + item = ('{py:obj}' + f'`{name} <{real_name}>`\\ ' + + sphinx.util.rst.escape(sig)) + else: + item = '{py:obj}' + f'`{name} <{real_name}>`' + append_row(item, summary) + + return [table_spec, table] + + +def get_md_suffix(app): + """Replaces `get_rst_suffix` in original `autosummary` extension.""" + return '.md' + + +def process_generate_options(app): + logger.info("============ process_generate_options ============") + genfiles = app.config.autosummary_generate + logger.info(f"============ genfiles={genfiles} ============") + + if genfiles is True: + env = app.builder.env + genfiles = [env.doc2path(x, base=None) for x in env.found_docs + if os.path.isfile(env.doc2path(x))] + logger.info(f"============ genfiles={genfiles} ============") + elif genfiles is False: + pass + else: + ext = list(app.config.source_suffix) + genfiles = [genfile + (ext[0] if not genfile.endswith(tuple(ext)) else '') + for genfile in genfiles] + + for entry in genfiles[:]: + if not os.path.isfile(os.path.join(app.srcdir, entry)): + logger.warning(__('autosummary_generate: file not found: %s'), entry) + genfiles.remove(entry) + + if not genfiles: + return + + suffix = get_md_suffix(app) + logger.info(f"============ suffix={suffix} ============") + + if suffix is None: + logger.warning(__('autosummary generats .rst files internally. ' + 'But your source_suffix does not contain .rst. Skipped.')) + return + + from extensions.myst_autosummary.generate import generate_autosummary_docs + + imported_members = app.config.autosummary_imported_members + with mock(app.config.autosummary_mock_imports): + generate_autosummary_docs(genfiles, suffix=suffix, base_path=app.srcdir, + app=app, imported_members=imported_members, + overwrite=app.config.autosummary_generate_overwrite, + encoding=app.config.source_encoding) + + +def setup(app): + """ + Sets up the extension. + + Sphinx calls this function if the user named the extension in `conf.py`. + It then sets up the Autosummary extension that ships with Sphinx and + overrides whatever necessary to produce Markdown to be parsed by MyST + instead of reStructuredText parsed by Sphinx/Docutils. + """ + app.setup_extension('sphinx.ext.autosummary') + app.add_directive('autosummary', Autosummary, override=True) + app.connect('builder-inited', process_generate_options) + return {'version': __version__, 'parallel_read_safe': True} diff --git a/tools/docs/extensions/myst_autosummary/generate.py b/tools/docs/extensions/myst_autosummary/generate.py new file mode 100644 index 00000000..5344025f --- /dev/null +++ b/tools/docs/extensions/myst_autosummary/generate.py @@ -0,0 +1,660 @@ +"""Generates reST source files for autosummary. + +Usable as a library or script to generate automatic RST source files for +items referred to in autosummary:: directives. + +Each generated RST file contains a single auto*:: directive which +extracts the docstring of the referred item. + +Example Makefile rule:: + + generate: + sphinx-autogen -o source/generated source/*.rst +""" + +import argparse +import inspect +import locale +import os +import pkgutil +import pydoc +import re +import sys +from gettext import NullTranslations +from os import path +from typing import Any, Dict, List, NamedTuple, Sequence, Set, Tuple, Type + +from jinja2 import TemplateNotFound +from jinja2.sandbox import SandboxedEnvironment + +import sphinx.locale +from sphinx import __display_version__, package_dir +from sphinx.application import Sphinx +from sphinx.builders import Builder +from sphinx.config import Config +from sphinx.ext.autodoc import Documenter +from sphinx.ext.autodoc.importer import import_module +from sphinx.ext.autosummary import (ImportExceptionGroup, get_documenter, import_by_name, + import_ivar_by_name) +from sphinx.locale import __ +from sphinx.pycode import ModuleAnalyzer, PycodeError +from sphinx.registry import SphinxComponentRegistry +from sphinx.util import logging, rst, split_full_qualified_name +from sphinx.util.inspect import getall, safe_getattr +from sphinx.util.osutil import ensuredir +from sphinx.util.template import SphinxTemplateLoader + +logger = logging.getLogger(__name__) + + +class DummyApplication: + """Dummy Application class for sphinx-autogen command.""" + + def __init__(self, translator: NullTranslations) -> None: + self.config = Config() + self.registry = SphinxComponentRegistry() + self.messagelog: List[str] = [] + self.srcdir = "/" + self.translator = translator + self.verbosity = 0 + self._warncount = 0 + self.warningiserror = False + + self.config.add('autosummary_context', {}, True, None) + self.config.add('autosummary_filename_map', {}, True, None) + self.config.add('autosummary_ignore_module_all', True, 'env', bool) + self.config.init_values() + + def emit_firstresult(self, *args: Any) -> None: + pass + + +class AutosummaryEntry(NamedTuple): + name: str + path: str + template: str + recursive: bool + + +def setup_documenters(app: Any) -> None: + from sphinx.ext.autodoc import (AttributeDocumenter, ClassDocumenter, DataDocumenter, + DecoratorDocumenter, ExceptionDocumenter, + FunctionDocumenter, MethodDocumenter, ModuleDocumenter, + NewTypeAttributeDocumenter, NewTypeDataDocumenter, + PropertyDocumenter) + documenters: List[Type[Documenter]] = [ + ModuleDocumenter, ClassDocumenter, ExceptionDocumenter, DataDocumenter, + FunctionDocumenter, MethodDocumenter, NewTypeAttributeDocumenter, + NewTypeDataDocumenter, AttributeDocumenter, DecoratorDocumenter, PropertyDocumenter, + ] + for documenter in documenters: + app.registry.add_documenter(documenter.objtype, documenter) + + +def _underline(title: str, line: str = '=') -> str: + if '\n' in title: + raise ValueError('Can only underline single lines') + return title + '\n' + line * len(title) + + +class AutosummaryRenderer: + """A helper class for rendering.""" + + def __init__(self, app: Sphinx) -> None: + if isinstance(app, Builder): + raise ValueError('Expected a Sphinx application object!') + + system_templates_path = [os.path.join(package_dir, 'ext', 'autosummary', 'templates')] + loader = SphinxTemplateLoader(app.srcdir, app.config.templates_path, + system_templates_path) + + self.env = SandboxedEnvironment(loader=loader) + self.env.filters['escape'] = rst.escape + self.env.filters['e'] = rst.escape + self.env.filters['underline'] = _underline + + if app.translator: + self.env.add_extension("jinja2.ext.i18n") + self.env.install_gettext_translations(app.translator) + + def render(self, template_name: str, context: Dict) -> str: + """Render a template file.""" + try: + template = self.env.get_template(template_name) + except TemplateNotFound: + try: + # objtype is given as template_name + template = self.env.get_template('autosummary/%s.rst' % template_name) + except TemplateNotFound: + # fallback to base.rst + template = self.env.get_template('autosummary/base.rst') + + return template.render(context) + + +# -- Generating output --------------------------------------------------------- + + +class ModuleScanner: + def __init__(self, app: Any, obj: Any) -> None: + self.app = app + self.object = obj + + def get_object_type(self, name: str, value: Any) -> str: + return get_documenter(self.app, value, self.object).objtype + + def is_skipped(self, name: str, value: Any, objtype: str) -> bool: + try: + return self.app.emit_firstresult('autodoc-skip-member', objtype, + name, value, False, {}) + except Exception as exc: + logger.warning(__('autosummary: failed to determine %r to be documented, ' + 'the following exception was raised:\n%s'), + name, exc, type='autosummary') + return False + + def scan(self, imported_members: bool) -> List[str]: + members = [] + try: + analyzer = ModuleAnalyzer.for_module(self.object.__name__) + attr_docs = analyzer.find_attr_docs() + except PycodeError: + attr_docs = {} + + for name in members_of(self.object, self.app.config): + try: + value = safe_getattr(self.object, name) + except AttributeError: + value = None + + objtype = self.get_object_type(name, value) + if self.is_skipped(name, value, objtype): + continue + + try: + if ('', name) in attr_docs: + imported = False + elif inspect.ismodule(value): + imported = True + elif safe_getattr(value, '__module__') != self.object.__name__: + imported = True + else: + imported = False + except AttributeError: + imported = False + + respect_module_all = not self.app.config.autosummary_ignore_module_all + if imported_members: + # list all members up + members.append(name) + elif imported is False: + # list not-imported members + members.append(name) + elif '__all__' in dir(self.object) and respect_module_all: + # list members that have __all__ set + members.append(name) + + return members + + +def members_of(obj: Any, conf: Config) -> Sequence[str]: + """Get the members of ``obj``, possibly ignoring the ``__all__`` module attribute + + Follows the ``conf.autosummary_ignore_module_all`` setting.""" + + if conf.autosummary_ignore_module_all: + return dir(obj) + else: + return getall(obj) or dir(obj) + + +def generate_autosummary_content(name: str, obj: Any, parent: Any, + template: AutosummaryRenderer, template_name: str, + imported_members: bool, app: Any, + recursive: bool, context: Dict, + modname: str = None, qualname: str = None) -> str: + doc = get_documenter(app, obj, parent) + + def skip_member(obj: Any, name: str, objtype: str) -> bool: + try: + return app.emit_firstresult('autodoc-skip-member', objtype, name, + obj, False, {}) + except Exception as exc: + logger.warning(__('autosummary: failed to determine %r to be documented, ' + 'the following exception was raised:\n%s'), + name, exc, type='autosummary') + return False + + def get_class_members(obj: Any) -> Dict[str, Any]: + members = sphinx.ext.autodoc.get_class_members(obj, [qualname], safe_getattr) + return {name: member.object for name, member in members.items()} + + def get_module_members(obj: Any) -> Dict[str, Any]: + members = {} + for name in members_of(obj, app.config): + try: + members[name] = safe_getattr(obj, name) + except AttributeError: + continue + return members + + def get_all_members(obj: Any) -> Dict[str, Any]: + if doc.objtype == "module": + return get_module_members(obj) + elif doc.objtype == "class": + return get_class_members(obj) + return {} + + def get_members(obj: Any, types: Set[str], include_public: List[str] = [], + imported: bool = True) -> Tuple[List[str], List[str]]: + items: List[str] = [] + public: List[str] = [] + + all_members = get_all_members(obj) + for name, value in all_members.items(): + documenter = get_documenter(app, value, obj) + if documenter.objtype in types: + # skip imported members if expected + if imported or getattr(value, '__module__', None) == obj.__name__: + skipped = skip_member(value, name, documenter.objtype) + if skipped is True: + pass + elif skipped is False: + # show the member forcedly + items.append(name) + public.append(name) + else: + items.append(name) + if name in include_public or not name.startswith('_'): + # considers member as public + public.append(name) + return public, items + + def get_module_attrs(members: Any) -> Tuple[List[str], List[str]]: + """Find module attributes with docstrings.""" + attrs, public = [], [] + try: + analyzer = ModuleAnalyzer.for_module(name) + attr_docs = analyzer.find_attr_docs() + for namespace, attr_name in attr_docs: + if namespace == '' and attr_name in members: + attrs.append(attr_name) + if not attr_name.startswith('_'): + public.append(attr_name) + except PycodeError: + pass # give up if ModuleAnalyzer fails to parse code + return public, attrs + + def get_modules(obj: Any) -> Tuple[List[str], List[str]]: + items: List[str] = [] + for _, modname, _ispkg in pkgutil.iter_modules(obj.__path__): + fullname = name + '.' + modname + try: + module = import_module(fullname) + if module and hasattr(module, '__sphinx_mock__'): + continue + except ImportError: + pass + + items.append(fullname) + public = [x for x in items if not x.split('.')[-1].startswith('_')] + return public, items + + ns: Dict[str, Any] = {} + ns.update(context) + + if doc.objtype == 'module': + scanner = ModuleScanner(app, obj) + ns['members'] = scanner.scan(imported_members) + ns['functions'], ns['all_functions'] = \ + get_members(obj, {'function'}, imported=imported_members) + ns['classes'], ns['all_classes'] = \ + get_members(obj, {'class'}, imported=imported_members) + ns['exceptions'], ns['all_exceptions'] = \ + get_members(obj, {'exception'}, imported=imported_members) + ns['attributes'], ns['all_attributes'] = \ + get_module_attrs(ns['members']) + ispackage = hasattr(obj, '__path__') + if ispackage and recursive: + ns['modules'], ns['all_modules'] = get_modules(obj) + elif doc.objtype == 'class': + ns['members'] = dir(obj) + ns['inherited_members'] = \ + set(dir(obj)) - set(obj.__dict__.keys()) + ns['methods'], ns['all_methods'] = \ + get_members(obj, {'method'}, ['__init__']) + ns['attributes'], ns['all_attributes'] = \ + get_members(obj, {'attribute', 'property'}) + + if modname is None or qualname is None: + modname, qualname = split_full_qualified_name(name) + + if doc.objtype in ('method', 'attribute', 'property'): + ns['class'] = qualname.rsplit(".", 1)[0] + + if doc.objtype in ('class',): + shortname = qualname + else: + shortname = qualname.rsplit(".", 1)[-1] + + ns['fullname'] = name + ns['module'] = modname + ns['objname'] = qualname + ns['name'] = shortname + + ns['objtype'] = doc.objtype + ns['underline'] = len(name) * '=' + + if template_name: + return template.render(template_name, ns) + else: + return template.render(doc.objtype, ns) + + +def generate_autosummary_docs(sources: List[str], output_dir: str = None, + suffix: str = '.rst', base_path: str = None, + imported_members: bool = False, app: Any = None, + overwrite: bool = True, encoding: str = 'utf-8') -> None: + logger.info('===== generate_autosummary_docs =====') + showed_sources = sorted(sources) + if len(showed_sources) > 20: + showed_sources = showed_sources[:10] + ['...'] + showed_sources[-10:] + logger.info(__('[autosummary] generating autosummary for: %s') % + ', '.join(showed_sources)) + + if output_dir: + logger.info(__('[autosummary] writing to %s') % output_dir) + + if base_path is not None: + sources = [os.path.join(base_path, filename) for filename in sources] + + template = AutosummaryRenderer(app) + + # read + items = find_autosummary_in_files(sources) + logger.info(f'===== items={items} =====') + + # keep track of new files + new_files = [] + + if app: + filename_map = app.config.autosummary_filename_map + else: + filename_map = {} + + # write + for entry in sorted(set(items), key=str): + if entry.path is None: + # The corresponding autosummary:: directive did not have + # a :toctree: option + continue + + path = output_dir or os.path.abspath(entry.path) + ensuredir(path) + + try: + name, obj, parent, modname = import_by_name(entry.name) + qualname = name.replace(modname + ".", "") + except ImportExceptionGroup as exc: + try: + # try to import as an instance attribute + name, obj, parent, modname = import_ivar_by_name(entry.name) + qualname = name.replace(modname + ".", "") + except ImportError as exc2: + if exc2.__cause__: + exceptions: List[BaseException] = exc.exceptions + [exc2.__cause__] + else: + exceptions = exc.exceptions + [exc2] + + errors = list({"* %s: %s" % (type(e).__name__, e) for e in exceptions}) + logger.warning(__('[autosummary] failed to import %s.\nPossible hints:\n%s'), + entry.name, '\n'.join(errors)) + continue + + context: Dict[str, Any] = {} + if app: + context.update(app.config.autosummary_context) + + content = generate_autosummary_content(name, obj, parent, template, entry.template, + imported_members, app, entry.recursive, context, + modname, qualname) + + filename = os.path.join(path, filename_map.get(name, name) + suffix) + if os.path.isfile(filename): + with open(filename, encoding=encoding) as f: + old_content = f.read() + + if content == old_content: + continue + elif overwrite: # content has changed + with open(filename, 'w', encoding=encoding) as f: + f.write(content) + new_files.append(filename) + else: + with open(filename, 'w', encoding=encoding) as f: + f.write(content) + new_files.append(filename) + + # descend recursively to new files + if new_files: + generate_autosummary_docs(new_files, output_dir=output_dir, + suffix=suffix, base_path=base_path, + imported_members=imported_members, app=app, + overwrite=overwrite) + + +# -- Finding documented entries in files --------------------------------------- + +def find_autosummary_in_files(filenames: List[str]) -> List[AutosummaryEntry]: + """Find out what items are documented in source/*.rst. + + See `find_autosummary_in_lines`. + """ + documented: List[AutosummaryEntry] = [] + for filename in filenames: + with open(filename, encoding='utf-8', errors='ignore') as f: + lines = f.read().splitlines() + documented.extend(find_autosummary_in_lines(lines, filename=filename)) + return documented + + +def find_autosummary_in_docstring(name: str, filename: str = None) -> List[AutosummaryEntry]: + """Find out what items are documented in the given object's docstring. + + See `find_autosummary_in_lines`. + """ + try: + real_name, obj, parent, modname = import_by_name(name) + lines = pydoc.getdoc(obj).splitlines() + return find_autosummary_in_lines(lines, module=name, filename=filename) + except AttributeError: + pass + except ImportExceptionGroup as exc: + errors = list({"* %s: %s" % (type(e).__name__, e) for e in exc.exceptions}) + print('Failed to import %s.\nPossible hints:\n%s' % (name, '\n'.join(errors))) + except SystemExit: + print("Failed to import '%s'; the module executes module level " + "statement and it might call sys.exit()." % name) + return [] + + +def find_autosummary_in_lines(lines: List[str], module: str = None, filename: str = None + ) -> List[AutosummaryEntry]: + """Find out what items appear in autosummary:: directives in the + given lines. + + Returns a list of (name, toctree, template) where *name* is a name + of an object and *toctree* the :toctree: path of the corresponding + autosummary directive (relative to the root of the file name), and + *template* the value of the :template: option. *toctree* and + *template* ``None`` if the directive does not have the + corresponding options set. + """ + autosummary_re = re.compile(r'^(\s*)```{autosummary}\s*') + automodule_re = re.compile( + r'^\s*```{automodule}\s*([A-Za-z0-9_.]+)\s*$') + module_re = re.compile( + r'^\s*```{(current)?module}\s*([a-zA-Z0-9_.]+)\s*$') + autosummary_item_re = re.compile(r'^\s*(~?[_a-zA-Z][a-zA-Z0-9_.]*)\s*.*?') + recursive_arg_re = re.compile(r'^\s*recursive:\s*$') + toctree_arg_re = re.compile(r'^\s*toctree:\s*(.*?)\s*$') + template_arg_re = re.compile(r'^\s*template:\s*(.*?)\s*$') + topmatter_re = re.compile(r'^\s*-{3,}\s*$') + + documented: List[AutosummaryEntry] = [] + + recursive = False + toctree: str = None + template = None + current_module = module + in_autosummary = False + in_topmatter = False + base_indent = "" + + for line in lines: + # logger.info(f"LINE: {line}") + if in_autosummary: + if in_topmatter: + m = topmatter_re.match(line) + if m: + logger.info(f"========= topmatter_re (stop): {line} =========") + in_topmatter = False + continue + + m = recursive_arg_re.match(line) + if m: + recursive = True + continue + + m = toctree_arg_re.match(line) + if m: + toctree = m.group(1) + if filename: + toctree = os.path.join(os.path.dirname(filename), + toctree) + continue + + m = template_arg_re.match(line) + if m: + template = m.group(1).strip() + continue + + continue # skip options + + m = topmatter_re.match(line) + if m: + logger.info(f"========= topmatter_re (start): {line} =========") + in_topmatter = True + continue + + m = autosummary_item_re.match(line) + if m: + logger.info(f"========= autosummary_item_re: {line} =========") + name = m.group(1).strip() + if name.startswith('~'): + name = name[1:] + if current_module and \ + not name.startswith(current_module + '.'): + name = "%s.%s" % (current_module, name) + documented.append(AutosummaryEntry(name, toctree, template, recursive)) + continue + + if not line.strip() or line.startswith(base_indent + " "): + continue + + in_autosummary = False + + m = autosummary_re.match(line) + if m: + logger.info(f"========= autosummary_re: {line} =========") + in_autosummary = True + base_indent = m.group(1) + recursive = False + toctree = None + template = None + continue + + m = automodule_re.search(line) + if m: + current_module = m.group(1).strip() + # recurse into the automodule docstring + documented.extend(find_autosummary_in_docstring( + current_module, filename=filename)) + continue + + m = module_re.match(line) + if m: + current_module = m.group(2) + continue + + return documented + + +def get_parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser( + usage='%(prog)s [OPTIONS] ...', + epilog=__('For more information, visit .'), + description=__(""" +Generate ReStructuredText using autosummary directives. + +sphinx-autogen is a frontend to sphinx.ext.autosummary.generate. It generates +the reStructuredText files from the autosummary directives contained in the +given input files. + +The format of the autosummary directive is documented in the +``sphinx.ext.autosummary`` Python module and can be read using:: + + pydoc sphinx.ext.autosummary +""")) + + parser.add_argument('--version', action='version', dest='show_version', + version='%%(prog)s %s' % __display_version__) + + parser.add_argument('source_file', nargs='+', + help=__('source files to generate rST files for')) + + parser.add_argument('-o', '--output-dir', action='store', + dest='output_dir', + help=__('directory to place all output in')) + parser.add_argument('-s', '--suffix', action='store', dest='suffix', + default='rst', + help=__('default suffix for files (default: ' + '%(default)s)')) + parser.add_argument('-t', '--templates', action='store', dest='templates', + default=None, + help=__('custom template directory (default: ' + '%(default)s)')) + parser.add_argument('-i', '--imported-members', action='store_true', + dest='imported_members', default=False, + help=__('document imported members (default: ' + '%(default)s)')) + parser.add_argument('-a', '--respect-module-all', action='store_true', + dest='respect_module_all', default=False, + help=__('document exactly the members in module __all__ attribute. ' + '(default: %(default)s)')) + + return parser + + +def main(argv: List[str] = sys.argv[1:]) -> None: + sphinx.locale.setlocale(locale.LC_ALL, '') + sphinx.locale.init_console(os.path.join(package_dir, 'locale'), 'sphinx') + translator, _ = sphinx.locale.init([], None) + + app = DummyApplication(translator) + logging.setup(app, sys.stdout, sys.stderr) # type: ignore + setup_documenters(app) + args = get_parser().parse_args(argv) + + if args.templates: + app.config.templates_path.append(path.abspath(args.templates)) + app.config.autosummary_ignore_module_all = not args.respect_module_all # type: ignore + + generate_autosummary_docs(args.source_file, args.output_dir, + '.' + args.suffix, + imported_members=args.imported_members, + app=app) + + +if __name__ == '__main__': + main() diff --git a/tools/docs/guide.md b/tools/docs/guide.md new file mode 100644 index 00000000..8c0d02fa --- /dev/null +++ b/tools/docs/guide.md @@ -0,0 +1 @@ +# Guide diff --git a/tools/docs/guide.rst b/tools/docs/guide.rst deleted file mode 100644 index 7a61aa6b..00000000 --- a/tools/docs/guide.rst +++ /dev/null @@ -1,2 +0,0 @@ -TensorFlow MRI guide -==================== diff --git a/tools/docs/guide/faq.rst b/tools/docs/guide/faq.md similarity index 73% rename from tools/docs/guide/faq.rst rename to tools/docs/guide/faq.md index a699674f..30695aef 100644 --- a/tools/docs/guide/faq.rst +++ b/tools/docs/guide/faq.md @@ -1,5 +1,4 @@ -Frequently Asked Questions -========================== +# Frequently asked questions **When trying to install TensorFlow MRI, I get an error about OpenEXR which includes: @@ -10,6 +9,8 @@ OpenEXR is needed by TensorFlow Graphics, which is a dependency of TensorFlow MRI. This issue can be fixed by installing the OpenEXR library. On Debian/Ubuntu: -.. code-block:: console +``` +apt install libopenexr-dev +``` - $ apt install libopenexr-dev +Depending on your environment, you might need sudo access. diff --git a/tools/docs/guide/install.md b/tools/docs/guide/install.md new file mode 100644 index 00000000..dc694a87 --- /dev/null +++ b/tools/docs/guide/install.md @@ -0,0 +1,81 @@ +# Install TensorFlow MRI + +## Requirements + +TensorFlow MRI should work in most Linux systems that meet the +[requirements for TensorFlow](https://www.tensorflow.org/install). + +```{warning} +TensorFlow MRI is not yet available for Windows or macOS. +[`Help us support them!](https://github.com/mrphys/tensorflow-mri/issues/3). +``` + +### TensorFlow compatibility + +Each TensorFlow MRI release is compiled against a specific version of +TensorFlow. To ensure compatibility, it is recommended to install matching +versions of TensorFlow and TensorFlow MRI according to the +{ref}`TensorFlow compatibility table`. + +```{warning} +Each TensorFlow MRI version aims to target and support the latest TensorFlow +version only. A new version of TensorFlow MRI will be released shortly after +each TensorFlow release. TensorFlow MRI versions that target older versions +of TensorFlow will not generally receive any updates. +``` + +## Set up your system + +You will need a working TensorFlow installation. Follow the +[TensorFlow installation instructions](https://www.tensorflow.org/install) if +you do not have one already. + + +### Use a GPU + +If you need GPU support, we suggest that you use one of the +[TensorFlow Docker images](https://www.tensorflow.org/install/docker). +These come with a GPU-enabled TensorFlow installation and are the easiest way +to run TensorFlow and TensorFlow MRI on your system. + +.. code-block:: console + + $ docker pull tensorflow/tensorflow:latest-gpu + +Alternatively, make sure you follow +[these instructions](https://www.tensorflow.org/install/gpu) when setting up +your system. + + +## Download from PyPI + +TensorFlow MRI is available on the Python package index (PyPI) and can be +installed using the ``pip`` package manager: + +``` +pip install tensorflow-mri +``` + + +## Run in Google Colab + +To get started without installing anything on your system, you can use +[Google Colab](https://colab.research.google.com/notebooks/welcome.ipynb). +Simply create a new notebook and use ``pip`` to install TensorFlow MRI. + +```python +!pip install tensorflow-mri +``` + +The Colab environment is already configured to run TensorFlow and has GPU +support. + + +### TensorFlow compatibility table + +```{include} ../../../README.md +--- +start-after: start-compatibility-table +end-before: end-compatibility-table +--- +``` diff --git a/tools/docs/guide/install.rst b/tools/docs/guide/install.rst deleted file mode 100644 index 404c4a7b..00000000 --- a/tools/docs/guide/install.rst +++ /dev/null @@ -1,89 +0,0 @@ -Install TensorFlow MRI -====================== - -Requirements ------------- - -TensorFlow MRI should work in most Linux systems that meet the -`requirements for TensorFlow `_. - -.. warning:: - - TensorFlow MRI is not yet available for Windows or macOS. - `Help us support them! `_. - - -TensorFlow compatibility -~~~~~~~~~~~~~~~~~~~~~~~~ - -Each TensorFlow MRI release is compiled against a specific version of -TensorFlow. To ensure compatibility, it is recommended to install matching -versions of TensorFlow and TensorFlow MRI according to the -:ref:`TensorFlow compatibility table`. - -.. warning:: - - Each TensorFlow MRI version aims to target and support the latest TensorFlow - version only. A new version of TensorFlow MRI will be released shortly after - each TensorFlow release. TensorFlow MRI versions that target older versions - of TensorFlow will not generally receive any updates. - - -Set up your system ------------------- - -You will need a working TensorFlow installation. Follow the `TensorFlow -installation instructions `_ if you do not -have one already. - - -Use a GPU -~~~~~~~~~ - -If you need GPU support, we suggest that you use one of the -`TensorFlow Docker images `_. -These come with a GPU-enabled TensorFlow installation and are the easiest way -to run TensorFlow and TensorFlow MRI on your system. - -.. code-block:: console - - $ docker pull tensorflow/tensorflow:latest-gpu - -Alternatively, make sure you follow -`these instructions `_ when setting up -your system. - - -Download from PyPI ------------------- - -TensorFlow MRI is available on the Python package index (PyPI) and can be -installed using the ``pip`` package manager: - -.. code-block:: console - - $ pip install tensorflow-mri - - -Run in Google Colab -------------------- - -To get started without installing anything on your system, you can use -`Google Colab `_. -Simply create a new notebook and use ``pip`` to install TensorFlow MRI. - -.. code:: python - - !pip install tensorflow-mri - - -The Colab environment is already configured to run TensorFlow and has GPU -support. - - -TensorFlow compatibility table ------------------------------- - -.. include:: ../../../README.rst - :start-after: start-compatibility-table - :end-before: end-compatibility-table diff --git a/tools/docs/templates/index.md b/tools/docs/templates/index.md new file mode 100644 index 00000000..181fc54f --- /dev/null +++ b/tools/docs/templates/index.md @@ -0,0 +1,43 @@ +# TensorFlow MRI {{ release }} + +```{include} ../../README.md +--- +start-after: start-intro +end-before: end-intro +--- +``` + +```{toctree} +--- +caption: Guide +hidden: +--- +Guide +Installation +Fast Fourier transform +Non-uniform FFT +Linear algebra +Optimization +MRI reconstruction +Contributing +FAQ +``` + +```{toctree} +--- +caption: Tutorials +hidden: +--- +Tutorials +Image reconstruction +``` + +```{toctree} +--- +caption: API Documentation +hidden: +--- +api_docs +api_docs/tfmri +${namespaces} +``` diff --git a/tools/docs/templates/index.rst b/tools/docs/templates/index.rst deleted file mode 100644 index e410e98e..00000000 --- a/tools/docs/templates/index.rst +++ /dev/null @@ -1,46 +0,0 @@ -TensorFlow MRI |release| -======================== - -.. image:: https://img.shields.io/badge/-View%20on%20GitHub-128091?logo=github&labelColor=grey - :target: https://github.com/mrphys/tensorflow-mri - :alt: View on GitHub - -.. include:: ../../README.rst - :start-after: start-intro - :end-before: end-intro - - -.. toctree:: - :caption: Guide - :hidden: - - Guide - Installation - Fast Fourier transform - Non-uniform FFT - Linear algebra - Optimization - MRI reconstruction - Contributing - FAQ - - -.. toctree:: - :caption: Tutorials - :hidden: - - Tutorials - Image reconstruction - - -.. toctree:: - :caption: API Documentation - :hidden: - - API documentation - api_docs/tfmri - ${namespaces} - - -.. meta:: - :google-site-verification: 8PySedj6KJ0kc5qC1CbO6_9blFB9Nho3SgXvbRzyVOU diff --git a/tools/docs/tutorials.rst b/tools/docs/tutorials.md similarity index 87% rename from tools/docs/tutorials.rst rename to tools/docs/tutorials.md index 9c522205..a0c22b26 100644 --- a/tools/docs/tutorials.rst +++ b/tools/docs/tutorials.md @@ -1,5 +1,4 @@ -TensorFlow MRI tutorials -======================== +# Tutorials All TensorFlow MRI tutorials are written as Jupyter notebooks. diff --git a/tools/docs/tutorials/recon.md b/tools/docs/tutorials/recon.md new file mode 100644 index 00000000..86f0f87b --- /dev/null +++ b/tools/docs/tutorials/recon.md @@ -0,0 +1,8 @@ +# Image reconstruction + +```{toctree} +--- +hidden: +--- + +``` diff --git a/tools/docs/tutorials/recon.rst b/tools/docs/tutorials/recon.rst deleted file mode 100644 index 6cbac95d..00000000 --- a/tools/docs/tutorials/recon.rst +++ /dev/null @@ -1,7 +0,0 @@ -Image reconstruction -==================== - -.. toctree:: - :hidden: - - CG-SENSE diff --git a/tools/docs/tutorials/recon/cg_sense.ipynb b/tools/docs/tutorials/recon/cg_sense.ipynb index d1ab7fa4..32242d78 100644 --- a/tools/docs/tutorials/recon/cg_sense.ipynb +++ b/tools/docs/tutorials/recon/cg_sense.ipynb @@ -7,16 +7,6 @@ "# Image reconstruction with CG-SENSE" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "[![View on website](https://img.shields.io/badge/-View%20on%20website-128091?labelColor=grey&logo=data:image/svg+xml;base64,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)](https://mrphys.github.io/tensorflow-mri/tutorials/recon/cg_sense)\n", - "[![Run in Colab](https://img.shields.io/badge/-Run%20in%20Colab-128091?labelColor=grey&logo=googlecolab)](https://colab.research.google.com/github/mrphys/tensorflow-mri/blob/master/tools/docs/tutorials/recon/cg_sense.ipynb)\n", - "[![View on GitHub](https://img.shields.io/badge/-View%20on%20GitHub-128091?labelColor=grey&logo=github)](https://github.com/mrphys/tensorflow-mri/blob/master/tools/docs/tutorials/recon/cg_sense.ipynb)\n", - "[![Download notebook](https://img.shields.io/badge/-Download%20notebook-128091?labelColor=grey&logo=data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->

<svg
   version="1.1"
   id="svg55"
   width="24"
   height="24"
   viewBox="0 0 24 24"
   sodipodi:docname="icons8-download-96.png"
   inkscape:version="1.1.2 (1:1.1+202202050942+0a00cf5339)"
   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg">
  <defs
     id="defs59">
    <inkscape:path-effect
       effect="fillet_chamfer"
       id="path-effect3740"
       is_visible="true"
       lpeversion="1"
       satellites_param="F,0,0,1,0,4,0,1 @ F,0,0,1,0,4,0,1 @ F,0,0,1,0,4,0,1 @ F,0,0,1,0,4,0,1"
       unit="px"
       method="auto"
       mode="F"
       radius="4"
       chamfer_steps="1"
       flexible="false"
       use_knot_distance="true"
       apply_no_radius="true"
       apply_with_radius="true"
       only_selected="false"
       hide_knots="false" />
    <inkscape:path-effect
       effect="fillet_chamfer"
       id="path-effect3720"
       is_visible="true"
       lpeversion="1"
       satellites_param="F,0,0,1,0,1,0,1 @ F,0,0,1,0,1,0,1 @ F,0,0,1,0,1,0,1 @ F,0,0,1,0,1,0,1"
       unit="px"
       method="auto"
       mode="F"
       radius="1"
       chamfer_steps="1"
       flexible="false"
       use_knot_distance="true"
       apply_no_radius="true"
       apply_with_radius="true"
       only_selected="false"
       hide_knots="false" />
    <inkscape:path-effect
       effect="fillet_chamfer"
       id="path-effect3517"
       is_visible="true"
       lpeversion="1"
       satellites_param="F,0,0,1,0,0,0,1 @ F,0,0,1,0,0,0,1 @ F,0,0,1,0,0,0,1 @ F,0,0,1,0,0,0,1"
       unit="px"
       method="auto"
       mode="F"
       radius="4"
       chamfer_steps="1"
       flexible="false"
       use_knot_distance="true"
       apply_no_radius="true"
       apply_with_radius="true"
       only_selected="false"
       hide_knots="false" />
    <inkscape:path-effect
       effect="fillet_chamfer"
       id="path-effect3360"
       is_visible="true"
       lpeversion="1"
       satellites_param="F,0,0,1,0,0,0,1 @ F,0,0,1,0,0,0,1 @ F,0,0,1,0,0,0,1 @ F,0,0,1,0,0,0,1"
       unit="px"
       method="auto"
       mode="F"
       radius="4"
       chamfer_steps="1"
       flexible="false"
       use_knot_distance="true"
       apply_no_radius="true"
       apply_with_radius="true"
       only_selected="false"
       hide_knots="false" />
    <inkscape:path-effect
       effect="fillet_chamfer"
       id="path-effect3312"
       is_visible="true"
       lpeversion="1"
       satellites_param="F,0,0,1,0,3,0,1 @ F,0,0,1,0,3,0,1 @ F,0,0,1,0,3,0,1"
       unit="px"
       method="auto"
       mode="F"
       radius="4"
       chamfer_steps="1"
       flexible="false"
       use_knot_distance="true"
       apply_no_radius="true"
       apply_with_radius="true"
       only_selected="false"
       hide_knots="false" />
    <inkscape:path-effect
       effect="fillet_chamfer"
       id="path-effect1987"
       is_visible="true"
       lpeversion="1"
       satellites_param="F,0,0,1,0,4,0,1 @ F,0,0,1,0,4,0,1 @ F,0,0,1,0,4,0,1 @ F,0,0,1,0,4,0,1"
       unit="px"
       method="auto"
       mode="F"
       radius="4"
       chamfer_steps="1"
       flexible="false"
       use_knot_distance="true"
       apply_no_radius="true"
       apply_with_radius="true"
       only_selected="false"
       hide_knots="false" />
    <inkscape:path-effect
       effect="fillet_chamfer"
       id="path-effect929"
       is_visible="true"
       lpeversion="1"
       satellites_param="F,0,0,1,0,4,0,1 @ F,0,0,1,0,4,0,1 @ F,0,0,1,0,4,0,1 @ F,0,0,1,0,4,0,1"
       unit="px"
       method="auto"
       mode="F"
       radius="4"
       chamfer_steps="1"
       flexible="false"
       use_knot_distance="true"
       apply_no_radius="true"
       apply_with_radius="true"
       only_selected="false"
       hide_knots="false" />
    <inkscape:path-effect
       effect="fillet_chamfer"
       id="path-effect560"
       is_visible="true"
       lpeversion="1"
       satellites_param="F,0,0,1,0,4,0,1 @ F,0,0,1,0,4.1323252,0,1 @ F,0,0,1,0,4,0,1"
       unit="px"
       method="auto"
       mode="F"
       radius="4"
       chamfer_steps="1"
       flexible="false"
       use_knot_distance="true"
       apply_no_radius="true"
       apply_with_radius="true"
       only_selected="false"
       hide_knots="false" />
    <inkscape:path-effect
       effect="fillet_chamfer"
       id="path-effect249"
       is_visible="true"
       lpeversion="1"
       satellites_param="F,0,0,1,0,3.4641016,0,1 @ F,0,0,1,0,3.4641016,0,1 @ F,0,0,1,0,3.4641016,0,1"
       unit="px"
       method="auto"
       mode="F"
       radius="2"
       chamfer_steps="1"
       flexible="false"
       use_knot_distance="false"
       apply_no_radius="true"
       apply_with_radius="true"
       only_selected="false"
       hide_knots="false" />
  </defs>
  <sodipodi:namedview
     id="namedview57"
     pagecolor="#ffffff"
     bordercolor="#666666"
     borderopacity="1.0"
     inkscape:pageshadow="2"
     inkscape:pageopacity="0.0"
     inkscape:pagecheckerboard="0"
     showgrid="true"
     inkscape:snap-global="false"
     inkscape:zoom="17.375"
     inkscape:cx="-4.4028777"
     inkscape:cy="10.244604"
     inkscape:window-width="1920"
     inkscape:window-height="1043"
     inkscape:window-x="0"
     inkscape:window-y="0"
     inkscape:window-maximized="1"
     inkscape:current-layer="layer1"
     width="2400000px">
    <inkscape:grid
       type="xygrid"
       id="grid804" />
  </sodipodi:namedview>
  <g
     inkscape:groupmode="layer"
     id="layer1"
     inkscape:label="Vectors">
    <path
       id="path2779"
       style="fill:#ffffff;stroke-width:0.290655"
       inkscape:transform-center-x="0.031879892"
       inkscape:transform-center-y="1.0318494"
       d="m 11,2 a 1,1 0 0 0 -1,1 v 8.010254 l -4,-0.0088 a 0.29449253,0.29449252 0 0 0 -0.2016603,0.510254 l 5.6054693,5.226562 a 0.81189245,0.81189245 0 0 0 1.101562,0.0054 l 5.691406,-5.208006 A 0.2923067,0.2923067 0 0 0 18,11.027832 l -4,-0.0088 V 3 A 1,1 0 0 0 13,2 Z" />
    <path
       id="rect1887"
       style="fill:#ffffff;stroke-width:0.251577"
       d="m 3,20 h 18 a 1,1 45 0 1 1,1 1,1 135 0 1 -1,1 H 3 A 1,1 45 0 1 2,21 1,1 135 0 1 3,20 Z" />
  </g>
</svg>
)](https://raw.githubusercontent.com/mrphys/tensorflow-mri/master/tools/docs/tutorials/recon/cg_sense.ipynb)" - ] - }, { "cell_type": "markdown", "metadata": {}, From dbb913d13a293dedd2c290d0f910468f1e423e3a Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 24 Aug 2022 23:15:15 +0000 Subject: [PATCH 040/101] Move docs to markdown --- README.md | 73 +- .../python/activations/complex_activations.py | 32 +- tools/docs/conf.py | 34 +- .../extensions/myst_autosummary/__init__.py | 5 - .../extensions/myst_autosummary/generate.py | 11 +- .../docs/extensions/myst_napoleon/__init__.py | 479 ++++++ .../extensions/myst_napoleon/docstring.py | 1357 +++++++++++++++++ .../extensions/myst_napoleon/iterators.py | 235 +++ tools/docs/guide/install.md | 22 +- tools/docs/test_docs.py | 2 + tools/docs/tutorials/recon.md | 2 +- 11 files changed, 2144 insertions(+), 108 deletions(-) create mode 100644 tools/docs/extensions/myst_napoleon/__init__.py create mode 100644 tools/docs/extensions/myst_napoleon/docstring.py create mode 100644 tools/docs/extensions/myst_napoleon/iterators.py diff --git a/README.md b/README.md index 78678bb1..0554aef2 100644 --- a/README.md +++ b/README.md @@ -1,17 +1,11 @@ -.. image:: https://raw.githubusercontent.com/mrphys/tensorflow-mri/v0.6.0/tools/assets/tfmr_logo.svg?sanitize=true - :align: center - :scale: 100 % - :alt: TFMRI logo +
+ +
-| - -[![PyPI](https://badge.fury.io/py/tensorflow-mri) -.. |build| image:: https://github.com/mrphys/tensorflow-mri/actions/workflows/build-package.yml/badge.svg - :target: https://github.com/mrphys/tensorflow-mri/actions/workflows/build-package.yml -.. |docs| image:: https://img.shields.io/badge/api-reference-blue.svg - :target: https://mrphys.github.io/tensorflow-mri/ -.. |doi| image:: https://zenodo.org/badge/388094708.svg - :target: https://zenodo.org/badge/latestdoi/388094708 +[![PyPI](https://badge.fury.io/py/tensorflow-mri.svg)](https://badge.fury.io/py/tensorflow-mri) +[![Build](https://github.com/mrphys/tensorflow-mri/actions/workflows/build-package.yml/badge.svg)](https://github.com/mrphys/tensorflow-mri/actions/workflows/build-package.yml) +[![Docs](https://img.shields.io/badge/api-reference-blue.svg)](https://mrphys.github.io/tensorflow-mri/) +[![DOI](https://zenodo.org/badge/388094708.svg)](https://zenodo.org/badge/latestdoi/388094708) % start-intro @@ -81,11 +75,11 @@ TensorFlow MRI contains operators for: gradient descent, L-BFGS. - And more, e.g., supporting array manipulation and math tasks. -% end-intro + ## Installation -% start-install + You can install TensorFlow MRI with ``pip``: @@ -101,37 +95,19 @@ Each TensorFlow MRI release is compiled against a specific version of TensorFlow. To ensure compatibility, it is recommended to install matching versions of TensorFlow and TensorFlow MRI according to the table below. -% start-compatibility-table - -====================== ======================== ============ -TensorFlow MRI Version TensorFlow Compatibility Release Date -====================== ======================== ============ -v0.22.0 v2.9.x Jul 24, 2022 -v0.21.0 v2.9.x Jul 24, 2022 -v0.20.0 v2.9.x Jun 18, 2022 -v0.19.0 v2.9.x Jun 1, 2022 -v0.18.0 v2.8.x May 6, 2022 -v0.17.0 v2.8.x Apr 22, 2022 -v0.16.0 v2.8.x Apr 13, 2022 -v0.15.0 v2.8.x Apr 1, 2022 -v0.14.0 v2.8.x Mar 29, 2022 -v0.13.0 v2.8.x Mar 15, 2022 -v0.12.0 v2.8.x Mar 14, 2022 -v0.11.0 v2.8.x Mar 10, 2022 -v0.10.0 v2.8.x Mar 3, 2022 -v0.9.0 v2.7.x Dec 3, 2021 -v0.8.0 v2.7.x Nov 11, 2021 -v0.7.0 v2.6.x Nov 3, 2021 -v0.6.2 v2.6.x Oct 13, 2021 -v0.6.1 v2.6.x Sep 30, 2021 -v0.6.0 v2.6.x Sep 28, 2021 -v0.5.0 v2.6.x Aug 29, 2021 -v0.4.0 v2.6.x Aug 18, 2021 -====================== ======================== ============ - -% end-compatibility-table - -% end-install + + +| TensorFlow MRI Version | TensorFlow Compatibility | Release Date | +| ---------------------- | ------------------------ | ------------ | +| v0.22.0 | v2.9.x | Jul 24, 2022 | +| v0.21.0 | v2.9.x | Jul 24, 2022 | +| v0.20.0 | v2.9.x | Jun 18, 2022 | +| v0.19.0 | v2.9.x | Jun 1, 2022 | +| v0.18.0 | v2.8.x | May 6, 2022 | + + + + ## Documentation @@ -146,10 +122,7 @@ describing your problem. We're here to help! ## Credits -If you like this software, star the repository! |stars| - -.. |stars| image:: https://img.shields.io/github/stars/mrphys/tensorflow-mri?style=social - :target: https://github.com/mrphys/tensorflow-mri/stargazers +If you like this software, star the repository! [![Stars](https://img.shields.io/github/stars/mrphys/tensorflow-mri?style=social)](https://github.com/mrphys/tensorflow-mri/stargazers) If you find this software useful in your research, you can cite TensorFlow MRI using its [Zenodo record](https://doi.org/10.5281/zenodo.5151590). diff --git a/tensorflow_mri/python/activations/complex_activations.py b/tensorflow_mri/python/activations/complex_activations.py index 0169b314..292159aa 100644 --- a/tensorflow_mri/python/activations/complex_activations.py +++ b/tensorflow_mri/python/activations/complex_activations.py @@ -14,6 +14,8 @@ # ============================================================================== """Complex-valued activations.""" +import inspect + import tensorflow as tf from tensorflow_mri.python.util import api_util @@ -36,6 +38,7 @@ def wrapper(x, *args, **kwargs): func(tf.math.imag(x), *args, **kwargs)) return func(x, *args, **kwargs) wrapper.__name__ = name + wrapper.__signature__ = inspect.signature(func) return wrapper return decorator @@ -57,11 +60,12 @@ def wrapper(x, *args, **kwargs): applied to its real and imaginary parts, i.e., the function returns `relu(real(x)) + 1j * relu(imag(x))`. - .. note:: - This activation does not preserve the phase of complex inputs. + ```{note} + This activation does not preserve the phase of complex inputs. + ``` If passed a real-valued tensor, this function falls back to the standard - `tf.keras.activations.relu`_. + `tf.keras.activations.relu`. Args: x: The input `tf.Tensor`. Can be real or complex. @@ -75,7 +79,8 @@ def wrapper(x, *args, **kwargs): Returns: A `tf.Tensor` of the same shape and dtype of input `x`. - .. _tf.keras.activations.relu: https://www.tensorflow.org/api_docs/python/tf/keras/activations/relu + References: + 1. https://arxiv.org/abs/1705.09792 """ ) @@ -95,16 +100,18 @@ def wrapper(x, *args, **kwargs): If passed a complex-valued tensor, the ReLU activation is applied to its magnitude, i.e., the function returns `relu(abs(x)) * exp(1j * angle(x))`. - .. note:: - This activation preserves the phase of complex inputs. + ```{note} + This activation preserves the phase of complex inputs. + ``` - .. warning:: - With default parameters, this activation is linear, since the magnitude - of the input is never negative. Usually you will want to set one or more - of the provided parameters to non-default values. + ```{warning} + With default parameters, this activation is linear, since the magnitude + of the input is never negative. Usually you will want to set one or more + of the provided parameters to non-default values. + ``` If passed a real-valued tensor, this function falls back to the standard - `tf.keras.activations.relu`_. + `tf.keras.activations.relu`. Args: x: The input `tf.Tensor`. Can be real or complex. @@ -118,6 +125,7 @@ def wrapper(x, *args, **kwargs): Returns: A `tf.Tensor` of the same shape and dtype of input `x`. - .. _tf.keras.activations.relu: https://www.tensorflow.org/api_docs/python/tf/keras/activations/relu + References: + 1. https://arxiv.org/abs/1705.09792 """ ) diff --git a/tools/docs/conf.py b/tools/docs/conf.py index bcd7c24e..b5c795b3 100644 --- a/tools/docs/conf.py +++ b/tools/docs/conf.py @@ -62,11 +62,11 @@ # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ - 'sphinx.ext.linkcode', - 'sphinx.ext.autosectionlabel', 'myst_nb', 'myst_autodoc', 'myst_autosummary', + 'myst_napoleon', + 'sphinx.ext.linkcode', 'sphinx_sitemap' ] @@ -134,6 +134,7 @@ "colon_fence", "deflist", "dollarmath", + "fieldlist", "html_image", "substitution" ] @@ -251,29 +252,22 @@ def linkcode_resolve(domain, info): 'np.ndarray': 'https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html', 'np.inf': 'https://numpy.org/doc/stable/reference/constants.html#numpy.inf', 'np.nan': 'https://numpy.org/doc/stable/reference/constants.html#numpy.nan', - # TensorFlow types. - 'tf.Tensor': 'https://www.tensorflow.org/api_docs/python/tf/Tensor', - 'tf.TensorShape': 'https://www.tensorflow.org/api_docs/python/tf/TensorShape', - 'tf.dtypes.DType': 'https://www.tensorflow.org/api_docs/python/tf/dtypes/DType' } -TFMRI_OBJECTS_PATTERN = re.compile(r"``(?Ptfmri.[a-zA-Z0-9_.]+)``") - -COMMON_TYPES_PATTERNS = { - k: re.compile(rf"``{k}``")for k in COMMON_TYPES_LINKS} - -COMMON_TYPES_REPLACEMENTS = { - k: rf"`{k} <{v}>`_" for k, v in COMMON_TYPES_LINKS.items()} - -CODE_LETTER_PATTERN = re.compile(r"``(?P\w+)``(?P[a-zA-Z])") -CODE_LETTER_REPL = r"``\g``\ \g" - -LINK_PATTERN = re.compile(r"``(?P[\w\.]+)``_") -LINK_REPL = r"`\g`_" - def process_docstring(app, what, name, obj, options, lines): # pylint: disable=missing-param-doc,unused-argument """Process autodoc docstrings.""" + # Regular expression. + tf_symbol_re = re.compile(r"`(?Ptf\.[a-zA-Z0-9_.]+)`") + # Iterate line by line. + for lineno, line in enumerate(lines): + + m = tf_symbol_re.match(line) + if m: + symbol = m.group('symbol') + link = f"https://www.tensorflow.org/api_docs/python/{symbol.replace('.', '/')}" + lines[lineno] = line.replace(f"`{symbol}`", f"[`{symbol}`]({link})") + def get_doc_url(name): diff --git a/tools/docs/extensions/myst_autosummary/__init__.py b/tools/docs/extensions/myst_autosummary/__init__.py index 4826ea93..774f6dba 100644 --- a/tools/docs/extensions/myst_autosummary/__init__.py +++ b/tools/docs/extensions/myst_autosummary/__init__.py @@ -98,7 +98,6 @@ def get_table(self, items): method of the parent class and convert the syntax with a regular expression after it's been generated.) """ - logger.info('get_table') table_spec = sphinx.addnodes.tabular_col_spec() table_spec['spec'] = r'\X{1}{2}\X{1}{2}' @@ -146,15 +145,12 @@ def get_md_suffix(app): def process_generate_options(app): - logger.info("============ process_generate_options ============") genfiles = app.config.autosummary_generate - logger.info(f"============ genfiles={genfiles} ============") if genfiles is True: env = app.builder.env genfiles = [env.doc2path(x, base=None) for x in env.found_docs if os.path.isfile(env.doc2path(x))] - logger.info(f"============ genfiles={genfiles} ============") elif genfiles is False: pass else: @@ -171,7 +167,6 @@ def process_generate_options(app): return suffix = get_md_suffix(app) - logger.info(f"============ suffix={suffix} ============") if suffix is None: logger.warning(__('autosummary generats .rst files internally. ' diff --git a/tools/docs/extensions/myst_autosummary/generate.py b/tools/docs/extensions/myst_autosummary/generate.py index 5344025f..1ac32010 100644 --- a/tools/docs/extensions/myst_autosummary/generate.py +++ b/tools/docs/extensions/myst_autosummary/generate.py @@ -355,7 +355,6 @@ def generate_autosummary_docs(sources: List[str], output_dir: str = None, suffix: str = '.rst', base_path: str = None, imported_members: bool = False, app: Any = None, overwrite: bool = True, encoding: str = 'utf-8') -> None: - logger.info('===== generate_autosummary_docs =====') showed_sources = sorted(sources) if len(showed_sources) > 20: showed_sources = showed_sources[:10] + ['...'] + showed_sources[-10:] @@ -372,7 +371,6 @@ def generate_autosummary_docs(sources: List[str], output_dir: str = None, # read items = find_autosummary_in_files(sources) - logger.info(f'===== items={items} =====') # keep track of new files new_files = [] @@ -490,6 +488,7 @@ def find_autosummary_in_lines(lines: List[str], module: str = None, filename: st *template* ``None`` if the directive does not have the corresponding options set. """ + # jmontalt: Changed regexes to support MyST syntax. autosummary_re = re.compile(r'^(\s*)```{autosummary}\s*') automodule_re = re.compile( r'^\s*```{automodule}\s*([A-Za-z0-9_.]+)\s*$') @@ -512,12 +511,12 @@ def find_autosummary_in_lines(lines: List[str], module: str = None, filename: st base_indent = "" for line in lines: - # logger.info(f"LINE: {line}") if in_autosummary: + # jmontalt: Added topmatter processing for MyST syntax. if in_topmatter: + # jmontalt: Added topmatter processing for MyST syntax. m = topmatter_re.match(line) if m: - logger.info(f"========= topmatter_re (stop): {line} =========") in_topmatter = False continue @@ -541,15 +540,14 @@ def find_autosummary_in_lines(lines: List[str], module: str = None, filename: st continue # skip options + # jmontalt: Added topmatter processing for MyST syntax. m = topmatter_re.match(line) if m: - logger.info(f"========= topmatter_re (start): {line} =========") in_topmatter = True continue m = autosummary_item_re.match(line) if m: - logger.info(f"========= autosummary_item_re: {line} =========") name = m.group(1).strip() if name.startswith('~'): name = name[1:] @@ -566,7 +564,6 @@ def find_autosummary_in_lines(lines: List[str], module: str = None, filename: st m = autosummary_re.match(line) if m: - logger.info(f"========= autosummary_re: {line} =========") in_autosummary = True base_indent = m.group(1) recursive = False diff --git a/tools/docs/extensions/myst_napoleon/__init__.py b/tools/docs/extensions/myst_napoleon/__init__.py new file mode 100644 index 00000000..f3dd770a --- /dev/null +++ b/tools/docs/extensions/myst_napoleon/__init__.py @@ -0,0 +1,479 @@ +"""Support for NumPy and Google style docstrings.""" +# This code is copied from `sphinx.ext.napoleon` v5.1.1. Any changes have +# been labelled with `jmontalt`. + +from typing import Any, Dict, List + +from sphinx import __display_version__ as __version__ +from sphinx.application import Sphinx +from myst_napoleon.docstring import GoogleDocstring, NumpyDocstring +from sphinx.util import inspect + + +class Config: + """Sphinx napoleon extension settings in `conf.py`. + + Listed below are all the settings used by napoleon and their default + values. These settings can be changed in the Sphinx `conf.py` file. Make + sure that "myst_napoleon" is enabled in `conf.py`:: + + # conf.py + + # Add any Sphinx extension module names here, as strings + extensions = ['myst_napoleon'] + + # Napoleon settings + napoleon_google_docstring = True + napoleon_numpy_docstring = True + napoleon_include_init_with_doc = False + napoleon_include_private_with_doc = False + napoleon_include_special_with_doc = False + napoleon_use_admonition_for_examples = False + napoleon_use_admonition_for_notes = False + napoleon_use_admonition_for_references = False + napoleon_use_ivar = False + napoleon_use_param = True + napoleon_use_rtype = True + napoleon_use_keyword = True + napoleon_preprocess_types = False + napoleon_type_aliases = None + napoleon_custom_sections = None + napoleon_attr_annotations = True + + .. _Google style: + https://google.github.io/styleguide/pyguide.html + .. _NumPy style: + https://numpydoc.readthedocs.io/en/latest/format.html#docstring-standard + + Attributes + ---------- + napoleon_google_docstring : :obj:`bool` (Defaults to True) + True to parse `Google style`_ docstrings. False to disable support + for Google style docstrings. + napoleon_numpy_docstring : :obj:`bool` (Defaults to True) + True to parse `NumPy style`_ docstrings. False to disable support + for NumPy style docstrings. + napoleon_include_init_with_doc : :obj:`bool` (Defaults to False) + True to list ``__init___`` docstrings separately from the class + docstring. False to fall back to Sphinx's default behavior, which + considers the ``__init___`` docstring as part of the class + documentation. + + **If True**:: + + def __init__(self): + \"\"\" + This will be included in the docs because it has a docstring + \"\"\" + + def __init__(self): + # This will NOT be included in the docs + + napoleon_include_private_with_doc : :obj:`bool` (Defaults to False) + True to include private members (like ``_membername``) with docstrings + in the documentation. False to fall back to Sphinx's default behavior. + + **If True**:: + + def _included(self): + \"\"\" + This will be included in the docs because it has a docstring + \"\"\" + pass + + def _skipped(self): + # This will NOT be included in the docs + pass + + napoleon_include_special_with_doc : :obj:`bool` (Defaults to False) + True to include special members (like ``__membername__``) with + docstrings in the documentation. False to fall back to Sphinx's + default behavior. + + **If True**:: + + def __str__(self): + \"\"\" + This will be included in the docs because it has a docstring + \"\"\" + return unicode(self).encode('utf-8') + + def __unicode__(self): + # This will NOT be included in the docs + return unicode(self.__class__.__name__) + + napoleon_use_admonition_for_examples : :obj:`bool` (Defaults to False) + True to use the ``.. admonition::`` directive for the **Example** and + **Examples** sections. False to use the ``.. rubric::`` directive + instead. One may look better than the other depending on what HTML + theme is used. + + This `NumPy style`_ snippet will be converted as follows:: + + Example + ------- + This is just a quick example + + **If True**:: + + .. admonition:: Example + + This is just a quick example + + **If False**:: + + .. rubric:: Example + + This is just a quick example + + napoleon_use_admonition_for_notes : :obj:`bool` (Defaults to False) + True to use the ``.. admonition::`` directive for **Notes** sections. + False to use the ``.. rubric::`` directive instead. + + Note + ---- + The singular **Note** section will always be converted to a + ``.. note::`` directive. + + See Also + -------- + :attr:`napoleon_use_admonition_for_examples` + + napoleon_use_admonition_for_references : :obj:`bool` (Defaults to False) + True to use the ``.. admonition::`` directive for **References** + sections. False to use the ``.. rubric::`` directive instead. + + See Also + -------- + :attr:`napoleon_use_admonition_for_examples` + + napoleon_use_ivar : :obj:`bool` (Defaults to False) + True to use the ``:ivar:`` role for instance variables. False to use + the ``.. attribute::`` directive instead. + + This `NumPy style`_ snippet will be converted as follows:: + + Attributes + ---------- + attr1 : int + Description of `attr1` + + **If True**:: + + :ivar attr1: Description of `attr1` + :vartype attr1: int + + **If False**:: + + .. attribute:: attr1 + + Description of `attr1` + + :type: int + + napoleon_use_param : :obj:`bool` (Defaults to True) + True to use a ``:param:`` role for each function parameter. False to + use a single ``:parameters:`` role for all the parameters. + + This `NumPy style`_ snippet will be converted as follows:: + + Parameters + ---------- + arg1 : str + Description of `arg1` + arg2 : int, optional + Description of `arg2`, defaults to 0 + + **If True**:: + + :param arg1: Description of `arg1` + :type arg1: str + :param arg2: Description of `arg2`, defaults to 0 + :type arg2: int, optional + + **If False**:: + + :parameters: * **arg1** (*str*) -- + Description of `arg1` + * **arg2** (*int, optional*) -- + Description of `arg2`, defaults to 0 + + napoleon_use_keyword : :obj:`bool` (Defaults to True) + True to use a ``:keyword:`` role for each function keyword argument. + False to use a single ``:keyword arguments:`` role for all the + keywords. + + This behaves similarly to :attr:`napoleon_use_param`. Note unlike + docutils, ``:keyword:`` and ``:param:`` will not be treated the same + way - there will be a separate "Keyword Arguments" section, rendered + in the same fashion as "Parameters" section (type links created if + possible) + + See Also + -------- + :attr:`napoleon_use_param` + + napoleon_use_rtype : :obj:`bool` (Defaults to True) + True to use the ``:rtype:`` role for the return type. False to output + the return type inline with the description. + + This `NumPy style`_ snippet will be converted as follows:: + + Returns + ------- + bool + True if successful, False otherwise + + **If True**:: + + :returns: True if successful, False otherwise + :rtype: bool + + **If False**:: + + :returns: *bool* -- True if successful, False otherwise + + napoleon_preprocess_types : :obj:`bool` (Defaults to False) + Enable the type preprocessor. + + napoleon_type_aliases : :obj:`dict` (Defaults to None) + Add a mapping of strings to string, translating types in numpy + style docstrings. Only works if ``napoleon_preprocess_types = True``. + + napoleon_custom_sections : :obj:`list` (Defaults to None) + Add a list of custom sections to include, expanding the list of parsed sections. + + The entries can either be strings or tuples, depending on the intention: + * To create a custom "generic" section, just pass a string. + * To create an alias for an existing section, pass a tuple containing the + alias name and the original, in that order. + * To create a custom section that displays like the parameters or returns + section, pass a tuple containing the custom section name and a string + value, "params_style" or "returns_style". + + If an entry is just a string, it is interpreted as a header for a generic + section. If the entry is a tuple/list/indexed container, the first entry + is the name of the section, the second is the section key to emulate. If the + second entry value is "params_style" or "returns_style", the custom section + will be displayed like the parameters section or returns section. + + napoleon_attr_annotations : :obj:`bool` (Defaults to True) + Use the type annotations of class attributes that are documented in the docstring + but do not have a type in the docstring. + + """ + _config_values = { + 'napoleon_google_docstring': (True, 'env'), + 'napoleon_numpy_docstring': (True, 'env'), + 'napoleon_include_init_with_doc': (False, 'env'), + 'napoleon_include_private_with_doc': (False, 'env'), + 'napoleon_include_special_with_doc': (False, 'env'), + 'napoleon_use_admonition_for_examples': (False, 'env'), + 'napoleon_use_admonition_for_notes': (False, 'env'), + 'napoleon_use_admonition_for_references': (False, 'env'), + 'napoleon_use_ivar': (False, 'env'), + 'napoleon_use_param': (True, 'env'), + 'napoleon_use_rtype': (True, 'env'), + 'napoleon_use_keyword': (True, 'env'), + 'napoleon_preprocess_types': (False, 'env'), + 'napoleon_type_aliases': (None, 'env'), + 'napoleon_custom_sections': (None, 'env'), + 'napoleon_attr_annotations': (True, 'env'), + } + + def __init__(self, **settings: Any) -> None: + for name, (default, _rebuild) in self._config_values.items(): + setattr(self, name, default) + for name, value in settings.items(): + setattr(self, name, value) + + +def setup(app: Sphinx) -> Dict[str, Any]: + """Sphinx extension setup function. + + When the extension is loaded, Sphinx imports this module and executes + the ``setup()`` function, which in turn notifies Sphinx of everything + the extension offers. + + Parameters + ---------- + app : sphinx.application.Sphinx + Application object representing the Sphinx process + + See Also + -------- + `The Sphinx documentation on Extensions + `_ + + `The Extension Tutorial `_ + + `The Extension API `_ + + """ + if not isinstance(app, Sphinx): + # probably called by tests + return {'version': __version__, 'parallel_read_safe': True} + + _patch_python_domain() + + app.setup_extension('sphinx.ext.autodoc') + app.connect('autodoc-process-docstring', _process_docstring) + app.connect('autodoc-skip-member', _skip_member) + + for name, (default, rebuild) in Config._config_values.items(): + app.add_config_value(name, default, rebuild) + return {'version': __version__, 'parallel_read_safe': True} + + +def _patch_python_domain() -> None: + try: + from sphinx.domains.python import PyTypedField + except ImportError: + pass + else: + import sphinx.domains.python + from sphinx.locale import _ + for doc_field in sphinx.domains.python.PyObject.doc_field_types: + if doc_field.name == 'parameter': + doc_field.names = ('param', 'parameter', 'arg', 'argument') + break + sphinx.domains.python.PyObject.doc_field_types.append( + PyTypedField('keyword', label=_('Keyword Arguments'), + names=('keyword', 'kwarg', 'kwparam'), + typerolename='obj', typenames=('paramtype', 'kwtype'), + can_collapse=True)) + + +def _process_docstring(app: Sphinx, what: str, name: str, obj: Any, + options: Any, lines: List[str]) -> None: + """Process the docstring for a given python object. + + Called when autodoc has read and processed a docstring. `lines` is a list + of docstring lines that `_process_docstring` modifies in place to change + what Sphinx outputs. + + The following settings in conf.py control what styles of docstrings will + be parsed: + + * ``napoleon_google_docstring`` -- parse Google style docstrings + * ``napoleon_numpy_docstring`` -- parse NumPy style docstrings + + Parameters + ---------- + app : sphinx.application.Sphinx + Application object representing the Sphinx process. + what : str + A string specifying the type of the object to which the docstring + belongs. Valid values: "module", "class", "exception", "function", + "method", "attribute". + name : str + The fully qualified name of the object. + obj : module, class, exception, function, method, or attribute + The object to which the docstring belongs. + options : sphinx.ext.autodoc.Options + The options given to the directive: an object with attributes + inherited_members, undoc_members, show_inheritance and noindex that + are True if the flag option of same name was given to the auto + directive. + lines : list of str + The lines of the docstring, see above. + + .. note:: `lines` is modified *in place* + + """ + result_lines = lines + docstring: GoogleDocstring = None + if app.config.napoleon_numpy_docstring: + docstring = NumpyDocstring(result_lines, app.config, app, what, name, + obj, options) + result_lines = docstring.lines() + if app.config.napoleon_google_docstring: + docstring = GoogleDocstring(result_lines, app.config, app, what, name, + obj, options) + result_lines = docstring.lines() + lines[:] = result_lines[:] + + +def _skip_member(app: Sphinx, what: str, name: str, obj: Any, + skip: bool, options: Any) -> bool: + """Determine if private and special class members are included in docs. + + The following settings in conf.py determine if private and special class + members or init methods are included in the generated documentation: + + * ``napoleon_include_init_with_doc`` -- + include init methods if they have docstrings + * ``napoleon_include_private_with_doc`` -- + include private members if they have docstrings + * ``napoleon_include_special_with_doc`` -- + include special members if they have docstrings + + Parameters + ---------- + app : sphinx.application.Sphinx + Application object representing the Sphinx process + what : str + A string specifying the type of the object to which the member + belongs. Valid values: "module", "class", "exception", "function", + "method", "attribute". + name : str + The name of the member. + obj : module, class, exception, function, method, or attribute. + For example, if the member is the __init__ method of class A, then + `obj` will be `A.__init__`. + skip : bool + A boolean indicating if autodoc will skip this member if `_skip_member` + does not override the decision + options : sphinx.ext.autodoc.Options + The options given to the directive: an object with attributes + inherited_members, undoc_members, show_inheritance and noindex that + are True if the flag option of same name was given to the auto + directive. + + Returns + ------- + bool + True if the member should be skipped during creation of the docs, + False if it should be included in the docs. + + """ + has_doc = getattr(obj, '__doc__', False) + is_member = what in ('class', 'exception', 'module') + if name != '__weakref__' and has_doc and is_member: + cls_is_owner = False + if what in ('class', 'exception'): + qualname = getattr(obj, '__qualname__', '') + cls_path, _, _ = qualname.rpartition('.') + if cls_path: + try: + if '.' in cls_path: + import functools + import importlib + + mod = importlib.import_module(obj.__module__) + mod_path = cls_path.split('.') + cls = functools.reduce(getattr, mod_path, mod) + else: + cls = inspect.unwrap(obj).__globals__[cls_path] + except Exception: + cls_is_owner = False + else: + cls_is_owner = (cls and hasattr(cls, name) and # type: ignore + name in cls.__dict__) + else: + cls_is_owner = False + + if what == 'module' or cls_is_owner: + is_init = (name == '__init__') + is_special = (not is_init and name.startswith('__') and + name.endswith('__')) + is_private = (not is_init and not is_special and + name.startswith('_')) + inc_init = app.config.napoleon_include_init_with_doc + inc_special = app.config.napoleon_include_special_with_doc + inc_private = app.config.napoleon_include_private_with_doc + if ((is_special and inc_special) or + (is_private and inc_private) or + (is_init and inc_init)): + return False + return None diff --git a/tools/docs/extensions/myst_napoleon/docstring.py b/tools/docs/extensions/myst_napoleon/docstring.py new file mode 100644 index 00000000..f80b2b8c --- /dev/null +++ b/tools/docs/extensions/myst_napoleon/docstring.py @@ -0,0 +1,1357 @@ +"""Classes for docstring parsing and formatting.""" +# This code is copied from `sphinx.ext.napoleon` v5.1.1. Any changes have +# been labelled with `jmontalt`. + +import collections +import inspect +import re +import warnings +from functools import partial +from typing import Any, Callable, Dict, List, Tuple, Type, Union + +from sphinx.application import Sphinx +from sphinx.config import Config as SphinxConfig +from sphinx.deprecation import RemovedInSphinx60Warning +from sphinx.locale import _, __ +from sphinx.util import logging +from sphinx.util.inspect import stringify_annotation +from sphinx.util.typing import get_type_hints + +logger = logging.getLogger(__name__) + +_directive_regex = re.compile(r'\.\. \S+::') +_google_section_regex = re.compile(r'^(\s|\w)+:\s*$') +_google_typed_arg_regex = re.compile(r'(.+?)\(\s*(.*[^\s]+)\s*\)') +_numpy_section_regex = re.compile(r'^[=\-`:\'"~^_*+#<>]{2,}\s*$') +_single_colon_regex = re.compile(r'(?\()?' + r'(\d+|#|[ivxlcdm]+|[IVXLCDM]+|[a-zA-Z])' + r'(?(paren)\)|\.)(\s+\S|\s*$)') +_token_regex = re.compile( + r"(,\sor\s|\sor\s|\sof\s|:\s|\sto\s|,\sand\s|\sand\s|,\s" + r"|[{]|[}]" + r'|"(?:\\"|[^"])*"' + r"|'(?:\\'|[^'])*')" +) +_default_regex = re.compile( + r"^default[^_0-9A-Za-z].*$", +) +_SINGLETONS = ("None", "True", "False", "Ellipsis") + + +class Deque(collections.deque): + """ + A subclass of deque that mimics ``pockets.iterators.modify_iter``. + + The `.Deque.get` and `.Deque.next` methods are added. + """ + + sentinel = object() + + def get(self, n: int) -> Any: + """ + Return the nth element of the stack, or ``self.sentinel`` if n is + greater than the stack size. + """ + return self[n] if n < len(self) else self.sentinel + + def next(self) -> Any: + if self: + return super().popleft() + else: + raise StopIteration + + +def _convert_type_spec(_type: str, translations: Dict[str, str] = {}) -> str: + """Convert type specification to reference in reST.""" + if _type in translations: + return translations[_type] + else: + if _type == 'None': + return ':obj:`None`' + else: + return ':class:`%s`' % _type + + return _type + + +class GoogleDocstring: + """Convert Google style docstrings to reStructuredText. + + Parameters + ---------- + docstring : :obj:`str` or :obj:`list` of :obj:`str` + The docstring to parse, given either as a string or split into + individual lines. + config: :obj:`myst_napoleon.Config` or :obj:`sphinx.config.Config` + The configuration settings to use. If not given, defaults to the + config object on `app`; or if `app` is not given defaults to the + a new :class:`myst_napoleon.Config` object. + + + Other Parameters + ---------------- + app : :class:`sphinx.application.Sphinx`, optional + Application object representing the Sphinx process. + what : :obj:`str`, optional + A string specifying the type of the object to which the docstring + belongs. Valid values: "module", "class", "exception", "function", + "method", "attribute". + name : :obj:`str`, optional + The fully qualified name of the object. + obj : module, class, exception, function, method, or attribute + The object to which the docstring belongs. + options : :class:`sphinx.ext.autodoc.Options`, optional + The options given to the directive: an object with attributes + inherited_members, undoc_members, show_inheritance and noindex that + are True if the flag option of same name was given to the auto + directive. + + + Example + ------- + >>> from myst_napoleon import Config + >>> config = Config(napoleon_use_param=True, napoleon_use_rtype=True) + >>> docstring = '''One line summary. + ... + ... Extended description. + ... + ... Args: + ... arg1(int): Description of `arg1` + ... arg2(str): Description of `arg2` + ... Returns: + ... str: Description of return value. + ... ''' + >>> print(GoogleDocstring(docstring, config)) + One line summary. + + Extended description. + + :param arg1: Description of `arg1` + :type arg1: int + :param arg2: Description of `arg2` + :type arg2: str + + :returns: Description of return value. + :rtype: str + + + """ + + _name_rgx = re.compile(r"^\s*((?::(?P\S+):)?`(?P~?[a-zA-Z0-9_.-]+)`|" + r" (?P~?[a-zA-Z0-9_.-]+))\s*", re.X) + + def __init__(self, docstring: Union[str, List[str]], config: SphinxConfig = None, + app: Sphinx = None, what: str = '', name: str = '', + obj: Any = None, options: Any = None) -> None: + self._config = config + self._app = app + + if not self._config: + from myst_napoleon import Config + self._config = self._app.config if self._app else Config() # type: ignore + + if not what: + if inspect.isclass(obj): + what = 'class' + elif inspect.ismodule(obj): + what = 'module' + elif callable(obj): + what = 'function' + else: + what = 'object' + + self._what = what + self._name = name + self._obj = obj + self._opt = options + if isinstance(docstring, str): + lines = docstring.splitlines() + else: + lines = docstring + self._lines = Deque(map(str.rstrip, lines)) + self._parsed_lines: List[str] = [] + self._is_in_section = False + self._section_indent = 0 + if not hasattr(self, '_directive_sections'): + self._directive_sections: List[str] = [] + if not hasattr(self, '_sections'): + self._sections: Dict[str, Callable] = { + 'args': self._parse_parameters_section, + 'arguments': self._parse_parameters_section, + 'attention': partial(self._parse_admonition, 'attention'), + 'attributes': self._parse_attributes_section, + 'caution': partial(self._parse_admonition, 'caution'), + 'danger': partial(self._parse_admonition, 'danger'), + 'error': partial(self._parse_admonition, 'error'), + 'example': self._parse_examples_section, + 'examples': self._parse_examples_section, + 'hint': partial(self._parse_admonition, 'hint'), + 'important': partial(self._parse_admonition, 'important'), + 'keyword args': self._parse_keyword_arguments_section, + 'keyword arguments': self._parse_keyword_arguments_section, + 'methods': self._parse_methods_section, + 'note': partial(self._parse_admonition, 'note'), + 'notes': self._parse_notes_section, + 'other parameters': self._parse_other_parameters_section, + 'parameters': self._parse_parameters_section, + 'receive': self._parse_receives_section, + 'receives': self._parse_receives_section, + 'return': self._parse_returns_section, + 'returns': self._parse_returns_section, + 'raise': self._parse_raises_section, + 'raises': self._parse_raises_section, + 'references': self._parse_references_section, + 'see also': self._parse_see_also_section, + 'tip': partial(self._parse_admonition, 'tip'), + 'todo': partial(self._parse_admonition, 'todo'), + 'warning': partial(self._parse_admonition, 'warning'), + 'warnings': partial(self._parse_admonition, 'warning'), + 'warn': self._parse_warns_section, + 'warns': self._parse_warns_section, + 'yield': self._parse_yields_section, + 'yields': self._parse_yields_section, + } + + self._load_custom_sections() + + self._parse() + + def __str__(self) -> str: + """Return the parsed docstring in reStructuredText format. + + Returns + ------- + unicode + Unicode version of the docstring. + + """ + return '\n'.join(self.lines()) + + def lines(self) -> List[str]: + """Return the parsed lines of the docstring in reStructuredText format. + + Returns + ------- + list(str) + The lines of the docstring in a list. + + """ + return self._parsed_lines + + def _consume_indented_block(self, indent: int = 1) -> List[str]: + lines = [] + line = self._lines.get(0) + while(not self._is_section_break() and + (not line or self._is_indented(line, indent))): + lines.append(self._lines.next()) + line = self._lines.get(0) + return lines + + def _consume_contiguous(self) -> List[str]: + lines = [] + while (self._lines and + self._lines.get(0) and + not self._is_section_header()): + lines.append(self._lines.next()) + return lines + + def _consume_empty(self) -> List[str]: + lines = [] + line = self._lines.get(0) + while self._lines and not line: + lines.append(self._lines.next()) + line = self._lines.get(0) + return lines + + def _consume_field(self, parse_type: bool = True, prefer_type: bool = False + ) -> Tuple[str, str, List[str]]: + line = self._lines.next() + + before, colon, after = self._partition_field_on_colon(line) + _name, _type, _desc = before, '', after + + if parse_type: + match = _google_typed_arg_regex.match(before) + if match: + _name = match.group(1).strip() + _type = match.group(2) + + _name = self._escape_args_and_kwargs(_name) + + if prefer_type and not _type: + _type, _name = _name, _type + + if _type and self._config.napoleon_preprocess_types: + _type = _convert_type_spec(_type, self._config.napoleon_type_aliases or {}) + + indent = self._get_indent(line) + 1 + _descs = [_desc] + self._dedent(self._consume_indented_block(indent)) + _descs = self.__class__(_descs, self._config).lines() + return _name, _type, _descs + + def _consume_fields(self, parse_type: bool = True, prefer_type: bool = False, + multiple: bool = False) -> List[Tuple[str, str, List[str]]]: + self._consume_empty() + fields = [] + while not self._is_section_break(): + _name, _type, _desc = self._consume_field(parse_type, prefer_type) + if multiple and _name: + for name in _name.split(","): + fields.append((name.strip(), _type, _desc)) + elif _name or _type or _desc: + fields.append((_name, _type, _desc,)) + return fields + + def _consume_inline_attribute(self) -> Tuple[str, List[str]]: + line = self._lines.next() + _type, colon, _desc = self._partition_field_on_colon(line) + if not colon or not _desc: + _type, _desc = _desc, _type + _desc += colon + _descs = [_desc] + self._dedent(self._consume_to_end()) + _descs = self.__class__(_descs, self._config).lines() + return _type, _descs + + def _consume_returns_section(self, preprocess_types: bool = False + ) -> List[Tuple[str, str, List[str]]]: + lines = self._dedent(self._consume_to_next_section()) + if lines: + before, colon, after = self._partition_field_on_colon(lines[0]) + _name, _type, _desc = '', '', lines + + if colon: + if after: + _desc = [after] + lines[1:] + else: + _desc = lines[1:] + + _type = before + + if (_type and preprocess_types and + self._config.napoleon_preprocess_types): + _type = _convert_type_spec(_type, self._config.napoleon_type_aliases or {}) + + _desc = self.__class__(_desc, self._config).lines() + return [(_name, _type, _desc,)] + else: + return [] + + def _consume_usage_section(self) -> List[str]: + lines = self._dedent(self._consume_to_next_section()) + return lines + + def _consume_section_header(self) -> str: + section = self._lines.next() + stripped_section = section.strip(':') + if stripped_section.lower() in self._sections: + section = stripped_section + return section + + def _consume_to_end(self) -> List[str]: + lines = [] + while self._lines: + lines.append(self._lines.next()) + return lines + + def _consume_to_next_section(self) -> List[str]: + self._consume_empty() + lines = [] + while not self._is_section_break(): + lines.append(self._lines.next()) + return lines + self._consume_empty() + + def _dedent(self, lines: List[str], full: bool = False) -> List[str]: + if full: + return [line.lstrip() for line in lines] + else: + min_indent = self._get_min_indent(lines) + return [line[min_indent:] for line in lines] + + def _escape_args_and_kwargs(self, name: str) -> str: + if name.endswith('_') and getattr(self._config, 'strip_signature_backslash', False): + name = name[:-1] + r'\_' + + if name[:2] == '**': + return r'\*\*' + name[2:] + elif name[:1] == '*': + return r'\*' + name[1:] + else: + return name + + def _fix_field_desc(self, desc: List[str]) -> List[str]: + if self._is_list(desc): + desc = [''] + desc + elif desc[0].endswith('::'): + desc_block = desc[1:] + indent = self._get_indent(desc[0]) + block_indent = self._get_initial_indent(desc_block) + if block_indent > indent: + desc = [''] + desc + else: + desc = ['', desc[0]] + self._indent(desc_block, 4) + return desc + + def _format_admonition(self, admonition: str, lines: List[str]) -> List[str]: + lines = self._strip_empty(lines) + if len(lines) == 1: + return ['.. %s:: %s' % (admonition, lines[0].strip()), ''] + elif lines: + lines = self._indent(self._dedent(lines), 3) + return ['.. %s::' % admonition, ''] + lines + [''] + else: + return ['.. %s::' % admonition, ''] + + def _format_block(self, prefix: str, lines: List[str], padding: str = None) -> List[str]: + if lines: + if padding is None: + padding = ' ' * len(prefix) + result_lines = [] + for i, line in enumerate(lines): + if i == 0: + result_lines.append((prefix + line).rstrip()) + elif line: + result_lines.append(padding + line) + else: + result_lines.append('') + return result_lines + else: + return [prefix] + + def _format_docutils_params(self, fields: List[Tuple[str, str, List[str]]], + field_role: str = 'param', type_role: str = 'type' + ) -> List[str]: + lines = [] + for _name, _type, _desc in fields: + _desc = self._strip_empty(_desc) + if any(_desc): + _desc = self._fix_field_desc(_desc) + field = ':%s %s: ' % (field_role, _name) + lines.extend(self._format_block(field, _desc)) + else: + lines.append(':%s %s:' % (field_role, _name)) + + if _type: + lines.append(':%s %s: %s' % (type_role, _name, _type)) + return lines + [''] + + def _format_field(self, _name: str, _type: str, _desc: List[str]) -> List[str]: + _desc = self._strip_empty(_desc) + has_desc = any(_desc) + separator = ' -- ' if has_desc else '' + if _name: + if _type: + if '`' in _type: + field = '**%s** (%s)%s' % (_name, _type, separator) + else: + field = '**%s** (*%s*)%s' % (_name, _type, separator) + else: + field = '**%s**%s' % (_name, separator) + elif _type: + if '`' in _type: + field = '%s%s' % (_type, separator) + else: + field = '*%s*%s' % (_type, separator) + else: + field = '' + + if has_desc: + _desc = self._fix_field_desc(_desc) + if _desc[0]: + return [field + _desc[0]] + _desc[1:] + else: + return [field] + _desc + else: + return [field] + + def _format_fields(self, field_type: str, fields: List[Tuple[str, str, List[str]]] + ) -> List[str]: + field_type = ':%s:' % field_type.strip() + padding = ' ' * len(field_type) + multi = len(fields) > 1 + lines: List[str] = [] + for _name, _type, _desc in fields: + field = self._format_field(_name, _type, _desc) + if multi: + if lines: + lines.extend(self._format_block(padding + ' * ', field)) + else: + lines.extend(self._format_block(field_type + ' * ', field)) + else: + lines.extend(self._format_block(field_type + ' ', field)) + if lines and lines[-1]: + lines.append('') + return lines + + def _get_current_indent(self, peek_ahead: int = 0) -> int: + line = self._lines.get(peek_ahead) + while line is not self._lines.sentinel: + if line: + return self._get_indent(line) + peek_ahead += 1 + line = self._lines.get(peek_ahead) + return 0 + + def _get_indent(self, line: str) -> int: + for i, s in enumerate(line): + if not s.isspace(): + return i + return len(line) + + def _get_initial_indent(self, lines: List[str]) -> int: + for line in lines: + if line: + return self._get_indent(line) + return 0 + + def _get_min_indent(self, lines: List[str]) -> int: + min_indent = None + for line in lines: + if line: + indent = self._get_indent(line) + if min_indent is None: + min_indent = indent + elif indent < min_indent: + min_indent = indent + return min_indent or 0 + + def _indent(self, lines: List[str], n: int = 4) -> List[str]: + return [(' ' * n) + line for line in lines] + + def _is_indented(self, line: str, indent: int = 1) -> bool: + for i, s in enumerate(line): + if i >= indent: + return True + elif not s.isspace(): + return False + return False + + def _is_list(self, lines: List[str]) -> bool: + if not lines: + return False + if _bullet_list_regex.match(lines[0]): + return True + if _enumerated_list_regex.match(lines[0]): + return True + if len(lines) < 2 or lines[0].endswith('::'): + return False + indent = self._get_indent(lines[0]) + next_indent = indent + for line in lines[1:]: + if line: + next_indent = self._get_indent(line) + break + return next_indent > indent + + def _is_section_header(self) -> bool: + section = self._lines.get(0).lower() + match = _google_section_regex.match(section) + if match and section.strip(':') in self._sections: + header_indent = self._get_indent(section) + section_indent = self._get_current_indent(peek_ahead=1) + return section_indent > header_indent + elif self._directive_sections: + if _directive_regex.match(section): + for directive_section in self._directive_sections: + if section.startswith(directive_section): + return True + return False + + def _is_section_break(self) -> bool: + line = self._lines.get(0) + return (not self._lines or + self._is_section_header() or + (self._is_in_section and + line and + not self._is_indented(line, self._section_indent))) + + def _load_custom_sections(self) -> None: + if self._config.napoleon_custom_sections is not None: + for entry in self._config.napoleon_custom_sections: + if isinstance(entry, str): + # if entry is just a label, add to sections list, + # using generic section logic. + self._sections[entry.lower()] = self._parse_custom_generic_section + else: + # otherwise, assume entry is container; + if entry[1] == "params_style": + self._sections[entry[0].lower()] = \ + self._parse_custom_params_style_section + elif entry[1] == "returns_style": + self._sections[entry[0].lower()] = \ + self._parse_custom_returns_style_section + else: + # [0] is new section, [1] is the section to alias. + # in the case of key mismatch, just handle as generic section. + self._sections[entry[0].lower()] = \ + self._sections.get(entry[1].lower(), + self._parse_custom_generic_section) + + def _parse(self) -> None: + self._parsed_lines = self._consume_empty() + + if self._name and self._what in ('attribute', 'data', 'property'): + # Implicit stop using StopIteration no longer allowed in + # Python 3.7; see PEP 479 + res: List[str] = [] + try: + res = self._parse_attribute_docstring() + except StopIteration: + pass + self._parsed_lines.extend(res) + return + + while self._lines: + if self._is_section_header(): + try: + section = self._consume_section_header() + self._is_in_section = True + self._section_indent = self._get_current_indent() + if _directive_regex.match(section): + lines = [section] + self._consume_to_next_section() + else: + lines = self._sections[section.lower()](section) + finally: + self._is_in_section = False + self._section_indent = 0 + else: + if not self._parsed_lines: + lines = self._consume_contiguous() + self._consume_empty() + else: + lines = self._consume_to_next_section() + self._parsed_lines.extend(lines) + + def _parse_admonition(self, admonition: str, section: str) -> List[str]: + # type (str, str) -> List[str] + lines = self._consume_to_next_section() + return self._format_admonition(admonition, lines) + + def _parse_attribute_docstring(self) -> List[str]: + _type, _desc = self._consume_inline_attribute() + lines = self._format_field('', '', _desc) + if _type: + lines.extend(['', ':type: %s' % _type]) + return lines + + def _parse_attributes_section(self, section: str) -> List[str]: + lines = [] + for _name, _type, _desc in self._consume_fields(): + if not _type: + _type = self._lookup_annotation(_name) + if self._config.napoleon_use_ivar: + field = ':ivar %s: ' % _name + lines.extend(self._format_block(field, _desc)) + if _type: + lines.append(':vartype %s: %s' % (_name, _type)) + else: + lines.append('.. attribute:: ' + _name) + if self._opt and 'noindex' in self._opt: + lines.append(' :noindex:') + lines.append('') + + fields = self._format_field('', '', _desc) + lines.extend(self._indent(fields, 3)) + if _type: + lines.append('') + lines.extend(self._indent([':type: %s' % _type], 3)) + lines.append('') + if self._config.napoleon_use_ivar: + lines.append('') + return lines + + def _parse_examples_section(self, section: str) -> List[str]: + labels = { + 'example': _('Example'), + 'examples': _('Examples'), + } + use_admonition = self._config.napoleon_use_admonition_for_examples + label = labels.get(section.lower(), section) + return self._parse_generic_section(label, use_admonition) + + def _parse_custom_generic_section(self, section: str) -> List[str]: + # for now, no admonition for simple custom sections + return self._parse_generic_section(section, False) + + def _parse_custom_params_style_section(self, section: str) -> List[str]: + return self._format_fields(section, self._consume_fields()) + + def _parse_custom_returns_style_section(self, section: str) -> List[str]: + fields = self._consume_returns_section(preprocess_types=True) + return self._format_fields(section, fields) + + def _parse_usage_section(self, section: str) -> List[str]: + header = ['.. rubric:: Usage:', ''] + block = ['.. code-block:: python', ''] + lines = self._consume_usage_section() + lines = self._indent(lines, 3) + return header + block + lines + [''] + + def _parse_generic_section(self, section: str, use_admonition: bool) -> List[str]: + lines = self._strip_empty(self._consume_to_next_section()) + lines = self._dedent(lines) + if use_admonition: + # jmontalt: use MyST syntax instead of RST. + header = '```{admonition} %s' % section + # lines = self._indent(lines, 3) + lines.append('```') + else: + # jmontalt: use MyST syntax instead of RST. + header = '```{rubric} %s' % section + lines = ['```'] + lines + if lines: + return [header, ''] + lines + [''] + else: + return [header, ''] + + def _parse_keyword_arguments_section(self, section: str) -> List[str]: + fields = self._consume_fields() + if self._config.napoleon_use_keyword: + return self._format_docutils_params( + fields, + field_role="keyword", + type_role="kwtype") + else: + return self._format_fields(_('Keyword Arguments'), fields) + + def _parse_methods_section(self, section: str) -> List[str]: + lines: List[str] = [] + for _name, _type, _desc in self._consume_fields(parse_type=False): + lines.append('.. method:: %s' % _name) + if self._opt and 'noindex' in self._opt: + lines.append(' :noindex:') + if _desc: + lines.extend([''] + self._indent(_desc, 3)) + lines.append('') + return lines + + def _parse_notes_section(self, section: str) -> List[str]: + use_admonition = self._config.napoleon_use_admonition_for_notes + return self._parse_generic_section(_('Notes'), use_admonition) + + def _parse_other_parameters_section(self, section: str) -> List[str]: + if self._config.napoleon_use_param: + # Allow to declare multiple parameters at once (ex: x, y: int) + fields = self._consume_fields(multiple=True) + return self._format_docutils_params(fields) + else: + fields = self._consume_fields() + return self._format_fields(_('Other Parameters'), fields) + + def _parse_parameters_section(self, section: str) -> List[str]: + if self._config.napoleon_use_param: + # Allow to declare multiple parameters at once (ex: x, y: int) + fields = self._consume_fields(multiple=True) + return self._format_docutils_params(fields) + else: + fields = self._consume_fields() + return self._format_fields(_('Parameters'), fields) + + def _parse_raises_section(self, section: str) -> List[str]: + fields = self._consume_fields(parse_type=False, prefer_type=True) + lines: List[str] = [] + for _name, _type, _desc in fields: + m = self._name_rgx.match(_type) + if m and m.group('name'): + _type = m.group('name') + elif _xref_regex.match(_type): + pos = _type.find('`') + _type = _type[pos + 1:-1] + _type = ' ' + _type if _type else '' + _desc = self._strip_empty(_desc) + _descs = ' ' + '\n '.join(_desc) if any(_desc) else '' + lines.append(':raises%s:%s' % (_type, _descs)) + if lines: + lines.append('') + return lines + + def _parse_receives_section(self, section: str) -> List[str]: + if self._config.napoleon_use_param: + # Allow to declare multiple parameters at once (ex: x, y: int) + fields = self._consume_fields(multiple=True) + return self._format_docutils_params(fields) + else: + fields = self._consume_fields() + return self._format_fields(_('Receives'), fields) + + def _parse_references_section(self, section: str) -> List[str]: + use_admonition = self._config.napoleon_use_admonition_for_references + return self._parse_generic_section(_('References'), use_admonition) + + def _parse_returns_section(self, section: str) -> List[str]: + fields = self._consume_returns_section() + multi = len(fields) > 1 + use_rtype = False if multi else self._config.napoleon_use_rtype + lines: List[str] = [] + + for _name, _type, _desc in fields: + if use_rtype: + field = self._format_field(_name, '', _desc) + else: + field = self._format_field(_name, _type, _desc) + + if multi: + if lines: + lines.extend(self._format_block(' * ', field)) + else: + lines.extend(self._format_block(':returns: * ', field)) + else: + if any(field): # only add :returns: if there's something to say + lines.extend(self._format_block(':returns: ', field)) + if _type and use_rtype: + lines.extend([':rtype: %s' % _type, '']) + if lines and lines[-1]: + lines.append('') + return lines + + def _parse_see_also_section(self, section: str) -> List[str]: + return self._parse_admonition('seealso', section) + + def _parse_warns_section(self, section: str) -> List[str]: + return self._format_fields(_('Warns'), self._consume_fields()) + + def _parse_yields_section(self, section: str) -> List[str]: + fields = self._consume_returns_section(preprocess_types=True) + return self._format_fields(_('Yields'), fields) + + def _partition_field_on_colon(self, line: str) -> Tuple[str, str, str]: + before_colon = [] + after_colon = [] + colon = '' + found_colon = False + for i, source in enumerate(_xref_or_code_regex.split(line)): + if found_colon: + after_colon.append(source) + else: + m = _single_colon_regex.search(source) + if (i % 2) == 0 and m: + found_colon = True + colon = source[m.start(): m.end()] + before_colon.append(source[:m.start()]) + after_colon.append(source[m.end():]) + else: + before_colon.append(source) + + return ("".join(before_colon).strip(), + colon, + "".join(after_colon).strip()) + + def _qualify_name(self, attr_name: str, klass: Type) -> str: + warnings.warn('%s._qualify_name() is deprecated.' % + self.__class__.__name__, RemovedInSphinx60Warning) + if klass and '.' not in attr_name: + if attr_name.startswith('~'): + attr_name = attr_name[1:] + try: + q = klass.__qualname__ + except AttributeError: + q = klass.__name__ + return '~%s.%s' % (q, attr_name) + return attr_name + + def _strip_empty(self, lines: List[str]) -> List[str]: + if lines: + start = -1 + for i, line in enumerate(lines): + if line: + start = i + break + if start == -1: + lines = [] + end = -1 + for i in reversed(range(len(lines))): + line = lines[i] + if line: + end = i + break + if start > 0 or end + 1 < len(lines): + lines = lines[start:end + 1] + return lines + + def _lookup_annotation(self, _name: str) -> str: + if self._config.napoleon_attr_annotations: + if self._what in ("module", "class", "exception") and self._obj: + # cache the class annotations + if not hasattr(self, "_annotations"): + localns = getattr(self._config, "autodoc_type_aliases", {}) + localns.update(getattr( + self._config, "napoleon_type_aliases", {} + ) or {}) + self._annotations = get_type_hints(self._obj, None, localns) + if _name in self._annotations: + return stringify_annotation(self._annotations[_name]) + # No annotation found + return "" + + +def _recombine_set_tokens(tokens: List[str]) -> List[str]: + token_queue = collections.deque(tokens) + keywords = ("optional", "default") + + def takewhile_set(tokens): + open_braces = 0 + previous_token = None + while True: + try: + token = tokens.popleft() + except IndexError: + break + + if token == ", ": + previous_token = token + continue + + if not token.strip(): + continue + + if token in keywords: + tokens.appendleft(token) + if previous_token is not None: + tokens.appendleft(previous_token) + break + + if previous_token is not None: + yield previous_token + previous_token = None + + if token == "{": + open_braces += 1 + elif token == "}": + open_braces -= 1 + + yield token + + if open_braces == 0: + break + + def combine_set(tokens): + while True: + try: + token = tokens.popleft() + except IndexError: + break + + if token == "{": + tokens.appendleft("{") + yield "".join(takewhile_set(tokens)) + else: + yield token + + return list(combine_set(token_queue)) + + +def _tokenize_type_spec(spec: str) -> List[str]: + def postprocess(item): + if _default_regex.match(item): + default = item[:7] + # can't be separated by anything other than a single space + # for now + other = item[8:] + + return [default, " ", other] + else: + return [item] + + tokens = [ + item + for raw_token in _token_regex.split(spec) + for item in postprocess(raw_token) + if item + ] + return tokens + + +def _token_type(token: str, location: str = None) -> str: + def is_numeric(token): + try: + # use complex to make sure every numeric value is detected as literal + complex(token) + except ValueError: + return False + else: + return True + + if token.startswith(" ") or token.endswith(" "): + type_ = "delimiter" + elif ( + is_numeric(token) or + (token.startswith("{") and token.endswith("}")) or + (token.startswith('"') and token.endswith('"')) or + (token.startswith("'") and token.endswith("'")) + ): + type_ = "literal" + elif token.startswith("{"): + logger.warning( + __("invalid value set (missing closing brace): %s"), + token, + location=location, + ) + type_ = "literal" + elif token.endswith("}"): + logger.warning( + __("invalid value set (missing opening brace): %s"), + token, + location=location, + ) + type_ = "literal" + elif token.startswith("'") or token.startswith('"'): + logger.warning( + __("malformed string literal (missing closing quote): %s"), + token, + location=location, + ) + type_ = "literal" + elif token.endswith("'") or token.endswith('"'): + logger.warning( + __("malformed string literal (missing opening quote): %s"), + token, + location=location, + ) + type_ = "literal" + elif token in ("optional", "default"): + # default is not a official keyword (yet) but supported by the + # reference implementation (numpydoc) and widely used + type_ = "control" + elif _xref_regex.match(token): + type_ = "reference" + else: + type_ = "obj" + + return type_ + + +def _convert_numpy_type_spec(_type: str, location: str = None, translations: dict = {}) -> str: + def convert_obj(obj, translations, default_translation): + translation = translations.get(obj, obj) + + # use :class: (the default) only if obj is not a standard singleton + if translation in _SINGLETONS and default_translation == ":class:`%s`": + default_translation = ":obj:`%s`" + elif translation == "..." and default_translation == ":class:`%s`": + # allow referencing the builtin ... + default_translation = ":obj:`%s `" + + if _xref_regex.match(translation) is None: + translation = default_translation % translation + + return translation + + tokens = _tokenize_type_spec(_type) + combined_tokens = _recombine_set_tokens(tokens) + types = [ + (token, _token_type(token, location)) + for token in combined_tokens + ] + + converters = { + "literal": lambda x: "``%s``" % x, + "obj": lambda x: convert_obj(x, translations, ":class:`%s`"), + "control": lambda x: "*%s*" % x, + "delimiter": lambda x: x, + "reference": lambda x: x, + } + + converted = "".join(converters.get(type_)(token) for token, type_ in types) + + return converted + + +class NumpyDocstring(GoogleDocstring): + """Convert NumPy style docstrings to reStructuredText. + + Parameters + ---------- + docstring : :obj:`str` or :obj:`list` of :obj:`str` + The docstring to parse, given either as a string or split into + individual lines. + config: :obj:`myst_napoleon.Config` or :obj:`sphinx.config.Config` + The configuration settings to use. If not given, defaults to the + config object on `app`; or if `app` is not given defaults to the + a new :class:`myst_napoleon.Config` object. + + + Other Parameters + ---------------- + app : :class:`sphinx.application.Sphinx`, optional + Application object representing the Sphinx process. + what : :obj:`str`, optional + A string specifying the type of the object to which the docstring + belongs. Valid values: "module", "class", "exception", "function", + "method", "attribute". + name : :obj:`str`, optional + The fully qualified name of the object. + obj : module, class, exception, function, method, or attribute + The object to which the docstring belongs. + options : :class:`sphinx.ext.autodoc.Options`, optional + The options given to the directive: an object with attributes + inherited_members, undoc_members, show_inheritance and noindex that + are True if the flag option of same name was given to the auto + directive. + + + Example + ------- + >>> from myst_napoleon import Config + >>> config = Config(napoleon_use_param=True, napoleon_use_rtype=True) + >>> docstring = '''One line summary. + ... + ... Extended description. + ... + ... Parameters + ... ---------- + ... arg1 : int + ... Description of `arg1` + ... arg2 : str + ... Description of `arg2` + ... Returns + ... ------- + ... str + ... Description of return value. + ... ''' + >>> print(NumpyDocstring(docstring, config)) + One line summary. + + Extended description. + + :param arg1: Description of `arg1` + :type arg1: int + :param arg2: Description of `arg2` + :type arg2: str + + :returns: Description of return value. + :rtype: str + + + Methods + ------- + __str__() + Return the parsed docstring in reStructuredText format. + + Returns + ------- + str + UTF-8 encoded version of the docstring. + + __unicode__() + Return the parsed docstring in reStructuredText format. + + Returns + ------- + unicode + Unicode version of the docstring. + + lines() + Return the parsed lines of the docstring in reStructuredText format. + + Returns + ------- + list(str) + The lines of the docstring in a list. + + """ + def __init__(self, docstring: Union[str, List[str]], config: SphinxConfig = None, + app: Sphinx = None, what: str = '', name: str = '', + obj: Any = None, options: Any = None) -> None: + self._directive_sections = ['.. index::'] + super().__init__(docstring, config, app, what, name, obj, options) + + def _get_location(self) -> str: + try: + filepath = inspect.getfile(self._obj) if self._obj is not None else None + except TypeError: + filepath = None + name = self._name + + if filepath is None and name is None: + return None + elif filepath is None: + filepath = "" + + return ":".join([filepath, "docstring of %s" % name]) + + def _escape_args_and_kwargs(self, name: str) -> str: + func = super()._escape_args_and_kwargs + + if ", " in name: + return ", ".join(func(param) for param in name.split(", ")) + else: + return func(name) + + def _consume_field(self, parse_type: bool = True, prefer_type: bool = False + ) -> Tuple[str, str, List[str]]: + line = self._lines.next() + if parse_type: + _name, _, _type = self._partition_field_on_colon(line) + else: + _name, _type = line, '' + _name, _type = _name.strip(), _type.strip() + _name = self._escape_args_and_kwargs(_name) + + if parse_type and not _type: + _type = self._lookup_annotation(_name) + + if prefer_type and not _type: + _type, _name = _name, _type + + if self._config.napoleon_preprocess_types: + _type = _convert_numpy_type_spec( + _type, + location=self._get_location(), + translations=self._config.napoleon_type_aliases or {}, + ) + + indent = self._get_indent(line) + 1 + _desc = self._dedent(self._consume_indented_block(indent)) + _desc = self.__class__(_desc, self._config).lines() + return _name, _type, _desc + + def _consume_returns_section(self, preprocess_types: bool = False + ) -> List[Tuple[str, str, List[str]]]: + return self._consume_fields(prefer_type=True) + + def _consume_section_header(self) -> str: + section = self._lines.next() + if not _directive_regex.match(section): + # Consume the header underline + self._lines.next() + return section + + def _is_section_break(self) -> bool: + line1, line2 = self._lines.get(0), self._lines.get(1) + return (not self._lines or + self._is_section_header() or + ['', ''] == [line1, line2] or + (self._is_in_section and + line1 and + not self._is_indented(line1, self._section_indent))) + + def _is_section_header(self) -> bool: + section, underline = self._lines.get(0), self._lines.get(1) + section = section.lower() + if section in self._sections and isinstance(underline, str): + return bool(_numpy_section_regex.match(underline)) + elif self._directive_sections: + if _directive_regex.match(section): + for directive_section in self._directive_sections: + if section.startswith(directive_section): + return True + return False + + def _parse_see_also_section(self, section: str) -> List[str]: + lines = self._consume_to_next_section() + try: + return self._parse_numpydoc_see_also_section(lines) + except ValueError: + return self._format_admonition('seealso', lines) + + def _parse_numpydoc_see_also_section(self, content: List[str]) -> List[str]: + """ + Derived from the NumpyDoc implementation of _parse_see_also. + + See Also + -------- + func_name : Descriptive text + continued text + another_func_name : Descriptive text + func_name1, func_name2, :meth:`func_name`, func_name3 + + """ + items = [] + + def parse_item_name(text: str) -> Tuple[str, str]: + """Match ':role:`name`' or 'name'""" + m = self._name_rgx.match(text) + if m: + g = m.groups() + if g[1] is None: + return g[3], None + else: + return g[2], g[1] + raise ValueError("%s is not a item name" % text) + + def push_item(name: str, rest: List[str]) -> None: + if not name: + return + name, role = parse_item_name(name) + items.append((name, list(rest), role)) + del rest[:] + + def translate(func, description, role): + translations = self._config.napoleon_type_aliases + if role is not None or not translations: + return func, description, role + + translated = translations.get(func, func) + match = self._name_rgx.match(translated) + if not match: + return translated, description, role + + groups = match.groupdict() + role = groups["role"] + new_func = groups["name"] or groups["name2"] + + return new_func, description, role + + current_func = None + rest: List[str] = [] + + for line in content: + if not line.strip(): + continue + + m = self._name_rgx.match(line) + if m and line[m.end():].strip().startswith(':'): + push_item(current_func, rest) + current_func, line = line[:m.end()], line[m.end():] + rest = [line.split(':', 1)[1].strip()] + if not rest[0]: + rest = [] + elif not line.startswith(' '): + push_item(current_func, rest) + current_func = None + if ',' in line: + for func in line.split(','): + if func.strip(): + push_item(func, []) + elif line.strip(): + current_func = line + elif current_func is not None: + rest.append(line.strip()) + push_item(current_func, rest) + + if not items: + return [] + + # apply type aliases + items = [ + translate(func, description, role) + for func, description, role in items + ] + + lines: List[str] = [] + last_had_desc = True + for name, desc, role in items: + if role: + link = ':%s:`%s`' % (role, name) + else: + link = ':obj:`%s`' % name + if desc or last_had_desc: + lines += [''] + lines += [link] + else: + lines[-1] += ", %s" % link + if desc: + lines += self._indent([' '.join(desc)]) + last_had_desc = True + else: + last_had_desc = False + lines += [''] + + return self._format_admonition('seealso', lines) diff --git a/tools/docs/extensions/myst_napoleon/iterators.py b/tools/docs/extensions/myst_napoleon/iterators.py new file mode 100644 index 00000000..6337ca99 --- /dev/null +++ b/tools/docs/extensions/myst_napoleon/iterators.py @@ -0,0 +1,235 @@ +"""A collection of helpful iterators.""" +# This code is copied from `sphinx.ext.napoleon` v5.1.1. Any changes have +# been labelled with `jmontalt`. + +import collections +import warnings +from typing import Any, Iterable, Optional + +from sphinx.deprecation import RemovedInSphinx70Warning + +warnings.warn('myst_napoleon.iterators is deprecated.', + RemovedInSphinx70Warning) + + +class peek_iter: + """An iterator object that supports peeking ahead. + + Parameters + ---------- + o : iterable or callable + `o` is interpreted very differently depending on the presence of + `sentinel`. + + If `sentinel` is not given, then `o` must be a collection object + which supports either the iteration protocol or the sequence protocol. + + If `sentinel` is given, then `o` must be a callable object. + + sentinel : any value, optional + If given, the iterator will call `o` with no arguments for each + call to its `next` method; if the value returned is equal to + `sentinel`, :exc:`StopIteration` will be raised, otherwise the + value will be returned. + + See Also + -------- + `peek_iter` can operate as a drop in replacement for the built-in + `iter `_ function. + + Attributes + ---------- + sentinel + The value used to indicate the iterator is exhausted. If `sentinel` + was not given when the `peek_iter` was instantiated, then it will + be set to a new object instance: ``object()``. + + """ + def __init__(self, *args: Any) -> None: + """__init__(o, sentinel=None)""" + self._iterable: Iterable = iter(*args) + self._cache: collections.deque = collections.deque() + if len(args) == 2: + self.sentinel = args[1] + else: + self.sentinel = object() + + def __iter__(self) -> "peek_iter": + return self + + def __next__(self, n: int = None) -> Any: + return self.next(n) + + def _fillcache(self, n: Optional[int]) -> None: + """Cache `n` items. If `n` is 0 or None, then 1 item is cached.""" + if not n: + n = 1 + try: + while len(self._cache) < n: + self._cache.append(next(self._iterable)) # type: ignore + except StopIteration: + while len(self._cache) < n: + self._cache.append(self.sentinel) + + def has_next(self) -> bool: + """Determine if iterator is exhausted. + + Returns + ------- + bool + True if iterator has more items, False otherwise. + + Note + ---- + Will never raise :exc:`StopIteration`. + + """ + return self.peek() != self.sentinel + + def next(self, n: int = None) -> Any: + """Get the next item or `n` items of the iterator. + + Parameters + ---------- + n : int or None + The number of items to retrieve. Defaults to None. + + Returns + ------- + item or list of items + The next item or `n` items of the iterator. If `n` is None, the + item itself is returned. If `n` is an int, the items will be + returned in a list. If `n` is 0, an empty list is returned. + + Raises + ------ + StopIteration + Raised if the iterator is exhausted, even if `n` is 0. + + """ + self._fillcache(n) + if not n: + if self._cache[0] == self.sentinel: + raise StopIteration + if n is None: + result = self._cache.popleft() + else: + result = [] + else: + if self._cache[n - 1] == self.sentinel: + raise StopIteration + result = [self._cache.popleft() for i in range(n)] + return result + + def peek(self, n: Optional[int] = None) -> Any: + """Preview the next item or `n` items of the iterator. + + The iterator is not advanced when peek is called. + + Returns + ------- + item or list of items + The next item or `n` items of the iterator. If `n` is None, the + item itself is returned. If `n` is an int, the items will be + returned in a list. If `n` is 0, an empty list is returned. + + If the iterator is exhausted, `peek_iter.sentinel` is returned, + or placed as the last item in the returned list. + + Note + ---- + Will never raise :exc:`StopIteration`. + + """ + self._fillcache(n) + if n is None: + result = self._cache[0] + else: + result = [self._cache[i] for i in range(n)] + return result + + +class modify_iter(peek_iter): + """An iterator object that supports modifying items as they are returned. + + Parameters + ---------- + o : iterable or callable + `o` is interpreted very differently depending on the presence of + `sentinel`. + + If `sentinel` is not given, then `o` must be a collection object + which supports either the iteration protocol or the sequence protocol. + + If `sentinel` is given, then `o` must be a callable object. + + sentinel : any value, optional + If given, the iterator will call `o` with no arguments for each + call to its `next` method; if the value returned is equal to + `sentinel`, :exc:`StopIteration` will be raised, otherwise the + value will be returned. + + modifier : callable, optional + The function that will be used to modify each item returned by the + iterator. `modifier` should take a single argument and return a + single value. Defaults to ``lambda x: x``. + + If `sentinel` is not given, `modifier` must be passed as a keyword + argument. + + Attributes + ---------- + modifier : callable + `modifier` is called with each item in `o` as it is iterated. The + return value of `modifier` is returned in lieu of the item. + + Values returned by `peek` as well as `next` are affected by + `modifier`. However, `modify_iter.sentinel` is never passed through + `modifier`; it will always be returned from `peek` unmodified. + + Example + ------- + >>> a = [" A list ", + ... " of strings ", + ... " with ", + ... " extra ", + ... " whitespace. "] + >>> modifier = lambda s: s.strip().replace('with', 'without') + >>> for s in modify_iter(a, modifier=modifier): + ... print('"%s"' % s) + "A list" + "of strings" + "without" + "extra" + "whitespace." + + """ + def __init__(self, *args: Any, **kwargs: Any) -> None: + """__init__(o, sentinel=None, modifier=lambda x: x)""" + if 'modifier' in kwargs: + self.modifier = kwargs['modifier'] + elif len(args) > 2: + self.modifier = args[2] + args = args[:2] + else: + self.modifier = lambda x: x + if not callable(self.modifier): + raise TypeError('modify_iter(o, modifier): ' + 'modifier must be callable') + super().__init__(*args) + + def _fillcache(self, n: Optional[int]) -> None: + """Cache `n` modified items. If `n` is 0 or None, 1 item is cached. + + Each item returned by the iterator is passed through the + `modify_iter.modified` function before being cached. + + """ + if not n: + n = 1 + try: + while len(self._cache) < n: + self._cache.append(self.modifier(next(self._iterable))) # type: ignore + except StopIteration: + while len(self._cache) < n: + self._cache.append(self.sentinel) diff --git a/tools/docs/guide/install.md b/tools/docs/guide/install.md index dc694a87..79935f08 100644 --- a/tools/docs/guide/install.md +++ b/tools/docs/guide/install.md @@ -14,8 +14,14 @@ TensorFlow MRI is not yet available for Windows or macOS. Each TensorFlow MRI release is compiled against a specific version of TensorFlow. To ensure compatibility, it is recommended to install matching -versions of TensorFlow and TensorFlow MRI according to the -{ref}`TensorFlow compatibility table`. +versions of TensorFlow and TensorFlow MRI according to the table below. + +```{include} ../../../README.md +--- +start-after: start-compatibility-table +end-before: end-compatibility-table +--- +``` ```{warning} Each TensorFlow MRI version aims to target and support the latest TensorFlow @@ -63,19 +69,9 @@ To get started without installing anything on your system, you can use [Google Colab](https://colab.research.google.com/notebooks/welcome.ipynb). Simply create a new notebook and use ``pip`` to install TensorFlow MRI. -```python +``` !pip install tensorflow-mri ``` The Colab environment is already configured to run TensorFlow and has GPU support. - - -### TensorFlow compatibility table - -```{include} ../../../README.md ---- -start-after: start-compatibility-table -end-before: end-compatibility-table ---- -``` diff --git a/tools/docs/test_docs.py b/tools/docs/test_docs.py index 404cd482..98325c00 100644 --- a/tools/docs/test_docs.py +++ b/tools/docs/test_docs.py @@ -4,10 +4,12 @@ wdir = pathlib.Path().absolute() sys.path.insert(0, str(wdir)) +from tensorflow_mri.python.activations import complex_activations from tensorflow_mri.python.ops import array_ops from tensorflow_mri.python.ops import wavelet_ops kwargs = dict(raise_on_error=True) +doctest.testmod(complex_activations, **kwargs) doctest.testmod(array_ops, **kwargs) doctest.testmod(wavelet_ops, **kwargs) diff --git a/tools/docs/tutorials/recon.md b/tools/docs/tutorials/recon.md index 86f0f87b..be02baae 100644 --- a/tools/docs/tutorials/recon.md +++ b/tools/docs/tutorials/recon.md @@ -4,5 +4,5 @@ --- hidden: --- - +CG-SENSE ``` From a9b5456ad2cfc6e053373b3b9d37f53896b3d39a Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 24 Aug 2022 10:08:12 +0000 Subject: [PATCH 041/101] Documenting VarNet --- .../python/layers/data_consistency.py | 1 - .../python/models/variational_network.py | 43 ++++++++++++++++++- 2 files changed, 41 insertions(+), 3 deletions(-) diff --git a/tensorflow_mri/python/layers/data_consistency.py b/tensorflow_mri/python/layers/data_consistency.py index b1d5059d..291213f0 100644 --- a/tensorflow_mri/python/layers/data_consistency.py +++ b/tensorflow_mri/python/layers/data_consistency.py @@ -23,7 +23,6 @@ from tensorflow_mri.python.util import keras_util -@api_util.export("layers.LeastSquaresGradientDescent") class LeastSquaresGradientDescent(linear_operator_layer.LinearOperatorLayer): """Least squares gradient descent layer. """ diff --git a/tensorflow_mri/python/models/variational_network.py b/tensorflow_mri/python/models/variational_network.py index a017e05d..d47f32f6 100644 --- a/tensorflow_mri/python/models/variational_network.py +++ b/tensorflow_mri/python/models/variational_network.py @@ -13,7 +13,8 @@ # limitations under the License. # ============================================================================== -import numpy as np +import string + import tensorflow as tf import warnings @@ -27,7 +28,41 @@ from tensorflow_mri.python.util import model_util -class VarNet(graph_like_model.GraphLikeModel): +class VarNet(tf.keras.Model): + """${rank}-D variational network. + + This model can be used to reconstruct MR images from *k*-space measurements. + The architecture consists of an interleaved cascade of gradient descent (GD) + steps and neural networks (NNs). The GD steps incorporate the MRI encoding + operator and they minimize the error between the current *k*-space estimate + and the *k*-space measurements (data consistency). The NNs act as a + regularization term. + + This model is flexible. It supports Cartesian and non-Cartesian data and + single and multicoil inputs. The corresponding encoding operator is + auto-constructed internally based on the available inputs. See + `tfmri.linalg.LinearOperatorMRI` for more details on how this operator + is constructed. + + Notes: + Test note. + + References: + 1. Sriram A, Zbontar J, Murrell T, Defazio A, Zitnick CL, Yakubova N, + Knoll F, Johnson P. End-to-end variational networks for accelerated MRI + reconstruction. InInternational Conference on Medical Image Computing + and Computer-Assisted Intervention 2020 Oct 4 (pp. 64-73). Springer, + Cham. + 2. Hammernik K, Klatzer T, Kobler E, Recht MP, Sodickson DK, Pock T, + Knoll F. Learning a variational network for reconstruction of + accelerated MRI data. Magnetic resonance in medicine. + 2018 Jun;79(6):3055-71. + 3. Schlemper J, Salehi SS, Kundu P, Lazarus C, Dyvorne H, Rueckert D, + Sofka M. Nonuniform variational network: deep learning for accelerated + nonuniform MR image reconstruction. InInternational Conference on + Medical Image Computing and Computer-Assisted Intervention 2019 Oct 13 + (pp. 57-64). Springer, Cham. + """ def __init__(self, rank, num_iterations=12, @@ -197,6 +232,10 @@ def __init__(self, *args, **kwargs): super().__init__(3, *args, **kwargs) +VarNet2D.__doc__ = string.Template(VarNet.__doc__).substitute(rank=2) +VarNet3D.__doc__ = string.Template(VarNet.__doc__).substitute(rank=3) + + def _get_default_coil_compression_kwargs(): return { 'out_coils': 12 From fc422f3d4440b35841a9b2bd17add18d8cf27931 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 25 Aug 2022 17:39:14 +0000 Subject: [PATCH 042/101] Support statically unknown numbers of phases in k-space trajectory --- tensorflow_mri/python/__init__.py | 1 + tensorflow_mri/python/geometry/__init__.py | 17 ++ .../python/geometry/rotation_matrix_2d.py | 120 ++++++++ .../geometry/rotation_matrix_2d_test.py | 259 ++++++++++++++++++ .../python/linalg/linear_operator_mri.py | 4 +- tensorflow_mri/python/ops/traj_ops.py | 52 +++- tensorflow_mri/python/util/api_util.py | 2 + 7 files changed, 442 insertions(+), 13 deletions(-) create mode 100644 tensorflow_mri/python/geometry/__init__.py create mode 100644 tensorflow_mri/python/geometry/rotation_matrix_2d.py create mode 100644 tensorflow_mri/python/geometry/rotation_matrix_2d_test.py diff --git a/tensorflow_mri/python/__init__.py b/tensorflow_mri/python/__init__.py index c3e14470..475dc930 100644 --- a/tensorflow_mri/python/__init__.py +++ b/tensorflow_mri/python/__init__.py @@ -17,6 +17,7 @@ from tensorflow_mri.python import activations from tensorflow_mri.python import callbacks from tensorflow_mri.python import coils +from tensorflow_mri.python import geometry from tensorflow_mri.python import initializers from tensorflow_mri.python import io from tensorflow_mri.python import layers diff --git a/tensorflow_mri/python/geometry/__init__.py b/tensorflow_mri/python/geometry/__init__.py new file mode 100644 index 00000000..110f09d9 --- /dev/null +++ b/tensorflow_mri/python/geometry/__init__.py @@ -0,0 +1,17 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Geometric operations.""" + +from tensorflow_mri.python.geometry import rotation_matrix_2d diff --git a/tensorflow_mri/python/geometry/rotation_matrix_2d.py b/tensorflow_mri/python/geometry/rotation_matrix_2d.py new file mode 100644 index 00000000..9f984293 --- /dev/null +++ b/tensorflow_mri/python/geometry/rotation_matrix_2d.py @@ -0,0 +1,120 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== + +import tensorflow as tf + +from tensorflow_mri.python.util import api_util + + +@api_util.export("geometry.euler_to_rotation_matrix_2d") +def from_euler(angle, name=None): + r"""Converts an angle to a 2D rotation matrix. + + Converts an angle $$\theta$$ to a 2D rotation matrix following the equation + + $$ + \mathbf{R} = + \begin{bmatrix} + \cos(\theta) & -\sin(\theta) \\ + \sin(\theta) & \cos(\theta) + \end{bmatrix}. + $$ + + Note: + The resulting matrix rotates points in the $$xy$$-plane counterclockwise. + + Args: + angle: A tensor of shape `[..., 1]`, where the last dimension + represents an angle in radians. + name: A name for this op. + + Returns: + A tensor of shape `[..., 2, 2]`, where the last dimension represents + a 2D rotation matrix. + + Raises: + ValueError: If the shape of `angle` is invalid. + + References: + This operator is based on + `tfg.geometry.transformation.rotation_matrix_2d.from_euler`. + """ + with tf.name_scope(name or "euler_to_rotation_matrix_2d"): + angle = tf.convert_to_tensor(angle) + + if not angle.shape[-1:].is_compatible_with([1]): + raise ValueError( + f"angle must have shape `[..., 1]`, but got: {angle.shape}") + + cos_angle = tf.cos(angle) + sin_angle = tf.sin(angle) + matrix = tf.stack((cos_angle, -sin_angle, + sin_angle, cos_angle), + axis=-1) + output_shape = tf.concat((tf.shape(input=angle)[:-1], (2, 2)), axis=-1) + return tf.reshape(matrix, shape=output_shape) + + +@api_util.export("geometry.rotate_with_rotation_matrix_2d") +def rotate(point, matrix, name=None): + """Rotates a 2D point using a 2D rotation matrix. + + Args: + point: A tensor of shape `[..., 2]`, where the last dimension + represents a 2D point and `...` represents any number of batch dimensions. + matrix: A tensor of shape `[..., 2, 2]`, where the last two + dimensions represent a 2D rotation matrix and `...` represents any + number of batch dimensions, which must be broadcastable with those in + shape. + name: A name for this op. + + Returns: + A tensor of shape `[..., 2]`, where the last dimension represents a 2D + point and `...` is the result of broadcasting the batch shapes of `point` + and `matrix`. + + Raises: + ValueError: If the shape of `point` or `matrix` is not supported. + + References: + This operator is based on + `tfg.geometry.transformation.rotation_matrix_2d.rotate`. + """ + with tf.name_scope(name or "rotate_with_rotation_matrix_2d"): + point = tf.convert_to_tensor(point) + matrix = tf.convert_to_tensor(matrix) + + if not point.shape[-1:].is_compatible_with(2): + raise ValueError( + f"point must have shape [..., 2], but got: {point.shape}") + if (not matrix.shape[-1:].is_compatible_with([2]) or + not matrix.shape[-2:-1].is_compatible_with([2])): + raise ValueError( + f"matrix must have shape [..., 2, 2], but got: {matrix.shape}") + try: + static_batch_shape = tf.broadcast_static_shape(point.shape[:-1], + matrix.shape[:-2]) + except ValueError as err: + raise ValueError( + f"The batch shapes of point and matrix could not be broadcasted. " + f"Received: {point.shape} and {matrix.shape}") from err + + common_batch_shape = tf.broadcast_dynamic_shape(tf.shape(point)[:-1], + tf.shape(matrix)[:-2]) + + point = tf.broadcast_to(point, tf.concat([common_batch_shape, [2]], 0)) + matrix = tf.broadcast_to(matrix, tf.concat([common_batch_shape, [2, 2]], 0)) + rotated_point = tf.linalg.matvec(matrix, point) + return tf.ensure_shape(rotated_point, static_batch_shape.concatenate([2])) diff --git a/tensorflow_mri/python/geometry/rotation_matrix_2d_test.py b/tensorflow_mri/python/geometry/rotation_matrix_2d_test.py new file mode 100644 index 00000000..55be2441 --- /dev/null +++ b/tensorflow_mri/python/geometry/rotation_matrix_2d_test.py @@ -0,0 +1,259 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== + +# Copyright 2020 The TensorFlow Authors +# +# 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 +# +# https://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. +# ============================================================================== +"""Tests for module `rotation_matrix_2d`.""" +# This file is copied from TensorFlow graphics. We're testing TFMRI's +# `rotation_matrix_2d` module, which is very similar to the TFG module of the +# same name, so we reuse those tests. For those functions that are not yet +# available in TFMRI, we use TFG's functions. + +from absl.testing import flagsaver +from absl.testing import parameterized +import numpy as np + +# TODO(jmontalt): Remove these lines when the `rotation_matrix_2d` module is +# fully implemented. +from tensorflow_graphics.geometry.transformation import rotation_matrix_2d as tfg_rotation_matrix_2d +from tensorflow_graphics.geometry.transformation.tests import test_data as td +from tensorflow_graphics.geometry.transformation.tests import test_helpers +from tensorflow_graphics.util import test_case + +from tensorflow_mri.python.geometry import rotation_matrix_2d + + +class RotationMatrix2dTest(test_case.TestCase): + + @parameterized.parameters( + ((1,)), + ((None, 1),), + ) + def test_from_euler_exception_not_raised(self, *shapes): + """Tests that the shape exceptions are not raised.""" + self.assert_exception_is_not_raised(rotation_matrix_2d.from_euler, shapes) + + @parameterized.parameters( + ("must have exactly 1 dimensions in axis -1", (None,)),) + def test_from_euler_exception_raised(self, error_msg, *shapes): + """Tests that the shape exceptions are properly raised.""" + self.assert_exception_is_raised(rotation_matrix_2d.from_euler, error_msg, + shapes) + + @flagsaver.flagsaver(tfg_add_asserts_to_graph=False) + def test_from_euler_jacobian_preset(self): + """Test the Jacobian of the from_euler function.""" + x_init = test_helpers.generate_preset_test_euler_angles(dimensions=1) + + self.assert_jacobian_is_correct_fn(rotation_matrix_2d.from_euler, [x_init]) + + @flagsaver.flagsaver(tfg_add_asserts_to_graph=False) + def test_from_euler_jacobian_random(self): + """Test the Jacobian of the from_euler function.""" + x_init = test_helpers.generate_random_test_euler_angles(dimensions=1) + + self.assert_jacobian_is_correct_fn(rotation_matrix_2d.from_euler, [x_init]) + + def test_from_euler_normalized_preset(self): + """Tests that an angle maps to correct matrix.""" + euler_angles = test_helpers.generate_preset_test_euler_angles(dimensions=1) + + matrix = rotation_matrix_2d.from_euler(euler_angles) + + self.assertAllEqual( + tfg_rotation_matrix_2d.is_valid(matrix), + np.ones(euler_angles.shape[0:-1] + (1,), dtype=bool)) + + @parameterized.parameters( + ((td.ANGLE_0,), (td.MAT_2D_ID,)), + ((td.ANGLE_45,), (td.MAT_2D_45,)), + ((td.ANGLE_90,), (td.MAT_2D_90,)), + ((td.ANGLE_180,), (td.MAT_2D_180,)), + ) + def test_from_euler_preset(self, test_inputs, test_outputs): + """Tests that an angle maps to correct matrix.""" + self.assert_output_is_correct(rotation_matrix_2d.from_euler, test_inputs, + test_outputs) + + @parameterized.parameters( + ((1,),), + ((None, 1),), + ) + def test_from_euler_with_small_angles_approximation_exception_not_raised( + self, *shapes): + """Tests that the shape exceptions are not raised.""" + self.assert_exception_is_not_raised( + tfg_rotation_matrix_2d.from_euler_with_small_angles_approximation, shapes) + + @parameterized.parameters( + ("must have exactly 1 dimensions in axis -1", (None,)),) + def test_from_euler_with_small_angles_approximation_exception_raised( + self, error_msg, *shape): + """Tests that the shape exceptions are raised.""" + self.assert_exception_is_raised( + tfg_rotation_matrix_2d.from_euler_with_small_angles_approximation, + error_msg, shape) + + def test_from_euler_with_small_angles_approximation_random(self): + """Tests small_angles approximation by comparing to exact calculation.""" + # Only generate small angles. For a test tolerance of 1e-3, 0.17 was found + # empirically to be the range where the small angle approximation works. + random_euler_angles = test_helpers.generate_random_test_euler_angles( + min_angle=-0.17, max_angle=0.17, dimensions=1) + + exact_matrix = rotation_matrix_2d.from_euler(random_euler_angles) + approximate_matrix = ( + tfg_rotation_matrix_2d.from_euler_with_small_angles_approximation( + random_euler_angles)) + + self.assertAllClose(exact_matrix, approximate_matrix, atol=1e-3) + + @parameterized.parameters( + ((2, 2),), + ((None, 2, 2),), + ) + def test_inverse_exception_not_raised(self, *shapes): + """Tests that the shape exceptions are not raised.""" + self.assert_exception_is_not_raised(tfg_rotation_matrix_2d.inverse, shapes) + + @parameterized.parameters( + ("must have a rank greater than 1", (2,)), + ("must have exactly 2 dimensions in axis -1", (2, None)), + ("must have exactly 2 dimensions in axis -2", (None, 2)), + ) + def test_inverse_exception_raised(self, error_msg, *shapes): + """Checks the inputs of the inverse function.""" + self.assert_exception_is_raised(tfg_rotation_matrix_2d.inverse, error_msg, + shapes) + + @flagsaver.flagsaver(tfg_add_asserts_to_graph=False) + def test_inverse_jacobian_preset(self): + """Test the Jacobian of the inverse function.""" + x_init = test_helpers.generate_preset_test_rotation_matrices_2d() + + self.assert_jacobian_is_correct_fn(tfg_rotation_matrix_2d.inverse, [x_init]) + + @flagsaver.flagsaver(tfg_add_asserts_to_graph=False) + def test_inverse_jacobian_random(self): + """Test the Jacobian of the inverse function.""" + x_init = test_helpers.generate_random_test_rotation_matrix_2d() + + self.assert_jacobian_is_correct_fn(tfg_rotation_matrix_2d.inverse, [x_init]) + + def test_inverse_random(self): + """Checks that inverting rotated points results in no transformation.""" + random_euler_angles = test_helpers.generate_random_test_euler_angles( + dimensions=1) + tensor_shape = random_euler_angles.shape[:-1] + + random_matrix = rotation_matrix_2d.from_euler(random_euler_angles) + random_point = np.random.normal(size=tensor_shape + (2,)) + rotated_random_points = rotation_matrix_2d.rotate(random_point, + random_matrix) + predicted_invert_random_matrix = tfg_rotation_matrix_2d.inverse(random_matrix) + predicted_invert_rotated_random_points = rotation_matrix_2d.rotate( + rotated_random_points, predicted_invert_random_matrix) + + self.assertAllClose( + random_point, predicted_invert_rotated_random_points, rtol=1e-6) + + @parameterized.parameters( + ((2, 2),), + ((None, 2, 2),), + ) + def test_is_valid_exception_not_raised(self, *shapes): + """Tests that the shape exceptions are not raised.""" + self.assert_exception_is_not_raised(tfg_rotation_matrix_2d.inverse, shapes) + + @parameterized.parameters( + ("must have a rank greater than 1", (2,)), + ("must have exactly 2 dimensions in axis -1", (2, None)), + ("must have exactly 2 dimensions in axis -2", (None, 2)), + ) + def test_is_valid_exception_raised(self, error_msg, *shape): + """Tests that the shape exceptions are raised.""" + self.assert_exception_is_raised(tfg_rotation_matrix_2d.is_valid, error_msg, + shape) + + @parameterized.parameters( + ((2,), (2, 2)), + ((None, 2), (None, 2, 2)), + ((1, 2), (1, 2, 2)), + ((2, 2), (2, 2, 2)), + ((2,), (1, 2, 2)), + ((1, 2), (2, 2)), + ) + def test_rotate_exception_not_raised(self, *shapes): + """Tests that the shape exceptions are not raised.""" + self.assert_exception_is_not_raised(rotation_matrix_2d.rotate, shapes) + + @parameterized.parameters( + ("matrix must have shape", (None,), (2, 2)), + ("matrix must have shape", (2,), (2,)), + ("matrix must have shape", (2,), (2, None)), + ("matrix must have shape", (2,), (None, 2)), + ) + def test_rotate_exception_raised(self, error_msg, *shape): + """Tests that the shape exceptions are properly raised.""" + self.assert_exception_is_raised(rotation_matrix_2d.rotate, error_msg, shape) + + @flagsaver.flagsaver(tfg_add_asserts_to_graph=False) + def test_rotate_jacobian_preset(self): + """Test the Jacobian of the rotate function.""" + x_matrix_init = test_helpers.generate_preset_test_rotation_matrices_2d() + tensor_shape = x_matrix_init.shape[:-2] + (2,) + x_point_init = np.random.uniform(size=tensor_shape) + + self.assert_jacobian_is_correct_fn(rotation_matrix_2d.rotate, + [x_point_init, x_matrix_init]) + + @flagsaver.flagsaver(tfg_add_asserts_to_graph=False) + def test_rotate_jacobian_random(self): + """Test the Jacobian of the rotate function.""" + x_matrix_init = test_helpers.generate_random_test_rotation_matrix_2d() + tensor_shape = x_matrix_init.shape[:-2] + (2,) + x_point_init = np.random.uniform(size=tensor_shape) + + self.assert_jacobian_is_correct_fn(rotation_matrix_2d.rotate, + [x_point_init, x_matrix_init]) + + @parameterized.parameters( + ((td.AXIS_2D_0, td.ANGLE_90), (td.AXIS_2D_0,)), + ((td.AXIS_2D_X, td.ANGLE_90), (td.AXIS_2D_Y,)), + ) + def test_rotate_preset(self, test_inputs, test_outputs): + """Tests that the rotate function correctly rotates points.""" + + def func(test_point, test_angle): + random_matrix = rotation_matrix_2d.from_euler(test_angle) + return rotation_matrix_2d.rotate(test_point, random_matrix) + + self.assert_output_is_correct(func, test_inputs, test_outputs) + + +if __name__ == "__main__": + test_case.main() diff --git a/tensorflow_mri/python/linalg/linear_operator_mri.py b/tensorflow_mri/python/linalg/linear_operator_mri.py index 768eb04c..92d02d43 100644 --- a/tensorflow_mri/python/linalg/linear_operator_mri.py +++ b/tensorflow_mri/python/linalg/linear_operator_mri.py @@ -144,8 +144,10 @@ def __init__(self, if self._rank not in (2, 3): raise ValueError(f"Rank must be 2 or 3, but got: {self._rank}") self._image_axes = list(range(-self._rank, 0)) # pylint: disable=invalid-unary-operand-type + if extra_shape is None: + extra_shape = [] self._extra_shape_static, self._extra_shape_dynamic = ( - tensor_util.static_and_dynamic_shapes_from_shape(extra_shape or [])) + tensor_util.static_and_dynamic_shapes_from_shape(extra_shape)) # Set initial batch shape, then update according to inputs. # We include the "extra" dimensions in the batch shape for now, so that diff --git a/tensorflow_mri/python/ops/traj_ops.py b/tensorflow_mri/python/ops/traj_ops.py index b5e31936..8ca0b68e 100755 --- a/tensorflow_mri/python/ops/traj_ops.py +++ b/tensorflow_mri/python/ops/traj_ops.py @@ -24,9 +24,9 @@ import numpy as np import tensorflow as tf import tensorflow_nufft as tfft -from tensorflow_graphics.geometry.transformation import rotation_matrix_2d # pylint: disable=wrong-import-order from tensorflow_graphics.geometry.transformation import rotation_matrix_3d # pylint: disable=wrong-import-order +from tensorflow_mri.python.geometry import rotation_matrix_2d from tensorflow_mri.python.ops import array_ops from tensorflow_mri.python.ops import geom_ops from tensorflow_mri.python.ops import signal_ops @@ -694,8 +694,10 @@ def radial_density(base_resolution, if ordering not in orderings_2d: raise ValueError(f"Ordering `{ordering}` is not implemented.") + phases_ = phases if phases is not None else 1 + # Get angles. - angles = _trajectory_angles(views, phases or 1, ordering=ordering, + angles = _trajectory_angles(views, phases_, ordering=ordering, angle_range=angle_range, tiny_number=tiny_number) # Compute weights. @@ -917,6 +919,8 @@ def _trajectory_angles(views, raise ValueError( f"`tiny_number` must be an integer >= 2. Received: {tiny_number}") + phases_ = phases if phases is not None else 1 + # Constants. pi = math.pi pi2 = math.pi * 2.0 @@ -932,19 +936,19 @@ def _trajectory_angles(views, def _angles_2d(angle_delta, angle_max, interleave=False): # Compute azimuthal angles [0, 2 * pi] (full) or [0, pi] (half). - angles = tf.range(views * (phases or 1), dtype=tf.float32) + angles = tf.range(views * phases_, dtype=tf.float32) angles *= angle_delta angles %= angle_max if interleave: - angles = tf.transpose(tf.reshape(angles, (views, phases or 1))) + angles = tf.transpose(tf.reshape(angles, (views, phases_))) else: - angles = tf.reshape(angles, (phases or 1, views)) + angles = tf.reshape(angles, (phases_, views)) angles = tf.expand_dims(angles, -1) return angles # Get ordering. if ordering == 'linear': - angles = _angles_2d(default_max / (views * (phases or 1)), default_max, + angles = _angles_2d(default_max / (views * phases_), default_max, interleave=True) elif ordering == 'golden': angles = _angles_2d(phi * default_max, default_max) @@ -981,7 +985,7 @@ def _scan_fn(prev, curr): elif ordering == 'tiny_half': angles = _angles_2d(phi_n * pi, default_max) elif ordering == 'sphere_archimedean': - projections = views * (phases or 1) + projections = views * phases_ full_projections = 2 * projections if angle_range == 'half' else projections # Computation is sensitive to floating-point errors, so we use float64 to # ensure sufficient accuracy. @@ -993,7 +997,7 @@ def _scan_fn(prev, curr): az = tf.math.floormod(tf.math.cumsum(az), 2.0 * math.pi) # pylint: disable=no-value-for-parameter # Interleave the readouts. def _interleave(arg): - return tf.transpose(tf.reshape(arg, (views, phases or 1))) + return tf.transpose(tf.reshape(arg, (views, phases_))) pol = _interleave(pol) az = _interleave(az) angles = tf.stack([pol, az], axis=-1) @@ -1212,10 +1216,22 @@ def flatten_trajectory(trajectory): Returns: A reshaped `Tensor` with shape `[..., views * samples, ndim]`. """ + # Compute static output shape. batch_shape = trajectory.shape[:-3] views, samples, rank = trajectory.shape[-3:] - new_shape = batch_shape + [views*samples, rank] - return tf.reshape(trajectory, new_shape) + if views is None or samples is None: + views_times_samples = None + else: + views_times_samples = views * samples + static_flat_shape = batch_shape + [views_times_samples, rank] + + # Compute dynamic output shape. + shape = tf.shape(trajectory) + batch_shape = shape[:-3] + views, samples, rank = shape[-3], shape[-2], shape[-1] + flat_shape = tf.concat([batch_shape, [views * samples, rank]], 0) + + return tf.ensure_shape(tf.reshape(trajectory, flat_shape), static_flat_shape) @api_util.export("sampling.flatten_density") @@ -1228,10 +1244,22 @@ def flatten_density(density): Returns: A reshaped `Tensor` with shape `[..., views * samples]`. """ + # Compute static output shape. batch_shape = density.shape[:-2] views, samples = density.shape[-2:] - new_shape = batch_shape + [views*samples] - return tf.reshape(density, new_shape) + if views is None or samples is None: + views_times_samples = None + else: + views_times_samples = views * samples + static_flat_shape = batch_shape + [views_times_samples] + + # Compute dynamic output shape. + shape = tf.shape(density) + batch_shape = shape[:-2] + views, samples = shape[-2], shape[-1] + flat_shape = tf.concat([batch_shape, [views * samples]], 0) + + return tf.ensure_shape(tf.reshape(density, flat_shape), static_flat_shape) @api_util.export("sampling.expand_trajectory") diff --git a/tensorflow_mri/python/util/api_util.py b/tensorflow_mri/python/util/api_util.py index 997b9c54..ad3fc49b 100644 --- a/tensorflow_mri/python/util/api_util.py +++ b/tensorflow_mri/python/util/api_util.py @@ -28,6 +28,7 @@ 'callbacks', 'coils', 'convex', + 'geometry', 'image', 'initializers', 'io', @@ -51,6 +52,7 @@ 'callbacks': "Keras callbacks.", 'coils': "Parallel imaging operations.", 'convex': "Convex optimization operations.", + 'geometry': "Geometric operations.", 'image': "Image processing operations.", 'initializers': "Keras initializers.", 'io': "Input/output operations.", From cf5851d3d368643f4dfb6a9224886c8513c37b10 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 25 Aug 2022 20:03:32 +0000 Subject: [PATCH 043/101] Allow base_resolution to be a tensor in radial_waveform --- tensorflow_mri/python/linalg/linear_operator_mri.py | 2 +- tensorflow_mri/python/ops/traj_ops.py | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/tensorflow_mri/python/linalg/linear_operator_mri.py b/tensorflow_mri/python/linalg/linear_operator_mri.py index 92d02d43..cc14e170 100644 --- a/tensorflow_mri/python/linalg/linear_operator_mri.py +++ b/tensorflow_mri/python/linalg/linear_operator_mri.py @@ -550,4 +550,4 @@ def _composite_tensor_fields(self): "trajectory", "density", "sensitivities", - "fft_norm") + "phase") diff --git a/tensorflow_mri/python/ops/traj_ops.py b/tensorflow_mri/python/ops/traj_ops.py index 8ca0b68e..650cb36c 100755 --- a/tensorflow_mri/python/ops/traj_ops.py +++ b/tensorflow_mri/python/ops/traj_ops.py @@ -868,11 +868,12 @@ def radial_waveform(base_resolution, readout_os=2.0, rank=2): # pylint: disable=unexpected-keyword-arg,no-value-for-parameter # Number of samples with oversampling. - samples = int(base_resolution * readout_os + 0.5) + samples = tf.cast(tf.cast(base_resolution, tf.float32) * + tf.cast(readout_os, tf.float32) + 0.5, dtype=tf.int32) # Compute 1D spoke. waveform = tf.range(-samples // 2, samples // 2, dtype=tf.float32) - waveform /= samples + waveform /= tf.cast(samples, waveform.dtype) # Add y/z dimensions. waveform = tf.expand_dims(waveform, axis=1) From 3fd38dcf9ff728fe6f6ee1861fec8def025015b0 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Fri, 26 Aug 2022 11:35:18 +0000 Subject: [PATCH 044/101] Refactored linear operator layers --- .../python/layers/linear_operator_layer.py | 92 +++++++++---------- tensorflow_mri/python/layers/recon_adjoint.py | 73 +++++++++------ .../python/layers/recon_adjoint_test.py | 39 +++++--- .../python/linalg/linear_operator_mri.py | 48 ++++++++-- 4 files changed, 155 insertions(+), 97 deletions(-) diff --git a/tensorflow_mri/python/layers/linear_operator_layer.py b/tensorflow_mri/python/layers/linear_operator_layer.py index 48fff6c5..0c32776f 100644 --- a/tensorflow_mri/python/layers/linear_operator_layer.py +++ b/tensorflow_mri/python/layers/linear_operator_layer.py @@ -14,33 +14,37 @@ # ============================================================================== """Linear operator layer.""" -import inspect - import tensorflow as tf from tensorflow_mri.python.linalg import linear_operator from tensorflow_mri.python.linalg import linear_operator_mri +LINEAR_OPERATORS = { + 'MRI': linear_operator_mri.LinearOperatorMRI, + 'LinearOperatorMRI': linear_operator_mri.LinearOperatorMRI +} + + class LinearOperatorLayer(tf.keras.layers.Layer): """A layer that uses a linear operator (abstract base class).""" - def __init__(self, - operator=linear_operator_mri.LinearOperatorMRI, - input_indices=None, - **kwargs): + def __init__(self, operator, input_indices=None, **kwargs): super().__init__(**kwargs) if isinstance(operator, linear_operator.LinearOperator): - self._operator_class = operator.__class__ - self._operator_instance = operator - elif (inspect.isclass(operator) and - issubclass(operator, linear_operator.LinearOperator)): - self._operator_class = operator - self._operator_instance = None + self._operator = operator + elif isinstance(operator, str): + if operator not in LINEAR_OPERATORS: + raise ValueError( + f"Unknown operator: {operator}. " + f"Valid strings are: {list(LINEAR_OPERATORS.keys())}") + self._operator = operator + elif callable(operator): + self._operator = operator else: raise TypeError( - f"`operator` must be a subclass of `tfmri.linalg.LinearOperator` " - f"or an instance thereof, but got type: {type(operator)}") + f"`operator` must be a `tfmri.linalg.LinearOperator`, a `str`, or a " + f"callable object. Received: {operator}") if isinstance(input_indices, (int, str)): input_indices = (input_indices,) @@ -53,51 +57,43 @@ def parse_inputs(self, inputs): method. It returns the inputs and an instance of the linear operator to be used. """ - if self._operator_instance is None: - # operator is a class. - if not isinstance(inputs, dict): - raise ValueError( - f"Layer {self.name} expected a mapping. " - f"Received: {inputs}") - - if self._input_indices is None: - input_indices = (tuple(inputs.keys())[0],) - else: - input_indices = self._input_indices - - main = tuple(inputs[i] for i in input_indices) - kwargs = {k: v for k, v in inputs.items() if k not in input_indices} - - # Unpack single input. - if len(main) == 1: - main = main[0] - - # Instantiate the operator. - operator = self._operator_class(**kwargs) - + if isinstance(self._operator, linear_operator.LinearOperator): + # Operator already instantiated. Simply return. + return inputs, self._operator + + # Need to instantiate the operator. + if not isinstance(inputs, dict): + raise ValueError( + f"Layer {self.name} expected a mapping. " + f"Received: {inputs}") + + # If operator is a string, get corresponding class. + if isinstance(self._operator, str): + operator = LINEAR_OPERATORS[self._operator] + + # Get main inputs (defined by input_indices). + if self._input_indices is None: + input_indices = (tuple(inputs.keys())[0],) else: - # Inputs. - main = inputs - operator = self._operator_instance + input_indices = self._input_indices + main = tuple(inputs[i] for i in input_indices) + if len(main) == 1: + main = main[0] # Unpack single inputs. + + # Get remaining inputs and instantiate the operator. + kwargs = {k: v for k, v in inputs.items() if k not in input_indices} + operator = operator(**kwargs) return main, operator def get_config(self): base_config = super().get_config() config = { - 'operator': self.get_input_operator(), + 'operator': self._operator, 'input_indices': self._input_indices } return {**config, **base_config} - def get_input_operator(self): - """Serializes an operator to a dictionary.""" - if self._operator_instance is None: - operator = self._operator_class - else: - operator = self._operator_instance - return operator - class LinearTransform(LinearOperatorLayer): """A layer that applies a linear transform to its inputs.""" diff --git a/tensorflow_mri/python/layers/recon_adjoint.py b/tensorflow_mri/python/layers/recon_adjoint.py index 0937b9ce..1537080e 100644 --- a/tensorflow_mri/python/layers/recon_adjoint.py +++ b/tensorflow_mri/python/layers/recon_adjoint.py @@ -27,26 +27,29 @@ from tensorflow_mri.python.util import keras_util -DOCSTRING = string.Template( - """${rank}-D adjoint reconstruction layer. +class ReconAdjoint(linear_operator_layer.LinearOperatorLayer): + r"""${rank}-D adjoint reconstruction layer. This layer reconstructs a signal using the adjoint of the specified system operator. - This layer's `inputs` differ depending on whether `operator` is a class or an - instance. + This layer can use the same operator instance in each invocation or + instantiate a new operator in each invocation, depending on whether the + operator remains constant or depends on the inputs to the layer. - - If `operator` is a class, then `inputs` must be a `dict` containing both - the inputs to the operator's constructor (e.g., *k*-space mask, trajectory, - coil sensitivities, etc...) and the input to the operator's `transform` - method (usually, the *k*-space data). The value at `kspace_index` will be - passed to the operator's `transform` method. Any other values in `inputs` - will be passed to the operator's constructor. + - If you wish to use the same operator instance during each call, initialize + the layer by setting `operator` to be an instance of a linear operator. + Then the call `inputs` are simply the input to the operator's `transform` + method (usually, the *k*-space data). - - If `operator` is an instance, then `inputs` only contains the input to the - operator's `transform` method (usually, the *k*-space data). In this case, - `inputs` must be a `tf.Tensor` which will be passed unmodified to the - operator's `transform` method. + - If you wish to instantiate a new operator during each call (e.g., because + the operator itself depends on the layer's inputs), initialize the layer by + setting `operator` to be a function that returns an instance of a linear + operator (or a string if you wish to use one of the built-in operators). + In this case the call `inputs` must be a `dict` containing both the inputs + to the operator's `transform` method (specified by `input_indices`) and the + any other inputs needed by the `operator` function to instantiate the + linear operator. Args: expand_channel_dim: A `boolean`. Whether to expand the channel dimension. @@ -55,26 +58,31 @@ Defaults to `True`. reinterpret_complex: A `boolean`. Whether to reinterpret a complex-valued output image as a dual-channel real image. Defaults to `False`. - operator: A subclass of `tfmri.linalg.LinearOperator` or an instance - thereof. The system operator. This object may be a class or an instance. - - - If `operator` is a class, then a new instance will be created during - each evaluation of `call`. The constructor will be passed the arguments - in `inputs` except `kspace_index`. - - If `operator` is an instance, then it will be used as is. - - Defaults to `tfmri.linalg.LinearOperatorMRI`. + operator: A `tfmri.linalg.LinearOperator`, or a callable that returns a + `tfmri.linalg.LinearOperator`, or a `str` containing the name of one + of the built-in linear operators. The system operator. + + - If `operator` is a `tfmri.linalg.LinearOperator`, the operator will be + used as is during each invocation of the layer's `call` method. + - If `operator` is a generic callable, it will be called during each + invocation of the layer's `call` method to construct a new + `tfmri.linalg.LinearOperator`. The callable will be passed all of the + arguments in `inputs` except `kspace_index`. + - If `operator` is a `str`, it must be the name of one of the built-in + linear operators. See the `tfmri.linalg` module for a list of built-in + operators. The operator will be constructed during each invocation of + `call` using the arguments in `inputs` except `kspace_index`. + + Defaults to `'MRI'`, which creates a new `tfmri.linalg.LinearOperatorMRI` + during each invocation of `call`. kspace_index: A `str`. The key of `inputs` containing the *k*-space data. Defaults to `None`, which takes the first element of `inputs`. - """) - - -class ReconAdjoint(linear_operator_layer.LinearOperatorLayer): + """ def __init__(self, rank, expand_channel_dim=True, reinterpret_complex=False, - operator=linear_operator_mri.LinearOperatorMRI, + operator='MRI', kspace_index=None, **kwargs): kwargs['dtype'] = kwargs.get('dtype') or keras_util.complexx() @@ -103,6 +111,11 @@ def get_config(self): input_indices[0] if input_indices is not None else None) return {**config, **base_config} + @classmethod + def from_config(cls, config): + print("from_config", config) + return cls(**config) + @api_util.export("layers.ReconAdjoint2D") @tf.keras.utils.register_keras_serializable(package='MRI') @@ -118,9 +131,9 @@ def __init__(self, *args, **kwargs): super().__init__(3, *args, **kwargs) -ReconAdjoint2D.__doc__ = DOCSTRING.substitute( +ReconAdjoint2D.__doc__ = string.Template(ReconAdjoint.__doc__).substitute( rank=2, dim_names='height, width') -ReconAdjoint3D.__doc__ = DOCSTRING.substitute( +ReconAdjoint3D.__doc__ = string.Template(ReconAdjoint.__doc__).substitute( rank=3, dim_names='depth, height, width') diff --git a/tensorflow_mri/python/layers/recon_adjoint_test.py b/tensorflow_mri/python/layers/recon_adjoint_test.py index 281b895b..773556db 100644 --- a/tensorflow_mri/python/layers/recon_adjoint_test.py +++ b/tensorflow_mri/python/layers/recon_adjoint_test.py @@ -14,6 +14,10 @@ # ============================================================================== """Tests for module `recon_adjoint`.""" +import os +import tempfile + +from absl.testing import parameterized import tensorflow as tf from tensorflow_mri.python.layers import recon_adjoint as recon_adjoint_layer @@ -22,9 +26,11 @@ class ReconAdjointTest(test_util.TestCase): - def test_recon_adjoint(self): + @parameterized.product(expand_channel_dim=[True, False]) + def test_recon_adjoint(self, expand_channel_dim): # Create layer. - layer = recon_adjoint_layer.ReconAdjoint() + layer = recon_adjoint_layer.ReconAdjoint2D( + expand_channel_dim=expand_channel_dim) # Generate k-space data. image_shape = tf.constant([4, 4]) @@ -34,18 +40,29 @@ def test_recon_adjoint(self): # Reconstruct image. expected = recon_adjoint.recon_adjoint_mri(kspace, image_shape) - - # Test with tuple inputs. - inputs = (kspace, image_shape) - result = layer(inputs) - self.assertAllClose(expected, result) + if expand_channel_dim: + expected = tf.expand_dims(expected, axis=-1) # Test with dict inputs. - inputs = {'kspace': kspace, 'image_shape': image_shape} - result = layer(inputs) + input_data = {'kspace': kspace, 'image_shape': image_shape} + result = layer(input_data) self.assertAllClose(expected, result) # Test (de)serialization. - layer = recon_adjoint_layer.ReconAdjoint.from_config(layer.get_config()) - result = layer(inputs) + layer = recon_adjoint_layer.ReconAdjoint2D.from_config(layer.get_config()) + result = layer(input_data) + self.assertAllClose(expected, result) + + # Test in model. + inputs = {k: tf.keras.Input(shape=v.shape, dtype=v.dtype) + for k, v in input_data.items()} + model = tf.keras.Model(inputs, layer(inputs)) + result = model(input_data) + self.assertAllClose(expected, result) + + # Test saving/loading. + saved_model = os.path.join(tempfile.mkdtemp(), 'saved_model') + model.save(saved_model) + model = tf.keras.models.load_model(saved_model) + result = model(input_data) self.assertAllClose(expected, result) diff --git a/tensorflow_mri/python/linalg/linear_operator_mri.py b/tensorflow_mri/python/linalg/linear_operator_mri.py index cc14e170..31168882 100644 --- a/tensorflow_mri/python/linalg/linear_operator_mri.py +++ b/tensorflow_mri/python/linalg/linear_operator_mri.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. @@ -14,6 +14,8 @@ # ============================================================================== """MRI linear operator.""" +import warnings + import tensorflow as tf from tensorflow_mri.python.ops import fft_ops @@ -24,15 +26,19 @@ from tensorflow_mri.python.util import tensor_util +_WARNED_IGNORED_BATCH_DIMENSIONS = {} + + @api_util.export("linalg.LinearOperatorMRI") class LinearOperatorMRI(linear_operator.LinearOperator): # pylint: disable=abstract-method - """Linear operator representing an MRI encoding matrix. + r"""Linear operator representing an MRI encoding matrix. - The MRI operator, :math:`A`, maps a [batch of] images, :math:`x` to a - [batch of] measurement data (*k*-space), :math:`b`. + The MRI operator, $A$, maps a [batch of] images, $x$ to a + [batch of] measurement data (*k*-space), $b$. - .. math:: - A x = b + $$ + A x = b + $$ This object may represent an undersampled MRI operator and supports Cartesian and non-Cartesian *k*-space sampling. The user may provide a @@ -130,6 +136,7 @@ def __init__(self, dynamic_domain=dynamic_domain, dtype=dtype, name=name) + super().__init__(dtype, name=name, parameters=parameters) # Set dtype. dtype = tf.as_dtype(dtype) @@ -137,6 +144,15 @@ def __init__(self, raise ValueError( f"`dtype` must be `complex64` or `complex128`, but got: {str(dtype)}") + # Batch dimensions in `image_shape` and `extra_shape` are not supported. + # However, it is convenient to allow them to have batch dimensions anyway. + # This helps when this operator is used in Keras models, where all inputs + # may be automatically batched. If there are any batch dimensions, we simply + # ignore them by taking the first element. The first time this happens + # we also emit a warning. + image_shape = self._ignore_batch_dims_in_shape(image_shape, "image_shape") + extra_shape = self._ignore_batch_dims_in_shape(extra_shape, "extra_shape") + # Set image shape, rank and extra shape. self._image_shape_static, self._image_shape_dynamic = ( tensor_util.static_and_dynamic_shapes_from_shape(image_shape)) @@ -311,8 +327,6 @@ def __init__(self, # This variable is used by `LinearOperatorGramMRI` to disable the NUFFT. self._skip_nufft = False - super().__init__(dtype, name=name, parameters=parameters) - def _transform(self, x, adjoint=False): """Transform [batch] input `x`. @@ -551,3 +565,21 @@ def _composite_tensor_fields(self): "density", "sensitivities", "phase") + + def _ignore_batch_dims_in_shape(self, shape, argname): + if shape is None: + return None + shape = tf.convert_to_tensor(shape, dtype=tf.int32) + if shape.shape.rank == 2: + warned = _WARNED_IGNORED_BATCH_DIMENSIONS.get(argname, False) + if not warned: + _WARNED_IGNORED_BATCH_DIMENSIONS[argname] = True + warnings.warn( + f"Operator {self.name} got a batched `{argname}` argument. " + f"It is not possible to process images with " + f"different shapes in the same batch. " + f"If the input batch has more than one element, " + f"only the first shape will be used. " + f"It is up to you to verify if this behavior is correct.") + return tf.ensure_shape(shape[0], shape.shape[1:]) + return shape From 355e767c87a816dc163f23481b3178b0d09d8d97 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Fri, 26 Aug 2022 11:39:41 +0000 Subject: [PATCH 045/101] Remove print statement --- tensorflow_mri/python/layers/recon_adjoint.py | 5 ----- 1 file changed, 5 deletions(-) diff --git a/tensorflow_mri/python/layers/recon_adjoint.py b/tensorflow_mri/python/layers/recon_adjoint.py index 1537080e..f6ecc6c7 100644 --- a/tensorflow_mri/python/layers/recon_adjoint.py +++ b/tensorflow_mri/python/layers/recon_adjoint.py @@ -111,11 +111,6 @@ def get_config(self): input_indices[0] if input_indices is not None else None) return {**config, **base_config} - @classmethod - def from_config(cls, config): - print("from_config", config) - return cls(**config) - @api_util.export("layers.ReconAdjoint2D") @tf.keras.utils.register_keras_serializable(package='MRI') From eafc7b014fdae6319c0fbe579f3ac2a49a08ec94 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Fri, 26 Aug 2022 17:08:42 +0000 Subject: [PATCH 046/101] Add normalization layers --- .gitignore | 1 + tensorflow_mri/python/layers/__init__.py | 1 + tensorflow_mri/python/layers/normalization.py | 66 +++++++++++++++++++ tensorflow_mri/python/models/conv_endec.py | 16 ++--- .../python/models/variational_network.py | 20 ++---- 5 files changed, 78 insertions(+), 26 deletions(-) create mode 100644 tensorflow_mri/python/layers/normalization.py diff --git a/.gitignore b/.gitignore index 8c626152..dd1821b7 100644 --- a/.gitignore +++ b/.gitignore @@ -6,6 +6,7 @@ __pycache__/ artifacts/ build/ +logs/ third_party/spiral_waveform tools/docs/_build tools/docs/_templates diff --git a/tensorflow_mri/python/layers/__init__.py b/tensorflow_mri/python/layers/__init__.py index 89bd6e55..5db028c7 100644 --- a/tensorflow_mri/python/layers/__init__.py +++ b/tensorflow_mri/python/layers/__init__.py @@ -20,6 +20,7 @@ from tensorflow_mri.python.layers import conv_endec from tensorflow_mri.python.layers import data_consistency from tensorflow_mri.python.layers import kspace_scaling +from tensorflow_mri.python.layers import normalization from tensorflow_mri.python.layers import pooling from tensorflow_mri.python.layers import preproc_layers from tensorflow_mri.python.layers import recon_adjoint diff --git a/tensorflow_mri/python/layers/normalization.py b/tensorflow_mri/python/layers/normalization.py new file mode 100644 index 00000000..1b55b03a --- /dev/null +++ b/tensorflow_mri/python/layers/normalization.py @@ -0,0 +1,66 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Normalization layers.""" + +import tensorflow as tf + +from tensorflow_mri.python.util import api_util + + +@api_util.export("layers.Normalized") +@tf.keras.utils.register_keras_serializable(package='MRI') +class Normalized(tf.keras.layers.Wrapper): + r"""Applies the wrapped layer with normalized inputs. + + This layer shifts and scales the inputs into a distribution centered around 0 + with a standard deviation of 1 before passing them to the wrapped layer. + + $$ + x = (x - \mu) / \sigma + $$ + + After applying the wrapped layer, the outputs are scaled back to the original + distribution. + + $$ + y = y \sigma + \mu + $$ + + Args: + layer: A `tf.keras.layers.Layer`. The wrapped layer. + axis: An `int` or a `list` thereof. The axis or axes to normalize across. + Typically this is the features axis/axes. The left-out axes are typically + the batch axis/axes. Defaults to -1, the last dimension in the input. + **kwargs: Additional keyword arguments to be passed to the base class. + """ + def __init__(self, layer, axis=-1, **kwargs): + super().__init__(layer, **kwargs) + self.axis = axis + + def compute_output_shape(self, input_shape): + return self.layer.compute_output_shape(input_shape) + + def call(self, inputs, **kwargs): + mean, variance = tf.nn.moments(inputs, axes=self.axis, keepdims=True) + std = tf.math.maximum(tf.math.sqrt(variance), tf.keras.backend.epsilon()) + inputs = (inputs - mean) / std + outputs = self.layer(inputs, **kwargs) + outputs = outputs * std + mean + return outputs + + def get_config(self): + base_config = super().get_config() + config = {'axis': self.axis} + return {**base_config, **config} diff --git a/tensorflow_mri/python/models/conv_endec.py b/tensorflow_mri/python/models/conv_endec.py index 7db338ed..5da07080 100644 --- a/tensorflow_mri/python/models/conv_endec.py +++ b/tensorflow_mri/python/models/conv_endec.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. @@ -26,7 +26,7 @@ from tensorflow_mri.python.util import layer_util -UNET_DOC_TEMPLATE = string.Template( +class UNet(tf.keras.Model): """${rank}D U-Net model. Args: @@ -91,11 +91,7 @@ .. [2] Han, Y., & Ye, J. C. (2018). Framing U-Net via deep convolutional framelets: Application to sparse-view CT. IEEE transactions on medical imaging, 37(6), 1418-1429. - """) - - -class UNet(tf.keras.Model): - """U-Net model (private base class).""" + """ def __init__(self, rank, filters, @@ -397,9 +393,9 @@ def __init__(self, *args, **kwargs): super().__init__(3, *args, **kwargs) -UNet1D.__doc__ = UNET_DOC_TEMPLATE.substitute(rank=1) -UNet2D.__doc__ = UNET_DOC_TEMPLATE.substitute(rank=2) -UNet3D.__doc__ = UNET_DOC_TEMPLATE.substitute(rank=3) +UNet1D.__doc__ = string.Template(UNet.__doc__).substitute(rank=1) +UNet2D.__doc__ = string.Template(UNet.__doc__).substitute(rank=2) +UNet3D.__doc__ = string.Template(UNet.__doc__).substitute(rank=3) UNet1D.__signature__ = doc_util.get_nd_layer_signature(UNet) diff --git a/tensorflow_mri/python/models/variational_network.py b/tensorflow_mri/python/models/variational_network.py index d47f32f6..fa044491 100644 --- a/tensorflow_mri/python/models/variational_network.py +++ b/tensorflow_mri/python/models/variational_network.py @@ -16,10 +16,9 @@ import string import tensorflow as tf -import warnings from tensorflow_mri.python.activations import complex_activations -from tensorflow_mri.python.layers import data_consistency, linear_operator_layer +from tensorflow_mri.python.layers import data_consistency, normalization from tensorflow_mri.python.models import graph_like_model from tensorflow_mri.python.ops import coil_ops, math_ops from tensorflow_mri.python.util import api_util @@ -104,7 +103,9 @@ def __init__(self, ) if self.reg_network == 'auto': - reg_network_class = model_util.get_nd_model('UNet', rank) + reg_network_class = lambda *args, name=None, **kwargs: normalization.Normalized( + model_util.get_nd_model('UNet', rank)(*args, **kwargs), + axis=list(range(-(self.rank + 1), 0)), name=name) reg_network_kwargs = dict( filters=[32, 64, 128], kernel_size=3, @@ -163,19 +164,6 @@ def __init__(self, def call(self, inputs): x = {k: v for k, v in inputs.items()} - if 'image_shape' in x: - image_shape = x['image_shape'] - if image_shape.shape.rank == 2: - warnings.warn( - f"Layer {self.name} got a batch of image shapes. " - f"It is not possible to reconstruct images with " - f"different shapes in the same batch. " - f"If the input batch has more than one element, " - f"only the first image shape will be used. " - f"It is up to you to verify if this behavior is correct.") - x['image_shape'] = tf.ensure_shape( - image_shape[0], image_shape.shape[1:]) - if self.compress_coils: x['kspace'] = self._coil_compression_layer(x) From f03be3c1a36fe48cb6c5b243ab364f070b110a87 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Fri, 26 Aug 2022 17:13:04 +0000 Subject: [PATCH 047/101] Fixed a bug in linear_operator_layer --- .../python/layers/linear_operator_layer.py | 2 + .../python/layers/normalization_test.py | 56 +++++++++++++++++++ 2 files changed, 58 insertions(+) create mode 100644 tensorflow_mri/python/layers/normalization_test.py diff --git a/tensorflow_mri/python/layers/linear_operator_layer.py b/tensorflow_mri/python/layers/linear_operator_layer.py index 0c32776f..1a25f97d 100644 --- a/tensorflow_mri/python/layers/linear_operator_layer.py +++ b/tensorflow_mri/python/layers/linear_operator_layer.py @@ -70,6 +70,8 @@ def parse_inputs(self, inputs): # If operator is a string, get corresponding class. if isinstance(self._operator, str): operator = LINEAR_OPERATORS[self._operator] + else: + operator = self._operator # Get main inputs (defined by input_indices). if self._input_indices is None: diff --git a/tensorflow_mri/python/layers/normalization_test.py b/tensorflow_mri/python/layers/normalization_test.py new file mode 100644 index 00000000..e8302f17 --- /dev/null +++ b/tensorflow_mri/python/layers/normalization_test.py @@ -0,0 +1,56 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Tests for normalization layers.""" +# pylint: disable=g-direct-tensorflow-import + +from absl.testing import parameterized +import keras +from keras.testing_infra import test_combinations +from keras.testing_infra import test_utils +import numpy as np +import tensorflow as tf + +from tensorflow_mri.python.layers import normalization +from tensorflow_mri.python.util import test_util + + +class NormalizedTest(test_util.TestCase): + @test_util.run_all_execution_modes + def test_normalized_dense(self): + model = keras.models.Sequential() + model.add( + keras.layers.TimeDistributed( + keras.layers.Dense(2), input_shape=(3, 4))) + model.compile(optimizer='rmsprop', loss='mse') + model.fit( + np.random.random((10, 3, 4)), + np.random.random((10, 3, 2)), + epochs=1, + batch_size=10) + + # test config + model.get_config() + + # check whether the model variables are present in the + # trackable list of objects + checkpointed_object_ids = { + id(o) for o in trackable_util.list_objects(model) + } + for v in model.variables: + self.assertIn(id(v), checkpointed_object_ids) + + +if __name__ == '__main__': + tf.test.main() From 98ed0a3dd8d1b2a169f393b5e435d9496a8b4517 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Fri, 26 Aug 2022 17:33:38 +0000 Subject: [PATCH 048/101] Add tests for normalized layer --- .../python/layers/normalization_test.py | 50 +++++++++---------- tensorflow_mri/python/layers/recon_adjoint.py | 1 - 2 files changed, 24 insertions(+), 27 deletions(-) diff --git a/tensorflow_mri/python/layers/normalization_test.py b/tensorflow_mri/python/layers/normalization_test.py index e8302f17..64ad22c8 100644 --- a/tensorflow_mri/python/layers/normalization_test.py +++ b/tensorflow_mri/python/layers/normalization_test.py @@ -13,12 +13,7 @@ # limitations under the License. # ============================================================================== """Tests for normalization layers.""" -# pylint: disable=g-direct-tensorflow-import -from absl.testing import parameterized -import keras -from keras.testing_infra import test_combinations -from keras.testing_infra import test_utils import numpy as np import tensorflow as tf @@ -29,27 +24,30 @@ class NormalizedTest(test_util.TestCase): @test_util.run_all_execution_modes def test_normalized_dense(self): - model = keras.models.Sequential() - model.add( - keras.layers.TimeDistributed( - keras.layers.Dense(2), input_shape=(3, 4))) - model.compile(optimizer='rmsprop', loss='mse') - model.fit( - np.random.random((10, 3, 4)), - np.random.random((10, 3, 2)), - epochs=1, - batch_size=10) - - # test config - model.get_config() - - # check whether the model variables are present in the - # trackable list of objects - checkpointed_object_ids = { - id(o) for o in trackable_util.list_objects(model) - } - for v in model.variables: - self.assertIn(id(v), checkpointed_object_ids) + layer = normalization.Normalized( + tf.keras.layers.Dense(2, bias_initializer='random_uniform')) + layer.build((None, 4)) + + input_data = np.random.uniform(size=(2, 4)) + + def _compute_output(input_data, normalized=False): + if normalized: + mean = input_data.mean(axis=-1, keepdims=True) + std = input_data.std(axis=-1, keepdims=True) + input_data = (input_data - mean) / std + output_data = layer.layer(input_data) + if normalized: + output_data = output_data * std + mean + return output_data + + expected_unnorm = _compute_output(input_data, normalized=False) + expected_norm = _compute_output(input_data, normalized=True) + + result_unnorm = layer.layer(input_data) + result_norm = layer(input_data) + + self.assertAllClose(expected_unnorm, result_unnorm) + self.assertAllClose(expected_norm, result_norm) if __name__ == '__main__': diff --git a/tensorflow_mri/python/layers/recon_adjoint.py b/tensorflow_mri/python/layers/recon_adjoint.py index f6ecc6c7..bd58a70b 100644 --- a/tensorflow_mri/python/layers/recon_adjoint.py +++ b/tensorflow_mri/python/layers/recon_adjoint.py @@ -19,7 +19,6 @@ import tensorflow as tf from tensorflow_mri.python.layers import linear_operator_layer -from tensorflow_mri.python.linalg import linear_operator_mri from tensorflow_mri.python.ops import math_ops from tensorflow_mri.python.recon import recon_adjoint from tensorflow_mri.python.util import api_util From 19726b30ba1dd0f0979611ee46552eaa16a217e7 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Sat, 27 Aug 2022 00:55:14 +0000 Subject: [PATCH 049/101] Added RotationMatrix2D --- RELEASE.md | 8 + tensorflow_mri/__init__.py | 1 + tensorflow_mri/_api/geometry/__init__.py | 5 + tensorflow_mri/_api/layers/__init__.py | 2 +- .../python/geometry/rotation_matrix.py | 164 +++++++++++ .../python/geometry/rotation_matrix_2d.py | 234 ++++++++------- .../geometry/rotation_matrix_2d_test.py | 232 +++------------ tensorflow_mri/python/geometry/test_data.py | 136 +++++++++ .../python/geometry/test_helpers.py | 275 ++++++++++++++++++ tensorflow_mri/python/layers/normalization.py | 4 +- tensorflow_mri/python/ops/traj_ops.py | 5 +- 11 files changed, 769 insertions(+), 297 deletions(-) create mode 100644 tensorflow_mri/_api/geometry/__init__.py create mode 100644 tensorflow_mri/python/geometry/rotation_matrix.py create mode 100644 tensorflow_mri/python/geometry/test_data.py create mode 100644 tensorflow_mri/python/geometry/test_helpers.py diff --git a/RELEASE.md b/RELEASE.md index 9718ede0..86be8dee 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -8,6 +8,14 @@ ## Major Features and Improvements +- `tfmri.geometry`: + + - Added new extension type `RotationMatrix2D`. + +- `tfmri.layers`: + + - Added new wrapper layer `Normalized`. + - `tfmri.sampling`: - Added operator ``spiral_waveform`` to public API. diff --git a/tensorflow_mri/__init__.py b/tensorflow_mri/__init__.py index b9d54286..8a0a8cf3 100644 --- a/tensorflow_mri/__init__.py +++ b/tensorflow_mri/__init__.py @@ -27,6 +27,7 @@ from tensorflow_mri._api import callbacks from tensorflow_mri._api import coils from tensorflow_mri._api import convex +from tensorflow_mri._api import geometry from tensorflow_mri._api import image from tensorflow_mri._api import initializers from tensorflow_mri._api import io diff --git a/tensorflow_mri/_api/geometry/__init__.py b/tensorflow_mri/_api/geometry/__init__.py new file mode 100644 index 00000000..079e8787 --- /dev/null +++ b/tensorflow_mri/_api/geometry/__init__.py @@ -0,0 +1,5 @@ +# This file was automatically generated by tools/build/create_api.py. +# Do not edit. +"""Geometric operations.""" + +from tensorflow_mri.python.geometry.rotation_matrix_2d import RotationMatrix2D as RotationMatrix2D diff --git a/tensorflow_mri/_api/layers/__init__.py b/tensorflow_mri/_api/layers/__init__.py index e83235de..0831f246 100644 --- a/tensorflow_mri/_api/layers/__init__.py +++ b/tensorflow_mri/_api/layers/__init__.py @@ -8,7 +8,7 @@ from tensorflow_mri.python.layers.convolutional import Conv2D as Convolution2D from tensorflow_mri.python.layers.convolutional import Conv3D as Conv3D from tensorflow_mri.python.layers.convolutional import Conv3D as Convolution3D -from tensorflow_mri.python.layers.data_consistency import LeastSquaresGradientDescent as LeastSquaresGradientDescent +from tensorflow_mri.python.layers.normalization import Normalized as Normalized from tensorflow_mri.python.layers.coil_sensitivities import CoilSensitivityEstimation2D as CoilSensitivityEstimation2D from tensorflow_mri.python.layers.coil_sensitivities import CoilSensitivityEstimation3D as CoilSensitivityEstimation3D from tensorflow_mri.python.layers.conv_blocks import ConvBlock as ConvBlock diff --git a/tensorflow_mri/python/geometry/rotation_matrix.py b/tensorflow_mri/python/geometry/rotation_matrix.py new file mode 100644 index 00000000..0a6babe8 --- /dev/null +++ b/tensorflow_mri/python/geometry/rotation_matrix.py @@ -0,0 +1,164 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== + +import contextlib + +import tensorflow as tf + + +class RotationMatrix(tf.experimental.ExtensionType): + """Represents a {n}D rotation matrix. + + References: + 1. https://en.wikipedia.org/wiki/Rotation_matrix + 2. https://www.tensorflow.org/graphics/api_docs/python/tfg/geometry/transformation/rotation_matrix_2d + """ + matrix: tf.Tensor + name: str = "rotation_matrix" + + def __init__(self, matrix, name=None): + self.matrix = matrix + self.name = name or self._default_name() + + def __validate__(self): + self._validate_shape() + + def __eq__(self, other): + return tf.math.equal(self.matrix, other.matrix) + + def inverse(self, name=None): + r"""Computes the inverse of this rotation matrix. + + Args: + name: A name for this op. Defaults to `"inverse"`. + + Returns: + A `RotationMatrix{n}D` representing the inverse of this rotation matrix. + """ + with self._name_scope(name or "inverse"): + return type(self)(tf.linalg.matrix_transpose(self.matrix), + name=self.name + '_inverse') + + def is_valid(self, atol=1e-3, name=None): + r"""Determines if this matrix is a valid rotation matrix. + + A matrix $\mathbf{{R}}$ is a valid rotation matrix if + $\mathbf{{R}}^T\mathbf{{R}} = \mathbf{{I}}$ and $\det(\mathbf{{R}}) = 1$. + + Args: + atol: The absolute tolerance parameter. + name: A name for this op. Defaults to `"is_valid"`. + + Returns: + A boolean `tf.Tensor` with shape `[..., 1]`, `True` if the corresponding + matrix is valid and `False` otherwise. + """ + with self._name_scope(name or "is_valid"): + # Compute how far the determinant of the matrix is from 1. + distance_determinant = tf.abs(tf.linalg.det(self.matrix) - 1.) + + # Computes how far the product of the transposed rotation matrix with itself + # is from the identity matrix. + identity = tf.eye(tf.shape(self.matrix)[-1], dtype=self.dtype) + inverse = tf.linalg.matrix_transpose(self.matrix) + distance_identity = tf.matmul(inverse, self.matrix) - identity + distance_identity = tf.norm(distance_identity, axis=[-2, -1]) + + # Computes the mask of entries that satisfies all conditions. + mask = tf.math.logical_and(distance_determinant < atol, + distance_identity < atol) + return tf.expand_dims(mask, axis=-1) + + def rotate(self, point, name=None): + r"""Rotates a {n}D point as described by this rotation matrix. + + Args: + point: A `tf.Tensor` of shape `[..., {n}]`, where the last dimension + represents a {n}D point and `...` represents any number of batch + dimensions, which must be broadcastable with the batch shape of the + rotation matrix. + name: A name for this op. Defaults to `"rotate"`. + + Returns: + A `tf.Tensor` of shape `[..., {n}]`, where the last dimension represents + a {n}D point and `...` is the result of broadcasting the batch shapes of + `point` and this rotation matrix. + + Raises: + ValueError: If the shape of `point` is invalid. + """ + with self._name_scope(name or "rotate"): + point = tf.convert_to_tensor(point) + + if not point.shape[-1:].is_compatible_with(2): + raise ValueError( + f"point must have shape [..., 2], but got: {point.shape}") + try: + static_batch_shape = tf.broadcast_static_shape( + point.shape[:-1], self.shape[:-2]) + except ValueError as err: + raise ValueError( + f"The batch shapes of point and this rotation matrix do not " + f"broadcast: {point.shape[:-1]} vs. {self.shape[:-2]}") from err + + common_batch_shape = tf.broadcast_dynamic_shape( + tf.shape(point)[:-1], tf.shape(self.matrix)[:-2]) + point = tf.broadcast_to(point, tf.concat( + [common_batch_shape, [self._n()]], 0)) + matrix = tf.broadcast_to(self.matrix, tf.concat( + [common_batch_shape, [self._n(), self._n()]], 0)) + + rotated_point = tf.linalg.matvec(matrix, point) + + output_shape = static_batch_shape.concatenate([self._n()]) + return tf.ensure_shape(rotated_point, output_shape) + + @property + def shape(self): + """Returns the shape of this rotation matrix.""" + return self.matrix.shape + + @property + def dtype(self): + """Returns the dtype of this rotation matrix.""" + return self.matrix.dtype + + @contextlib.contextmanager + def _name_scope(self, name=None): + """Helper function to standardize op scope.""" + with tf.name_scope(self.name): + with tf.name_scope(name) as scope: + yield scope + + def _default_name(self): + return {2: 'rotation_matrix_2d', 3: 'rotation_matrix_3d'}[self._n()] + + def _validate_shape(self): + if self.matrix.shape.rank is not None: + if self.matrix.shape.rank < 2: + raise ValueError( + f"matrix must have rank >= 2, but got: {self.matrix.shape}") + if not self.matrix.shape[-2:].is_compatible_with([self._n(), self._n()]): + raise ValueError( + f"matrix must have shape [..., {self._n()}, {self._n()}], " + f"but got: {self.matrix.shape}") + + def _n(self): + return {'RotationMatrix2D': 2, 'RotationMatrix3D': 3}[type(self).__name__] + + +@tf.experimental.dispatch_for_api(tf.shape, {'input': RotationMatrix}) +def rotation_matrix_shape(input, out_type=tf.int32, name=None): + return tf.shape(input.matrix, out_type=out_type, name=name) diff --git a/tensorflow_mri/python/geometry/rotation_matrix_2d.py b/tensorflow_mri/python/geometry/rotation_matrix_2d.py index 9f984293..5e9d836b 100644 --- a/tensorflow_mri/python/geometry/rotation_matrix_2d.py +++ b/tensorflow_mri/python/geometry/rotation_matrix_2d.py @@ -13,108 +13,142 @@ # limitations under the License. # ============================================================================== +# Copyright 2020 The TensorFlow Authors +# +# 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 +# +# https://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. +# ============================================================================== +"""2D rotation matrix.""" +# This file is partly inspired by TensorFlow Graphics. + import tensorflow as tf +from tensorflow_mri.python.geometry import rotation_matrix from tensorflow_mri.python.util import api_util -@api_util.export("geometry.euler_to_rotation_matrix_2d") -def from_euler(angle, name=None): - r"""Converts an angle to a 2D rotation matrix. - - Converts an angle $$\theta$$ to a 2D rotation matrix following the equation - - $$ - \mathbf{R} = - \begin{bmatrix} - \cos(\theta) & -\sin(\theta) \\ - \sin(\theta) & \cos(\theta) - \end{bmatrix}. - $$ - - Note: - The resulting matrix rotates points in the $$xy$$-plane counterclockwise. - - Args: - angle: A tensor of shape `[..., 1]`, where the last dimension - represents an angle in radians. - name: A name for this op. - - Returns: - A tensor of shape `[..., 2, 2]`, where the last dimension represents - a 2D rotation matrix. - - Raises: - ValueError: If the shape of `angle` is invalid. - - References: - This operator is based on - `tfg.geometry.transformation.rotation_matrix_2d.from_euler`. - """ - with tf.name_scope(name or "euler_to_rotation_matrix_2d"): - angle = tf.convert_to_tensor(angle) - - if not angle.shape[-1:].is_compatible_with([1]): - raise ValueError( - f"angle must have shape `[..., 1]`, but got: {angle.shape}") - - cos_angle = tf.cos(angle) - sin_angle = tf.sin(angle) - matrix = tf.stack((cos_angle, -sin_angle, - sin_angle, cos_angle), - axis=-1) - output_shape = tf.concat((tf.shape(input=angle)[:-1], (2, 2)), axis=-1) - return tf.reshape(matrix, shape=output_shape) - - -@api_util.export("geometry.rotate_with_rotation_matrix_2d") -def rotate(point, matrix, name=None): - """Rotates a 2D point using a 2D rotation matrix. - - Args: - point: A tensor of shape `[..., 2]`, where the last dimension - represents a 2D point and `...` represents any number of batch dimensions. - matrix: A tensor of shape `[..., 2, 2]`, where the last two - dimensions represent a 2D rotation matrix and `...` represents any - number of batch dimensions, which must be broadcastable with those in - shape. - name: A name for this op. - - Returns: - A tensor of shape `[..., 2]`, where the last dimension represents a 2D - point and `...` is the result of broadcasting the batch shapes of `point` - and `matrix`. - - Raises: - ValueError: If the shape of `point` or `matrix` is not supported. - - References: - This operator is based on - `tfg.geometry.transformation.rotation_matrix_2d.rotate`. - """ - with tf.name_scope(name or "rotate_with_rotation_matrix_2d"): - point = tf.convert_to_tensor(point) - matrix = tf.convert_to_tensor(matrix) - - if not point.shape[-1:].is_compatible_with(2): - raise ValueError( - f"point must have shape [..., 2], but got: {point.shape}") - if (not matrix.shape[-1:].is_compatible_with([2]) or - not matrix.shape[-2:-1].is_compatible_with([2])): - raise ValueError( - f"matrix must have shape [..., 2, 2], but got: {matrix.shape}") - try: - static_batch_shape = tf.broadcast_static_shape(point.shape[:-1], - matrix.shape[:-2]) - except ValueError as err: - raise ValueError( - f"The batch shapes of point and matrix could not be broadcasted. " - f"Received: {point.shape} and {matrix.shape}") from err - - common_batch_shape = tf.broadcast_dynamic_shape(tf.shape(point)[:-1], - tf.shape(matrix)[:-2]) - - point = tf.broadcast_to(point, tf.concat([common_batch_shape, [2]], 0)) - matrix = tf.broadcast_to(matrix, tf.concat([common_batch_shape, [2, 2]], 0)) - rotated_point = tf.linalg.matvec(matrix, point) - return tf.ensure_shape(rotated_point, static_batch_shape.concatenate([2])) +FORMAT_KWARGS = dict(n=2) + + +@api_util.export("geometry.RotationMatrix2D") +class RotationMatrix2D(rotation_matrix.RotationMatrix): + __doc__ = rotation_matrix.RotationMatrix.__doc__.format(**FORMAT_KWARGS) + + @classmethod + def from_euler(cls, angle, name=None): + r"""Creates a rotation matrix from an angle. + + Converts an angle $\theta$ to a 2D rotation matrix following the equation + + $$ + \mathbf{R} = + \begin{bmatrix} + \cos(\theta) & -\sin(\theta) \\ + \sin(\theta) & \cos(\theta) + \end{bmatrix}. + $$ + + ```{note} + The resulting matrix rotates points in the $xy$-plane counterclockwise. + ``` + + Args: + angle: A `tf.Tensor` of shape `[..., 1]`, where the last dimension + represents an angle in radians. + name: A name for this op. Defaults to `"from_euler"`. + + Returns: + A `RotationMatrix2D`. + + Raises: + ValueError: If the shape of `angle` is invalid. + """ + name = name or "from_euler" + with tf.name_scope(f"rotation_matrix_2d/{name}"): + angle = tf.convert_to_tensor(angle) + + if not angle.shape[-1:].is_compatible_with([1]): + raise ValueError( + f"angle must have shape `[..., 1]`, but got: {angle.shape}") + + cos_angle = tf.math.cos(angle) + sin_angle = tf.math.sin(angle) + matrix = tf.stack([cos_angle, -sin_angle, sin_angle, cos_angle], axis=-1) + output_shape = tf.concat([tf.shape(angle)[:-1], [2, 2]], axis=-1) + return cls(tf.reshape(matrix, output_shape)) + + @classmethod + def from_euler_with_small_angles_approximation(cls, angle, name=None): + r"""Creates a rotation matrix from an angle using small angle approximation. + + Under the small angle assumption, $\sin(x)$ and $\cos(x)$ can be + approximated by their second order Taylor expansions, where + $\sin(x) \approx x$ and $\cos(x) \approx 1 - \frac{x^2}{2}$. The 2D + rotation matrix will then be approximated as + + $$ + \mathbf{R} = + \begin{bmatrix} + 1.0 - 0.5\theta^2 & -\theta \\ + \theta & 1.0 - 0.5\theta^2 + \end{bmatrix}. + $$ + + ```{note} + The resulting matrix rotates points in the $xy$-plane counterclockwise. + ``` + + ```{note} + This function does not verify the smallness of the angles. + ``` + + Args: + angle: A `tf.Tensor` of shape `[..., 1]`, where the last dimension + represents an angle in radians. + name: A name for this op. Defaults to + "from_euler_with_small_angles_approximation". + + Returns: + A `RotationMatrix2D`. + + Raises: + ValueError: If the shape of `angle` is invalid. + """ + name = name or "from_euler_with_small_angles_approximation" + with tf.name_scope(f"rotation_matrix_2d/{name}"): + angle = tf.convert_to_tensor(angle) + + if not angle.shape[-1:].is_compatible_with([1]): + raise ValueError( + f"angle must have shape `[..., 1]`, but got: {angle.shape}") + + cos_angle = 1.0 - 0.5 * angle * angle + sin_angle = angle + matrix = tf.stack([cos_angle, -sin_angle, sin_angle, cos_angle], axis=-1) + output_shape = tf.concat([tf.shape(angle)[:-1], [2, 2]], axis=-1) + return cls(tf.reshape(matrix, output_shape)) + + # The following methods are overridden only to generate the docstrings. + def inverse(self, name=None): + return super().inverse(name=name) + inverse.__doc__ = rotation_matrix.RotationMatrix.inverse.__doc__.format( + **FORMAT_KWARGS) + + def is_valid(self, atol=1e-3, name=None): + return super().is_valid(atol=atol, name=name) + is_valid.__doc__ = rotation_matrix.RotationMatrix.is_valid.__doc__.format( + **FORMAT_KWARGS) + + def rotate(self, point, name=None): + return super().rotate(point=point, name=name) + rotate.__doc__ = rotation_matrix.RotationMatrix.rotate.__doc__.format( + **FORMAT_KWARGS) diff --git a/tensorflow_mri/python/geometry/rotation_matrix_2d_test.py b/tensorflow_mri/python/geometry/rotation_matrix_2d_test.py index 55be2441..7264f644 100644 --- a/tensorflow_mri/python/geometry/rotation_matrix_2d_test.py +++ b/tensorflow_mri/python/geometry/rotation_matrix_2d_test.py @@ -28,95 +28,43 @@ # limitations under the License. # ============================================================================== """Tests for module `rotation_matrix_2d`.""" -# This file is copied from TensorFlow graphics. We're testing TFMRI's -# `rotation_matrix_2d` module, which is very similar to the TFG module of the -# same name, so we reuse those tests. For those functions that are not yet -# available in TFMRI, we use TFG's functions. +# This file is partly inspired by TensorFlow Graphics. -from absl.testing import flagsaver from absl.testing import parameterized import numpy as np +import tensorflow as tf -# TODO(jmontalt): Remove these lines when the `rotation_matrix_2d` module is -# fully implemented. -from tensorflow_graphics.geometry.transformation import rotation_matrix_2d as tfg_rotation_matrix_2d -from tensorflow_graphics.geometry.transformation.tests import test_data as td -from tensorflow_graphics.geometry.transformation.tests import test_helpers -from tensorflow_graphics.util import test_case +from tensorflow_mri.python.geometry import test_data as td +from tensorflow_mri.python.geometry import test_helpers +from tensorflow_mri.python.geometry.rotation_matrix_2d import RotationMatrix2D +from tensorflow_mri.python.util import test_util -from tensorflow_mri.python.geometry import rotation_matrix_2d +class RotationMatrix2DTest(test_util.TestCase): + """Tests for `RotationMatrix2D`.""" + def test_shape(self): + matrix = RotationMatrix2D.from_euler([0.0]) + self.assertAllEqual([2, 2], matrix.shape) + self.assertAllEqual([2, 2], tf.shape(matrix)) -class RotationMatrix2dTest(test_case.TestCase): - - @parameterized.parameters( - ((1,)), - ((None, 1),), - ) - def test_from_euler_exception_not_raised(self, *shapes): - """Tests that the shape exceptions are not raised.""" - self.assert_exception_is_not_raised(rotation_matrix_2d.from_euler, shapes) - - @parameterized.parameters( - ("must have exactly 1 dimensions in axis -1", (None,)),) - def test_from_euler_exception_raised(self, error_msg, *shapes): - """Tests that the shape exceptions are properly raised.""" - self.assert_exception_is_raised(rotation_matrix_2d.from_euler, error_msg, - shapes) - - @flagsaver.flagsaver(tfg_add_asserts_to_graph=False) - def test_from_euler_jacobian_preset(self): - """Test the Jacobian of the from_euler function.""" - x_init = test_helpers.generate_preset_test_euler_angles(dimensions=1) - - self.assert_jacobian_is_correct_fn(rotation_matrix_2d.from_euler, [x_init]) - - @flagsaver.flagsaver(tfg_add_asserts_to_graph=False) - def test_from_euler_jacobian_random(self): - """Test the Jacobian of the from_euler function.""" - x_init = test_helpers.generate_random_test_euler_angles(dimensions=1) - - self.assert_jacobian_is_correct_fn(rotation_matrix_2d.from_euler, [x_init]) - - def test_from_euler_normalized_preset(self): + def test_from_euler_normalized(self): """Tests that an angle maps to correct matrix.""" euler_angles = test_helpers.generate_preset_test_euler_angles(dimensions=1) - matrix = rotation_matrix_2d.from_euler(euler_angles) - - self.assertAllEqual( - tfg_rotation_matrix_2d.is_valid(matrix), - np.ones(euler_angles.shape[0:-1] + (1,), dtype=bool)) + matrix = RotationMatrix2D.from_euler(euler_angles) + self.assertAllEqual(np.ones(euler_angles.shape[0:-1] + (1,), dtype=bool), + matrix.is_valid()) - @parameterized.parameters( - ((td.ANGLE_0,), (td.MAT_2D_ID,)), - ((td.ANGLE_45,), (td.MAT_2D_45,)), - ((td.ANGLE_90,), (td.MAT_2D_90,)), - ((td.ANGLE_180,), (td.MAT_2D_180,)), + @parameterized.named_parameters( + ("0", td.ANGLE_0, td.MAT_2D_ID), + ("45", td.ANGLE_45, td.MAT_2D_45), + ("90", td.ANGLE_90, td.MAT_2D_90), + ("180", td.ANGLE_180, td.MAT_2D_180), ) - def test_from_euler_preset(self, test_inputs, test_outputs): + def test_from_euler(self, angle, expected): """Tests that an angle maps to correct matrix.""" - self.assert_output_is_correct(rotation_matrix_2d.from_euler, test_inputs, - test_outputs) - - @parameterized.parameters( - ((1,),), - ((None, 1),), - ) - def test_from_euler_with_small_angles_approximation_exception_not_raised( - self, *shapes): - """Tests that the shape exceptions are not raised.""" - self.assert_exception_is_not_raised( - tfg_rotation_matrix_2d.from_euler_with_small_angles_approximation, shapes) - - @parameterized.parameters( - ("must have exactly 1 dimensions in axis -1", (None,)),) - def test_from_euler_with_small_angles_approximation_exception_raised( - self, error_msg, *shape): - """Tests that the shape exceptions are raised.""" - self.assert_exception_is_raised( - tfg_rotation_matrix_2d.from_euler_with_small_angles_approximation, - error_msg, shape) + matrix = RotationMatrix2D.from_euler(angle) + self.assertAllClose(expected, matrix.matrix) def test_from_euler_with_small_angles_approximation_random(self): """Tests small_angles approximation by comparing to exact calculation.""" @@ -125,44 +73,14 @@ def test_from_euler_with_small_angles_approximation_random(self): random_euler_angles = test_helpers.generate_random_test_euler_angles( min_angle=-0.17, max_angle=0.17, dimensions=1) - exact_matrix = rotation_matrix_2d.from_euler(random_euler_angles) + exact_matrix = RotationMatrix2D.from_euler( + random_euler_angles) approximate_matrix = ( - tfg_rotation_matrix_2d.from_euler_with_small_angles_approximation( + RotationMatrix2D.from_euler_with_small_angles_approximation( random_euler_angles)) - self.assertAllClose(exact_matrix, approximate_matrix, atol=1e-3) - - @parameterized.parameters( - ((2, 2),), - ((None, 2, 2),), - ) - def test_inverse_exception_not_raised(self, *shapes): - """Tests that the shape exceptions are not raised.""" - self.assert_exception_is_not_raised(tfg_rotation_matrix_2d.inverse, shapes) - - @parameterized.parameters( - ("must have a rank greater than 1", (2,)), - ("must have exactly 2 dimensions in axis -1", (2, None)), - ("must have exactly 2 dimensions in axis -2", (None, 2)), - ) - def test_inverse_exception_raised(self, error_msg, *shapes): - """Checks the inputs of the inverse function.""" - self.assert_exception_is_raised(tfg_rotation_matrix_2d.inverse, error_msg, - shapes) - - @flagsaver.flagsaver(tfg_add_asserts_to_graph=False) - def test_inverse_jacobian_preset(self): - """Test the Jacobian of the inverse function.""" - x_init = test_helpers.generate_preset_test_rotation_matrices_2d() - - self.assert_jacobian_is_correct_fn(tfg_rotation_matrix_2d.inverse, [x_init]) - - @flagsaver.flagsaver(tfg_add_asserts_to_graph=False) - def test_inverse_jacobian_random(self): - """Test the Jacobian of the inverse function.""" - x_init = test_helpers.generate_random_test_rotation_matrix_2d() - - self.assert_jacobian_is_correct_fn(tfg_rotation_matrix_2d.inverse, [x_init]) + self.assertAllClose(exact_matrix.matrix, approximate_matrix.matrix, + atol=1e-3) def test_inverse_random(self): """Checks that inverting rotated points results in no transformation.""" @@ -170,90 +88,24 @@ def test_inverse_random(self): dimensions=1) tensor_shape = random_euler_angles.shape[:-1] - random_matrix = rotation_matrix_2d.from_euler(random_euler_angles) + random_matrix = RotationMatrix2D.from_euler(random_euler_angles) random_point = np.random.normal(size=tensor_shape + (2,)) - rotated_random_points = rotation_matrix_2d.rotate(random_point, - random_matrix) - predicted_invert_random_matrix = tfg_rotation_matrix_2d.inverse(random_matrix) - predicted_invert_rotated_random_points = rotation_matrix_2d.rotate( - rotated_random_points, predicted_invert_random_matrix) + rotated_random_points = random_matrix.rotate(random_point) + predicted_invert_random_matrix = random_matrix.inverse() + predicted_invert_rotated_random_points = ( + predicted_invert_random_matrix.rotate(rotated_random_points)) - self.assertAllClose( - random_point, predicted_invert_rotated_random_points, rtol=1e-6) - - @parameterized.parameters( - ((2, 2),), - ((None, 2, 2),), - ) - def test_is_valid_exception_not_raised(self, *shapes): - """Tests that the shape exceptions are not raised.""" - self.assert_exception_is_not_raised(tfg_rotation_matrix_2d.inverse, shapes) - - @parameterized.parameters( - ("must have a rank greater than 1", (2,)), - ("must have exactly 2 dimensions in axis -1", (2, None)), - ("must have exactly 2 dimensions in axis -2", (None, 2)), - ) - def test_is_valid_exception_raised(self, error_msg, *shape): - """Tests that the shape exceptions are raised.""" - self.assert_exception_is_raised(tfg_rotation_matrix_2d.is_valid, error_msg, - shape) - - @parameterized.parameters( - ((2,), (2, 2)), - ((None, 2), (None, 2, 2)), - ((1, 2), (1, 2, 2)), - ((2, 2), (2, 2, 2)), - ((2,), (1, 2, 2)), - ((1, 2), (2, 2)), - ) - def test_rotate_exception_not_raised(self, *shapes): - """Tests that the shape exceptions are not raised.""" - self.assert_exception_is_not_raised(rotation_matrix_2d.rotate, shapes) + self.assertAllClose(random_point, predicted_invert_rotated_random_points) - @parameterized.parameters( - ("matrix must have shape", (None,), (2, 2)), - ("matrix must have shape", (2,), (2,)), - ("matrix must have shape", (2,), (2, None)), - ("matrix must have shape", (2,), (None, 2)), + @parameterized.named_parameters( + ("preset1", td.AXIS_2D_0, td.ANGLE_90, td.AXIS_2D_0), + ("preset2", td.AXIS_2D_X, td.ANGLE_90, td.AXIS_2D_Y), ) - def test_rotate_exception_raised(self, error_msg, *shape): - """Tests that the shape exceptions are properly raised.""" - self.assert_exception_is_raised(rotation_matrix_2d.rotate, error_msg, shape) - - @flagsaver.flagsaver(tfg_add_asserts_to_graph=False) - def test_rotate_jacobian_preset(self): - """Test the Jacobian of the rotate function.""" - x_matrix_init = test_helpers.generate_preset_test_rotation_matrices_2d() - tensor_shape = x_matrix_init.shape[:-2] + (2,) - x_point_init = np.random.uniform(size=tensor_shape) - - self.assert_jacobian_is_correct_fn(rotation_matrix_2d.rotate, - [x_point_init, x_matrix_init]) - - @flagsaver.flagsaver(tfg_add_asserts_to_graph=False) - def test_rotate_jacobian_random(self): - """Test the Jacobian of the rotate function.""" - x_matrix_init = test_helpers.generate_random_test_rotation_matrix_2d() - tensor_shape = x_matrix_init.shape[:-2] + (2,) - x_point_init = np.random.uniform(size=tensor_shape) - - self.assert_jacobian_is_correct_fn(rotation_matrix_2d.rotate, - [x_point_init, x_matrix_init]) - - @parameterized.parameters( - ((td.AXIS_2D_0, td.ANGLE_90), (td.AXIS_2D_0,)), - ((td.AXIS_2D_X, td.ANGLE_90), (td.AXIS_2D_Y,)), - ) - def test_rotate_preset(self, test_inputs, test_outputs): + def test_rotate(self, point, angle, expected): """Tests that the rotate function correctly rotates points.""" - - def func(test_point, test_angle): - random_matrix = rotation_matrix_2d.from_euler(test_angle) - return rotation_matrix_2d.rotate(test_point, random_matrix) - - self.assert_output_is_correct(func, test_inputs, test_outputs) + result = RotationMatrix2D.from_euler(angle).rotate(point) + self.assertAllClose(expected, result) if __name__ == "__main__": - test_case.main() + tf.test.main() diff --git a/tensorflow_mri/python/geometry/test_data.py b/tensorflow_mri/python/geometry/test_data.py new file mode 100644 index 00000000..3e288c7f --- /dev/null +++ b/tensorflow_mri/python/geometry/test_data.py @@ -0,0 +1,136 @@ +# Copyright 2020 The TensorFlow Authors +# +# 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 +# +# https://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. +"""Module with test data for transformation tests.""" +# This file is copied from TensorFlow Graphics. + +import numpy as np + +ANGLE_0 = np.array((0.,)) +ANGLE_45 = np.array((np.pi / 4.,)) +ANGLE_90 = np.array((np.pi / 2.,)) +ANGLE_180 = np.array((np.pi,)) + +AXIS_2D_0 = np.array((0., 0.)) +AXIS_2D_X = np.array((1., 0.)) +AXIS_2D_Y = np.array((0., 1.)) + + +def _rotation_2d_x(angle): + """Creates a 2d rotation matrix. + + Args: + angle: The angle. + + Returns: + The 2d rotation matrix. + """ + angle = angle.item() + return np.array(((np.cos(angle), -np.sin(angle)), + (np.sin(angle), np.cos(angle)))) # pyformat: disable + + +MAT_2D_ID = np.eye(2) +MAT_2D_45 = _rotation_2d_x(ANGLE_45) +MAT_2D_90 = _rotation_2d_x(ANGLE_90) +MAT_2D_180 = _rotation_2d_x(ANGLE_180) + +AXIS_3D_0 = np.array((0., 0., 0.)) +AXIS_3D_X = np.array((1., 0., 0.)) +AXIS_3D_Y = np.array((0., 1., 0.)) +AXIS_3D_Z = np.array((0., 0., 1.)) + + +def _axis_angle_to_quaternion(axis, angle): + """Converts an axis-angle representation to a quaternion. + + Args: + axis: The axis of rotation. + angle: The angle. + + Returns: + The quaternion. + """ + quat = np.zeros(4) + quat[0:3] = axis * np.sin(0.5 * angle) + quat[3] = np.cos(0.5 * angle) + return quat + + +QUAT_ID = _axis_angle_to_quaternion(AXIS_3D_0, ANGLE_0) +QUAT_X_45 = _axis_angle_to_quaternion(AXIS_3D_X, ANGLE_45) +QUAT_X_90 = _axis_angle_to_quaternion(AXIS_3D_X, ANGLE_90) +QUAT_X_180 = _axis_angle_to_quaternion(AXIS_3D_X, ANGLE_180) +QUAT_Y_45 = _axis_angle_to_quaternion(AXIS_3D_Y, ANGLE_45) +QUAT_Y_90 = _axis_angle_to_quaternion(AXIS_3D_Y, ANGLE_90) +QUAT_Y_180 = _axis_angle_to_quaternion(AXIS_3D_Y, ANGLE_180) +QUAT_Z_45 = _axis_angle_to_quaternion(AXIS_3D_Z, ANGLE_45) +QUAT_Z_90 = _axis_angle_to_quaternion(AXIS_3D_Z, ANGLE_90) +QUAT_Z_180 = _axis_angle_to_quaternion(AXIS_3D_Z, ANGLE_180) + + +def _rotation_3d_x(angle): + """Creates a 3d rotation matrix around the x axis. + + Args: + angle: The angle. + + Returns: + The 3d rotation matrix. + """ + angle = angle.item() + return np.array(((1., 0., 0.), + (0., np.cos(angle), -np.sin(angle)), + (0., np.sin(angle), np.cos(angle)))) # pyformat: disable + + +def _rotation_3d_y(angle): + """Creates a 3d rotation matrix around the y axis. + + Args: + angle: The angle. + + Returns: + The 3d rotation matrix. + """ + angle = angle.item() + return np.array(((np.cos(angle), 0., np.sin(angle)), + (0., 1., 0.), + (-np.sin(angle), 0., np.cos(angle)))) # pyformat: disable + + +def _rotation_3d_z(angle): + """Creates a 3d rotation matrix around the z axis. + + Args: + angle: The angle. + + Returns: + The 3d rotation matrix. + """ + angle = angle.item() + return np.array(((np.cos(angle), -np.sin(angle), 0.), + (np.sin(angle), np.cos(angle), 0.), + (0., 0., 1.))) # pyformat: disable + + +MAT_3D_ID = np.eye(3) +MAT_3D_X_45 = _rotation_3d_x(ANGLE_45) +MAT_3D_X_90 = _rotation_3d_x(ANGLE_90) +MAT_3D_X_180 = _rotation_3d_x(ANGLE_180) +MAT_3D_Y_45 = _rotation_3d_y(ANGLE_45) +MAT_3D_Y_90 = _rotation_3d_y(ANGLE_90) +MAT_3D_Y_180 = _rotation_3d_y(ANGLE_180) +MAT_3D_Z_45 = _rotation_3d_z(ANGLE_45) +MAT_3D_Z_90 = _rotation_3d_z(ANGLE_90) +MAT_3D_Z_180 = _rotation_3d_z(ANGLE_180) diff --git a/tensorflow_mri/python/geometry/test_helpers.py b/tensorflow_mri/python/geometry/test_helpers.py new file mode 100644 index 00000000..c5f553b5 --- /dev/null +++ b/tensorflow_mri/python/geometry/test_helpers.py @@ -0,0 +1,275 @@ +# Copyright 2020 The TensorFlow Authors +# +# 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 +# +# https://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. +"""Test helpers for the transformation module.""" +# This file is copied from TensorFlow Graphics. + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import itertools +import math + +import numpy as np +from scipy import stats +from six.moves import range +import tensorflow.compat.v2 as tf + +from tensorflow_graphics.geometry.transformation import axis_angle +from tensorflow_graphics.geometry.transformation import quaternion +from tensorflow_graphics.geometry.transformation import rotation_matrix_2d +from tensorflow_graphics.geometry.transformation import rotation_matrix_3d + + +def generate_preset_test_euler_angles(dimensions=3): + """Generates a permutation with duplicate of some classic euler angles.""" + permutations = itertools.product( + [0., np.pi, np.pi / 2., np.pi / 3., np.pi / 4., np.pi / 6.], + repeat=dimensions) + return np.array(list(permutations)) + + +def generate_preset_test_translations(dimensions=3): + """Generates a set of translations.""" + permutations = itertools.product([0.1, -0.2, 0.5, 0.7, 0.4, -0.1], + repeat=dimensions) + return np.array(list(permutations)) + + +def generate_preset_test_rotation_matrices_3d(): + """Generates pre-set test 3d rotation matrices.""" + angles = generate_preset_test_euler_angles() + preset_rotation_matrix = rotation_matrix_3d.from_euler(angles) + return preset_rotation_matrix + + +def generate_preset_test_rotation_matrices_2d(): + """Generates pre-set test 2d rotation matrices.""" + angles = generate_preset_test_euler_angles(dimensions=1) + preset_rotation_matrix = rotation_matrix_2d.from_euler(angles) + return preset_rotation_matrix + + +def generate_preset_test_axis_angle(): + """Generates pre-set test rotation matrices.""" + angles = generate_preset_test_euler_angles() + axis, angle = axis_angle.from_euler(angles) + return axis, angle + + +def generate_preset_test_quaternions(): + """Generates pre-set test quaternions.""" + angles = generate_preset_test_euler_angles() + preset_quaternion = quaternion.from_euler(angles) + return preset_quaternion + + +def generate_preset_test_dual_quaternions(): + """Generates pre-set test quaternions.""" + angles = generate_preset_test_euler_angles() + preset_quaternion_real = quaternion.from_euler(angles) + + translations = generate_preset_test_translations() + translations = np.concatenate( + (translations / 2.0, np.zeros((np.ma.size(translations, 0), 1))), axis=1) + preset_quaternion_translation = tf.convert_to_tensor(value=translations) + + preset_quaternion_dual = quaternion.multiply(preset_quaternion_translation, + preset_quaternion_real) + + preset_dual_quaternion = tf.concat( + (preset_quaternion_real, preset_quaternion_dual), axis=-1) + + return preset_dual_quaternion + + +def generate_random_test_euler_angles_translations( + dimensions=3, + min_angle=-3.0 * np.pi, + max_angle=3.0 * np.pi, + min_translation=3.0, + max_translation=3.0): + """Generates random test random Euler angles and translations.""" + tensor_dimensions = np.random.randint(3) + tensor_tile = np.random.randint(1, 10, tensor_dimensions).tolist() + return (np.random.uniform(min_angle, max_angle, tensor_tile + [dimensions]), + np.random.uniform(min_translation, max_translation, + tensor_tile + [dimensions])) + + +def generate_random_test_dual_quaternions(): + """Generates random test dual quaternions.""" + angles = generate_random_test_euler_angles() + random_quaternion_real = quaternion.from_euler(angles) + + min_translation = -3.0 + max_translation = 3.0 + translations = np.random.uniform(min_translation, max_translation, + angles.shape) + + translations_quaternion_shape = np.asarray(translations.shape) + translations_quaternion_shape[-1] = 1 + translations = np.concatenate( + (translations / 2.0, np.zeros(translations_quaternion_shape)), axis=-1) + + random_quaternion_translation = tf.convert_to_tensor(value=translations) + + random_quaternion_dual = quaternion.multiply(random_quaternion_translation, + random_quaternion_real) + + random_dual_quaternion = tf.concat( + (random_quaternion_real, random_quaternion_dual), axis=-1) + + return random_dual_quaternion + + +def generate_random_test_euler_angles(dimensions=3, + min_angle=-3. * np.pi, + max_angle=3. * np.pi): + """Generates random test random Euler angles.""" + tensor_dimensions = np.random.randint(3) + tensor_tile = np.random.randint(1, 10, tensor_dimensions).tolist() + return np.random.uniform(min_angle, max_angle, tensor_tile + [dimensions]) + + +def generate_random_test_quaternions(tensor_shape=None): + """Generates random test quaternions.""" + if tensor_shape is None: + tensor_dimensions = np.random.randint(low=1, high=3) + tensor_shape = np.random.randint(1, 10, size=(tensor_dimensions)).tolist() + u1 = np.random.uniform(0.0, 1.0, tensor_shape) + u2 = np.random.uniform(0.0, 2.0 * math.pi, tensor_shape) + u3 = np.random.uniform(0.0, 2.0 * math.pi, tensor_shape) + a = np.sqrt(1.0 - u1) + b = np.sqrt(u1) + return np.stack((a * np.sin(u2), + a * np.cos(u2), + b * np.sin(u3), + b * np.cos(u3)), + axis=-1) # pyformat: disable + + +def generate_random_test_axis_angle(): + """Generates random test axis-angles.""" + tensor_dimensions = np.random.randint(3) + tensor_shape = np.random.randint(1, 10, size=(tensor_dimensions)).tolist() + random_axis = np.random.uniform(size=tensor_shape + [3]) + random_axis /= np.linalg.norm(random_axis, axis=-1, keepdims=True) + random_angle = np.random.uniform(size=tensor_shape + [1]) + return random_axis, random_angle + + +def generate_random_test_rotation_matrix_3d(): + """Generates random test 3d rotation matrices.""" + random_matrix = np.array( + [stats.special_ortho_group.rvs(3) for _ in range(20)]) + return np.reshape(random_matrix, [5, 4, 3, 3]) + + +def generate_random_test_rotation_matrix_2d(): + """Generates random test 2d rotation matrices.""" + random_matrix = np.array( + [stats.special_ortho_group.rvs(2) for _ in range(20)]) + return np.reshape(random_matrix, [5, 4, 2, 2]) + + +def generate_random_test_lbs_blend(): + """Generates random test for the linear blend skinning blend function.""" + tensor_dimensions = np.random.randint(3) + tensor_shape = np.random.randint(1, 10, size=(tensor_dimensions)).tolist() + random_points = np.random.uniform(size=tensor_shape + [3]) + num_weights = np.random.randint(2, 10) + random_weights = np.random.uniform(size=tensor_shape + [num_weights]) + random_weights /= np.sum(random_weights, axis=-1, keepdims=True) + + random_rotations = np.array( + [stats.special_ortho_group.rvs(3) for _ in range(num_weights)]) + random_rotations = np.reshape(random_rotations, [num_weights, 3, 3]) + random_translations = np.random.uniform(size=[num_weights, 3]) + return random_points, random_weights, random_rotations, random_translations + + +def generate_preset_test_lbs_blend(): + """Generates preset test for the linear blend skinning blend function.""" + points = np.array([[[1.0, 0.0, 0.0], [0.1, 0.2, 0.5]], + [[0.0, 1.0, 0.0], [0.3, -0.5, 0.2]], + [[-0.3, 0.1, 0.3], [0.1, -0.9, -0.4]]]) + weights = np.array([[[0.0, 1.0, 0.0, 0.0], [0.4, 0.2, 0.3, 0.1]], + [[0.6, 0.0, 0.4, 0.0], [0.2, 0.2, 0.1, 0.5]], + [[0.0, 0.1, 0.0, 0.9], [0.1, 0.2, 0.3, 0.4]]]) + rotations = np.array( + [[[[1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0]], + [[0.36, 0.48, -0.8], + [-0.8, 0.60, 0.00], + [0.48, 0.64, 0.60]], + [[0.0, 0.0, 1.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0]], + [[0.0, 1.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 0.0, -1.0]]], + [[[-0.41554751, -0.42205085, -0.80572535], + [0.08028719, -0.89939186, 0.42970716], + [-0.9060211, 0.11387432, 0.40762533]], + [[-0.05240625, -0.24389111, 0.96838562], + [0.99123384, -0.13047444, 0.02078231], + [0.12128095, 0.96098572, 0.2485908]], + [[-0.32722936, -0.06793413, -0.94249981], + [-0.70574479, 0.68082693, 0.19595657], + [0.62836712, 0.72928708, -0.27073072]], + [[-0.22601332, -0.95393284, 0.19730719], + [-0.01189659, 0.20523618, 0.97864017], + [-0.97405157, 0.21883843, -0.05773466]]]]) # pyformat: disable + translations = np.array( + [[[0.1, -0.2, 0.5], + [-0.2, 0.7, 0.7], + [0.8, -0.2, 0.4], + [-0.1, 0.2, -0.3]], + [[0.5, 0.6, 0.9], + [-0.1, -0.3, -0.7], + [0.4, -0.2, 0.8], + [0.7, 0.8, -0.4]]]) # pyformat: disable + blended_points = np.array([[[[0.16, -0.1, 1.18], [0.3864, 0.148, 0.7352]], + [[0.38, 0.4, 0.86], [-0.2184, 0.152, 0.0088]], + [[-0.05, 0.01, -0.46], [-0.3152, -0.004, + -0.1136]]], + [[[-0.15240625, 0.69123384, -0.57871905], + [0.07776242, 0.33587402, 0.55386645]], + [[0.17959584, 0.01269566, 1.22003942], + [0.71406514, 0.6187734, -0.43794053]], + [[0.67662743, 0.94549789, -0.14946982], + [0.88587099, -0.09324637, -0.45012815]]]]) + + return points, weights, rotations, translations, blended_points + + +def generate_random_test_axis_angle_translation(): + """Generates random test angles, axes, translations.""" + tensor_dimensions = np.random.randint(3) + tensor_shape = np.random.randint(1, 10, size=(tensor_dimensions)).tolist() + random_axis = np.random.uniform(size=tensor_shape + [3]) + random_axis /= np.linalg.norm(random_axis, axis=-1, keepdims=True) + random_angle = np.random.uniform(size=tensor_shape + [1]) + random_translation = np.random.uniform(size=tensor_shape + [3]) + return random_axis, random_angle, random_translation + + +def generate_random_test_points(): + """Generates random 3D points.""" + tensor_dimensions = np.random.randint(3) + tensor_shape = np.random.randint(1, 10, size=(tensor_dimensions)).tolist() + random_point = np.random.uniform(size=tensor_shape + [3]) + return random_point diff --git a/tensorflow_mri/python/layers/normalization.py b/tensorflow_mri/python/layers/normalization.py index 1b55b03a..ffd6aa1d 100644 --- a/tensorflow_mri/python/layers/normalization.py +++ b/tensorflow_mri/python/layers/normalization.py @@ -28,14 +28,14 @@ class Normalized(tf.keras.layers.Wrapper): with a standard deviation of 1 before passing them to the wrapped layer. $$ - x = (x - \mu) / \sigma + x = \frac{x - \mu}{\sigma} $$ After applying the wrapped layer, the outputs are scaled back to the original distribution. $$ - y = y \sigma + \mu + y = \sigma y + \mu $$ Args: diff --git a/tensorflow_mri/python/ops/traj_ops.py b/tensorflow_mri/python/ops/traj_ops.py index 650cb36c..621196b0 100755 --- a/tensorflow_mri/python/ops/traj_ops.py +++ b/tensorflow_mri/python/ops/traj_ops.py @@ -1037,9 +1037,6 @@ def _rotate_waveform_2d(waveform, angles): # Prepare for broadcasting. angles = tf.expand_dims(angles, -2) - # Compute rotation matrix. - rot_matrix = rotation_matrix_2d.from_euler(angles) - # Add leading singleton dimensions to `waveform` to match the batch shape of # `angles`. This prevents a broadcasting error later. waveform = tf.reshape(waveform, @@ -1047,7 +1044,7 @@ def _rotate_waveform_2d(waveform, angles): tf.shape(waveform)], 0)) # Apply rotation. - return rotation_matrix_2d.rotate(waveform, rot_matrix) + return rotation_matrix_2d.RotationMatrix2D.from_euler(angles).rotate(waveform) def _rotate_waveform_3d(waveform, angles): From b7eb06e7836320ffcbc04dcebce9f4791719b8a9 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Sat, 27 Aug 2022 13:16:21 +0000 Subject: [PATCH 050/101] Removed TF Graphics dependency --- RELEASE.md | 2 +- requirements.txt | 1 - tensorflow_mri/__init__.py | 1 - tensorflow_mri/_api/geometry/__init__.py | 3 +- tensorflow_mri/python/geometry/__init__.py | 3 +- .../python/geometry/rotation/__init__.py | 0 .../python/geometry/rotation/quaternion.py | 141 ++++++++++ .../geometry/rotation/rotation_matrix.py | 135 ++++++++++ .../geometry/rotation/rotation_matrix_2d.py | 139 ++++++++++ .../geometry/rotation/rotation_matrix_3d.py | 241 +++++++++++++++++ .../geometry/{ => rotation}/test_data.py | 0 .../geometry/{ => rotation}/test_helpers.py | 15 +- tensorflow_mri/python/geometry/rotation_2d.py | 226 ++++++++++++++++ ..._matrix_2d_test.py => rotation_2d_test.py} | 50 ++-- tensorflow_mri/python/geometry/rotation_3d.py | 255 ++++++++++++++++++ .../python/geometry/rotation_3d_test.py | 239 ++++++++++++++++ .../python/geometry/rotation_matrix.py | 164 ----------- .../python/geometry/rotation_matrix_2d.py | 154 ----------- .../linalg/linear_operator_gram_nufft_test.py | 5 +- tensorflow_mri/python/ops/geom_ops.py | 181 ------------- tensorflow_mri/python/ops/geom_ops_test.py | 15 -- tensorflow_mri/python/ops/image_ops.py | 9 +- tensorflow_mri/python/ops/traj_ops.py | 138 +++++++++- tools/build/create_api.py | 1 - 24 files changed, 1554 insertions(+), 564 deletions(-) create mode 100644 tensorflow_mri/python/geometry/rotation/__init__.py create mode 100644 tensorflow_mri/python/geometry/rotation/quaternion.py create mode 100644 tensorflow_mri/python/geometry/rotation/rotation_matrix.py create mode 100644 tensorflow_mri/python/geometry/rotation/rotation_matrix_2d.py create mode 100644 tensorflow_mri/python/geometry/rotation/rotation_matrix_3d.py rename tensorflow_mri/python/geometry/{ => rotation}/test_data.py (100%) rename tensorflow_mri/python/geometry/{ => rotation}/test_helpers.py (95%) create mode 100644 tensorflow_mri/python/geometry/rotation_2d.py rename tensorflow_mri/python/geometry/{rotation_matrix_2d_test.py => rotation_2d_test.py} (72%) create mode 100644 tensorflow_mri/python/geometry/rotation_3d.py create mode 100644 tensorflow_mri/python/geometry/rotation_3d_test.py delete mode 100644 tensorflow_mri/python/geometry/rotation_matrix.py delete mode 100644 tensorflow_mri/python/geometry/rotation_matrix_2d.py delete mode 100644 tensorflow_mri/python/ops/geom_ops.py delete mode 100644 tensorflow_mri/python/ops/geom_ops_test.py diff --git a/RELEASE.md b/RELEASE.md index 86be8dee..a89ebb12 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -10,7 +10,7 @@ - `tfmri.geometry`: - - Added new extension type `RotationMatrix2D`. + - Added new extension types `Rotation2D` and `Rotation3D`. - `tfmri.layers`: diff --git a/requirements.txt b/requirements.txt index 916dc593..995788bd 100755 --- a/requirements.txt +++ b/requirements.txt @@ -7,7 +7,6 @@ PyWavelets scipy tensorboard tensorflow>=2.9.0,<2.10.0 -tensorflow-graphics tensorflow-io>=0.26.0 tensorflow-nufft>=0.8.0 tensorflow-probability>=0.16.0 diff --git a/tensorflow_mri/__init__.py b/tensorflow_mri/__init__.py index 8a0a8cf3..7c3373bc 100644 --- a/tensorflow_mri/__init__.py +++ b/tensorflow_mri/__init__.py @@ -11,7 +11,6 @@ from tensorflow_mri.python.ops.coil_ops import * from tensorflow_mri.python.ops.convex_ops import * from tensorflow_mri.python.ops.fft_ops import * -from tensorflow_mri.python.ops.geom_ops import * from tensorflow_mri.python.ops.image_ops import * from tensorflow_mri.python.ops.math_ops import * from tensorflow_mri.python.ops.optimizer_ops import * diff --git a/tensorflow_mri/_api/geometry/__init__.py b/tensorflow_mri/_api/geometry/__init__.py index 079e8787..8a791278 100644 --- a/tensorflow_mri/_api/geometry/__init__.py +++ b/tensorflow_mri/_api/geometry/__init__.py @@ -2,4 +2,5 @@ # Do not edit. """Geometric operations.""" -from tensorflow_mri.python.geometry.rotation_matrix_2d import RotationMatrix2D as RotationMatrix2D +from tensorflow_mri.python.geometry.rotation_2d import Rotation2D as Rotation2D +from tensorflow_mri.python.geometry.rotation_3d import Rotation3D as Rotation3D diff --git a/tensorflow_mri/python/geometry/__init__.py b/tensorflow_mri/python/geometry/__init__.py index 110f09d9..29dd1576 100644 --- a/tensorflow_mri/python/geometry/__init__.py +++ b/tensorflow_mri/python/geometry/__init__.py @@ -14,4 +14,5 @@ # ============================================================================== """Geometric operations.""" -from tensorflow_mri.python.geometry import rotation_matrix_2d +from tensorflow_mri.python.geometry import rotation_2d +from tensorflow_mri.python.geometry import rotation_3d diff --git a/tensorflow_mri/python/geometry/rotation/__init__.py b/tensorflow_mri/python/geometry/rotation/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tensorflow_mri/python/geometry/rotation/quaternion.py b/tensorflow_mri/python/geometry/rotation/quaternion.py new file mode 100644 index 00000000..5287710e --- /dev/null +++ b/tensorflow_mri/python/geometry/rotation/quaternion.py @@ -0,0 +1,141 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== + +# Copyright 2020 The TensorFlow Authors +# +# 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 +# +# https://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. +# ============================================================================== +"""Quaternions.""" + +import tensorflow as tf + + +def from_euler(angles): + """Converts Euler angles to a quaternion. + + Args: + angles: A `tf.Tensor` of shape `[..., 3]`. + + Returns: + A `tf.Tensor` of shape `[..., 4]`. + + Raises: + ValueError: If the shape of `angles` is invalid. + """ + angles = tf.convert_to_tensor(angles) + + if angles.shape[-1] != 3: + raise ValueError(f"angles must have shape `[..., 3]`, " + f"but got: {angles.shape}") + + half_angles = angles / 2.0 + cos_half_angles = tf.math.cos(half_angles) + sin_half_angles = tf.math.sin(half_angles) + return _build_quaternion_from_sines_and_cosines(sin_half_angles, + cos_half_angles) + + +def from_small_euler(angles): + """Converts small Euler angles to a quaternion. + + Args: + angles: A `tf.Tensor` of shape `[..., 3]`. + + Returns: + A `tf.Tensor` of shape `[..., 4]`. + + Raises: + ValueError: If the shape of `angles` is invalid. + """ + angles = tf.convert_to_tensor(angles) + + if angles.shape[-1] != 3: + raise ValueError(f"angles must have shape `[..., 3]`, " + f"but got: {angles.shape}") + + half_angles = angles / 2.0 + cos_half_angles = 1.0 - 0.5 * half_angles * half_angles + sin_half_angles = half_angles + quaternion = _build_quaternion_from_sines_and_cosines( + sin_half_angles, cos_half_angles) + + # We need to normalize the quaternion due to the small angle approximation. + return tf.nn.l2_normalize(quaternion, axis=-1) + + +def _build_quaternion_from_sines_and_cosines(sin_half_angles, cos_half_angles): + """Builds a quaternion from sines and cosines of half Euler angles. + + Args: + sin_half_angles: A tensor of shape `[..., 3]`, where the last + dimension represents the sine of half Euler angles. + cos_half_angles: A tensor of shape `[..., 3]`, where the last + dimension represents the cosine of half Euler angles. + + Returns: + A `tf.Tensor` of shape `[..., 4]`, where the last dimension represents + a quaternion. + """ + c1, c2, c3 = tf.unstack(cos_half_angles, axis=-1) + s1, s2, s3 = tf.unstack(sin_half_angles, axis=-1) + w = c1 * c2 * c3 + s1 * s2 * s3 + x = -c1 * s2 * s3 + s1 * c2 * c3 + y = c1 * s2 * c3 + s1 * c2 * s3 + z = -s1 * s2 * c3 + c1 * c2 * s3 + return tf.stack((x, y, z, w), axis=-1) + + +def multiply(quaternion1, quaternion2): + """Multiplies two quaternions. + + Args: + quaternion1: A `tf.Tensor` of shape `[..., 4]`, where the last dimension + represents a quaternion. + quaternion2: A `tf.Tensor` of shape `[..., 4]`, where the last dimension + represents a quaternion. + + Returns: + A `tf.Tensor` of shape `[..., 4]` representing quaternions. + + Raises: + ValueError: If the shape of `quaternion1` or `quaternion2` is invalid. + """ + quaternion1 = tf.convert_to_tensor(value=quaternion1) + quaternion2 = tf.convert_to_tensor(value=quaternion2) + + if quaternion1.shape[-1] != 4: + raise ValueError(f"quaternion1 must have shape `[..., 4]`, " + f"but got: {quaternion1.shape}") + if quaternion2.shape[-1] != 4: + raise ValueError(f"quaternion2 must have shape `[..., 4]`, " + f"but got: {quaternion2.shape}") + + x1, y1, z1, w1 = tf.unstack(quaternion1, axis=-1) + x2, y2, z2, w2 = tf.unstack(quaternion2, axis=-1) + x = x1 * w2 + y1 * z2 - z1 * y2 + w1 * x2 + y = -x1 * z2 + y1 * w2 + z1 * x2 + w1 * y2 + z = x1 * y2 - y1 * x2 + z1 * w2 + w1 * z2 + w = -x1 * x2 - y1 * y2 - z1 * z2 + w1 * w2 + return tf.stack((x, y, z, w), axis=-1) diff --git a/tensorflow_mri/python/geometry/rotation/rotation_matrix.py b/tensorflow_mri/python/geometry/rotation/rotation_matrix.py new file mode 100644 index 00000000..bff15b19 --- /dev/null +++ b/tensorflow_mri/python/geometry/rotation/rotation_matrix.py @@ -0,0 +1,135 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== + +# Copyright 2020 The TensorFlow Authors +# +# 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 +# +# https://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. +# ============================================================================== +"""Rotation matrices.""" + +import tensorflow as tf + + +def rotate(n, point, matrix): + """Rotates an N-D point using rotation matrix. + + Args: + n: An `int`. The dimension of the point and matrix. + point: A `tf.Tensor` of shape `[..., N]`. + matrix: A `tf.Tensor` of shape `[..., N, N]`. + + Returns: + A `tf.Tensor` of shape `[..., N]`. + """ + point = tf.convert_to_tensor(point) + matrix = tf.convert_to_tensor(matrix) + + if point.shape[-1] != n: + raise ValueError( + f"point must have shape [..., {n}], but got: {point.shape}") + if matrix.shape[-1] != n or matrix.shape[-2] != n: + raise ValueError( + f"matrix must have shape [..., {n}, {n}], but got: {matrix.shape}") + try: + static_batch_shape = tf.broadcast_static_shape( + point.shape[:-1], matrix.shape[:-2]) + except ValueError as err: + raise ValueError( + f"The batch shapes of point and this rotation matrix do not " + f"broadcast: {point.shape[:-1]} vs. {matrix.shape[:-2]}") from err + + common_batch_shape = tf.broadcast_dynamic_shape( + tf.shape(point)[:-1], tf.shape(matrix)[:-2]) + point = tf.broadcast_to(point, tf.concat( + [common_batch_shape, [n]], 0)) + matrix = tf.broadcast_to(matrix, tf.concat( + [common_batch_shape, [n, n]], 0)) + + rotated_point = tf.linalg.matvec(matrix, point) + output_shape = static_batch_shape.concatenate([n]) + return tf.ensure_shape(rotated_point, output_shape) + + +def inverse(n, matrix): + """Inverts an N-D rotation matrix. + + Args: + n: An `int`. The dimension of the matrix. + matrix: A `tf.Tensor` of shape `[..., N, N]`. + + Returns: + A `tf.Tensor` of shape `[..., N, N]`. + """ + matrix = tf.convert_to_tensor(matrix) + + if matrix.shape[-1] != n or matrix.shape[-2] != n: + raise ValueError( + f"matrix must have shape [..., {n}, {n}], but got: {matrix.shape}") + + return tf.linalg.matrix_transpose(matrix) + + +def is_valid(n, matrix, atol=1e-3): + """Checks if an N-D rotation matrix is valid. + + Args: + n: An `int`. The dimension of the matrix. + matrix: A `tf.Tensor` of shape `[..., N, N]`. + atol: A `float`. The absolute tolerance for checking if the matrix is valid. + + Returns: + A boolean `tf.Tensor` of shape `[..., 1]`. + """ + matrix = tf.convert_to_tensor(matrix) + + if matrix.shape[-1] != n or matrix.shape[-2] != n: + raise ValueError( + f"matrix must have shape [..., {n}, {n}], but got: {matrix.shape}") + + # Compute how far the determinant of the matrix is from 1. + distance_determinant = tf.abs(tf.linalg.det(matrix) - 1.) + + # Computes how far the product of the transposed rotation matrix with itself + # is from the identity matrix. + identity = tf.eye(n, dtype=matrix.dtype) + inverse = tf.linalg.matrix_transpose(matrix) + distance_identity = tf.matmul(inverse, matrix) - identity + distance_identity = tf.norm(distance_identity, axis=[-2, -1]) + + # Computes the mask of entries that satisfies all conditions. + mask = tf.math.logical_and(distance_determinant < atol, + distance_identity < atol) + return tf.expand_dims(mask, axis=-1) + + +def check_shape(n, matrix): + matrix = tf.convert_to_tensor(matrix) + if matrix.shape.rank is not None and matrix.shape.rank < 2: + raise ValueError( + f"matrix must have rank >= 2, but got: {matrix.shape}") + if matrix.shape[-2] != n or matrix.shape[-1] != n: + raise ValueError( + f"matrix must have shape [..., {n}, {n}], " + f"but got: {matrix.shape}") diff --git a/tensorflow_mri/python/geometry/rotation/rotation_matrix_2d.py b/tensorflow_mri/python/geometry/rotation/rotation_matrix_2d.py new file mode 100644 index 00000000..1a178017 --- /dev/null +++ b/tensorflow_mri/python/geometry/rotation/rotation_matrix_2d.py @@ -0,0 +1,139 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== + +# Copyright 2020 The TensorFlow Authors +# +# 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 +# +# https://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. +# ============================================================================== +"""2D rotation matrices.""" + +import tensorflow as tf + +from tensorflow_mri.python.geometry.rotation import rotation_matrix + + +def from_euler(angle): + """Converts an angle to a 2D rotation matrix. + + Args: + angle: A `tf.Tensor` of shape `[..., 1]`. + + Returns: + A `tf.Tensor` of shape `[..., 2, 2]`. + + Raises: + ValueError: If the shape of `angle` is invalid. + """ + angle = tf.convert_to_tensor(angle) + + if angle.shape[-1] != 1: + raise ValueError( + f"angle must have shape `[..., 1]`, but got: {angle.shape}") + + cos_angle = tf.math.cos(angle) + sin_angle = tf.math.sin(angle) + matrix = tf.stack([cos_angle, -sin_angle, sin_angle, cos_angle], axis=-1) + output_shape = tf.concat([tf.shape(angle)[:-1], [2, 2]], axis=-1) + return tf.reshape(matrix, output_shape) + + +def from_small_euler(angle): + """Converts a small angle to a 2D rotation matrix. + + Args: + angle: A `tf.Tensor` of shape `[..., 1]`. + + Returns: + A `tf.Tensor` of shape `[..., 2, 2]`. + + Raises: + ValueError: If the shape of `angle` is invalid. + """ + angle = tf.convert_to_tensor(angle) + + if angle.shape[-1] != 1: + raise ValueError( + f"angle must have shape `[..., 1]`, but got: {angle.shape}") + + cos_angle = 1.0 - 0.5 * angle * angle + sin_angle = angle + matrix = tf.stack([cos_angle, -sin_angle, sin_angle, cos_angle], axis=-1) + output_shape = tf.concat([tf.shape(angle)[:-1], [2, 2]], axis=-1) + return tf.reshape(matrix, output_shape) + + +def inverse(matrix): + """Inverts a 2D rotation matrix. + + Args: + matrix: A `tf.Tensor` of shape `[..., 2, 2]`. + + Returns: + A `tf.Tensor` of shape `[..., 2, 2]`. + + Raises: + ValueError: If the shape of `matrix` is invalid. + """ + return rotation_matrix.inverse(2, matrix) + + +def is_valid(matrix, atol=1e-3): + """Checks if a 2D rotation matrix is valid. + + Args: + matrix: A `tf.Tensor` of shape `[..., 2, 2]`. + + Returns: + A `tf.Tensor` of shape `[..., 1]` indicating whether the matrix is valid. + """ + return rotation_matrix.is_valid(2, matrix, atol=atol) + + +def rotate(point, matrix): + """Rotates a 2D point using rotation matrix. + + Args: + point: A `tf.Tensor` of shape `[..., 2]`. + matrix: A `tf.Tensor` of shape `[..., 2, 2]`. + + Returns: + A `tf.Tensor` of shape `[..., 2]`. + + Raises: + ValueError: If the shape of `point` or `matrix` is invalid. + """ + return rotation_matrix.rotate(2, point, matrix) + + +def check_shape(matrix): + """Checks the shape of `point` and `matrix`. + + Args: + matrix: A `tf.Tensor` of shape `[..., 2, 2]`. + + Raises: + ValueError: If the shape of `matrix` is invalid. + """ + rotation_matrix.check_shape(2, matrix) diff --git a/tensorflow_mri/python/geometry/rotation/rotation_matrix_3d.py b/tensorflow_mri/python/geometry/rotation/rotation_matrix_3d.py new file mode 100644 index 00000000..ed00d534 --- /dev/null +++ b/tensorflow_mri/python/geometry/rotation/rotation_matrix_3d.py @@ -0,0 +1,241 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== + +# Copyright 2020 The TensorFlow Authors +# +# 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 +# +# https://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. +# ============================================================================== +"""3D rotation matrices.""" + +import tensorflow as tf + +from tensorflow_mri.python.geometry.rotation import rotation_matrix + + +def from_euler(angles): + """Converts Euler angles to a 3D rotation matrix. + + Args: + angles: A `tf.Tensor` of shape `[..., 3]`. + + Returns: + A `tf.Tensor` of shape `[..., 3, 3]`. + + Raises: + ValueError: If the shape of `angles` is invalid. + """ + angles = tf.convert_to_tensor(angles) + + if angles.shape[-1] != 3: + raise ValueError( + f"angles must have shape `[..., 3]`, but got: {angles.shape}") + + sin_angles = tf.math.sin(angles) + cos_angles = tf.math.cos(angles) + return _build_matrix_from_sines_and_cosines(sin_angles, cos_angles) + + +def from_small_euler(angles): + """Converts small Euler angles to a 3D rotation matrix. + + Args: + angles: A `tf.Tensor` of shape `[..., 3]`. + + Returns: + A `tf.Tensor` of shape `[..., 3, 3]`. + + Raises: + ValueError: If the shape of `angles` is invalid. + """ + angles = tf.convert_to_tensor(angles) + + if angles.shape[-1:] != 3: + raise ValueError( + f"angles must have shape `[..., 3]`, but got: {angles.shape}") + + sin_angles = angles + cos_angles = 1.0 - 0.5 * tf.math.square(angles) + return _build_matrix_from_sines_and_cosines(sin_angles, cos_angles) + + +def from_axis_angle(axis, angle): + """Converts an axis-angle to a 3D rotation matrix.""" + axis = tf.convert_to_tensor(axis) + angle = tf.convert_to_tensor(angle) + + if axis.shape[-1] != 3: + raise ValueError( + f"axis must have shape `[..., 3]`, but got: {axis.shape}") + if angle.shape[-1:] != 1: + raise ValueError( + f"angle must have shape `[..., 1]`, but got: {angle.shape}") + + try: + static_batch_shape = tf.broadcast_static_shape( + axis.shape[:-1], angle.shape[:-1]) + except ValueError as err: + raise ValueError( + f"The batch shapes of axis and angle do not " + f"broadcast: {axis.shape[:-1]} vs. {angle.shape[:-1]}") from err + + sin_axis = tf.sin(angle) * axis + cos_angle = tf.cos(angle) + cos1_axis = (1.0 - cos_angle) * axis + _, axis_y, axis_z = tf.unstack(axis, axis=-1) + cos1_axis_x, cos1_axis_y, _ = tf.unstack(cos1_axis, axis=-1) + sin_axis_x, sin_axis_y, sin_axis_z = tf.unstack(sin_axis, axis=-1) + tmp = cos1_axis_x * axis_y + m01 = tmp - sin_axis_z + m10 = tmp + sin_axis_z + tmp = cos1_axis_x * axis_z + m02 = tmp + sin_axis_y + m20 = tmp - sin_axis_y + tmp = cos1_axis_y * axis_z + m12 = tmp - sin_axis_x + m21 = tmp + sin_axis_x + diag = cos1_axis * axis + cos_angle + diag_x, diag_y, diag_z = tf.unstack(diag, axis=-1) + matrix = tf.stack([diag_x, m01, m02, + m10, diag_y, m12, + m20, m21, diag_z], axis=-1) + output_shape = tf.concat([tf.shape(axis)[:-1], [3, 3]], axis=-1) + return tf.reshape(matrix, output_shape) + + +def from_quaternion(quaternion): + """Converts a quaternion to a 3D rotation matrix.""" + quaternion = tf.convert_to_tensor(quaternion) + + if quaternion.shape[-1] != 4: + raise ValueError(f"quaternion must have shape `[..., 4]`, ", + f"but got: {quaternion.shape}") + + x, y, z, w = tf.unstack(quaternion, axis=-1) + tx = 2.0 * x + ty = 2.0 * y + tz = 2.0 * z + twx = tx * w + twy = ty * w + twz = tz * w + txx = tx * x + txy = ty * x + txz = tz * x + tyy = ty * y + tyz = tz * y + tzz = tz * z + matrix = tf.stack([1.0 - (tyy + tzz), txy - twz, txz + twy, + txy + twz, 1.0 - (txx + tzz), tyz - twx, + txz - twy, tyz + twx, 1.0 - (txx + tyy)], axis=-1) + output_shape = tf.concat([tf.shape(quaternion)[:-1], [3, 3]], axis=-1) + return tf.reshape(matrix, output_shape) + + +def _build_matrix_from_sines_and_cosines(sin_angles, cos_angles): + """Builds a 3D rotation matrix from sines and cosines of Euler angles. + + Args: + sin_angles: A tensor of shape `[..., 3]`, where the last dimension + represents the sine of the Euler angles. + cos_angles: A tensor of shape `[..., 3]`, where the last dimension + represents the cosine of the Euler angles. + + Returns: + A `tf.Tensor` of shape `[..., 3, 3]`, where the last two dimensions + represent a 3D rotation matrix. + """ + sin_angles.shape.assert_is_compatible_with(cos_angles.shape) + + sx, sy, sz = tf.unstack(sin_angles, axis=-1) + cx, cy, cz = tf.unstack(cos_angles, axis=-1) + m00 = cy * cz + m01 = (sx * sy * cz) - (cx * sz) + m02 = (cx * sy * cz) + (sx * sz) + m10 = cy * sz + m11 = (sx * sy * sz) + (cx * cz) + m12 = (cx * sy * sz) - (sx * cz) + m20 = -sy + m21 = sx * cy + m22 = cx * cy + matrix = tf.stack([m00, m01, m02, + m10, m11, m12, + m20, m21, m22], + axis=-1) + output_shape = tf.concat([tf.shape(sin_angles)[:-1], [3, 3]], axis=-1) + return tf.reshape(matrix, output_shape) + + +def inverse(matrix): + """Inverts a 3D rotation matrix. + + Args: + matrix: A `tf.Tensor` of shape `[..., 3, 3]`. + + Returns: + A `tf.Tensor` of shape `[..., 3, 3]`. + + Raises: + ValueError: If the shape of `matrix` is invalid. + """ + return rotation_matrix.inverse(3, matrix) + + +def is_valid(matrix, atol=1e-3): + """Checks if a 3D rotation matrix is valid. + + Args: + matrix: A `tf.Tensor` of shape `[..., 3, 3]`. + + Returns: + A `tf.Tensor` of shape `[..., 1]` indicating whether the matrix is valid. + """ + return rotation_matrix.is_valid(3, matrix, atol=atol) + + +def rotate(point, matrix): + """Rotates a 3D point using rotation matrix. + + Args: + point: A `tf.Tensor` of shape `[..., 3]`. + matrix: A `tf.Tensor` of shape `[..., 3, 3]`. + + Returns: + A `tf.Tensor` of shape `[..., 3]`. + + Raises: + ValueError: If the shape of `point` or `matrix` is invalid. + """ + return rotation_matrix.rotate(3, point, matrix) + + +def check_shape(matrix): + """Checks the shape of `point` and `matrix`. + + Args: + matrix: A `tf.Tensor` of shape `[..., 3, 3]`. + + Raises: + ValueError: If the shape of `matrix` is invalid. + """ + rotation_matrix.check_shape(3, matrix) diff --git a/tensorflow_mri/python/geometry/test_data.py b/tensorflow_mri/python/geometry/rotation/test_data.py similarity index 100% rename from tensorflow_mri/python/geometry/test_data.py rename to tensorflow_mri/python/geometry/rotation/test_data.py diff --git a/tensorflow_mri/python/geometry/test_helpers.py b/tensorflow_mri/python/geometry/rotation/test_helpers.py similarity index 95% rename from tensorflow_mri/python/geometry/test_helpers.py rename to tensorflow_mri/python/geometry/rotation/test_helpers.py index c5f553b5..cb26aa03 100644 --- a/tensorflow_mri/python/geometry/test_helpers.py +++ b/tensorflow_mri/python/geometry/rotation/test_helpers.py @@ -14,22 +14,17 @@ """Test helpers for the transformation module.""" # This file is copied from TensorFlow Graphics. -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - import itertools import math import numpy as np from scipy import stats from six.moves import range -import tensorflow.compat.v2 as tf +import tensorflow as tf -from tensorflow_graphics.geometry.transformation import axis_angle -from tensorflow_graphics.geometry.transformation import quaternion -from tensorflow_graphics.geometry.transformation import rotation_matrix_2d -from tensorflow_graphics.geometry.transformation import rotation_matrix_3d +from tensorflow_mri.python.geometry.rotation import rotation_matrix_2d +from tensorflow_mri.python.geometry.rotation import rotation_matrix_3d +from tensorflow_mri.python.geometry.rotation import quaternion def generate_preset_test_euler_angles(dimensions=3): @@ -64,7 +59,7 @@ def generate_preset_test_rotation_matrices_2d(): def generate_preset_test_axis_angle(): """Generates pre-set test rotation matrices.""" angles = generate_preset_test_euler_angles() - axis, angle = axis_angle.from_euler(angles) + axis, angle = rotation_matrix_3d.from_axis_angle(angles) return axis, angle diff --git a/tensorflow_mri/python/geometry/rotation_2d.py b/tensorflow_mri/python/geometry/rotation_2d.py new file mode 100644 index 00000000..5d5cacb5 --- /dev/null +++ b/tensorflow_mri/python/geometry/rotation_2d.py @@ -0,0 +1,226 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""2D rotation.""" + +import contextlib + +import tensorflow as tf + +from tensorflow_mri.python.geometry.rotation import rotation_matrix_2d +from tensorflow_mri.python.util import api_util + + +@api_util.export("geometry.Rotation2D") +class Rotation2D(tf.experimental.ExtensionType): + """Represents a 2D rotation (or a batch thereof).""" + _matrix: tf.Tensor + _name: str = "rotation_2d" + + @classmethod + def from_matrix(cls, matrix, name=None): + r"""Creates a 2D rotation from a rotation matrix. + + Args: + matrix: A `tf.Tensor` of shape `[..., 2, 2]`, where `...` represents + any number of batch dimensions. + name: A name for this op. Defaults to `"rotation_2d/from_matrix"`. + + Returns: + A `Rotation2D`. + """ + name = name or "rotation_2d/from_matrix" + with tf.name_scope(name): + return cls(_matrix=matrix, _name=name) + + @classmethod + def from_euler(cls, angle, name=None): + r"""Creates a 2D rotation from an angle. + + The resulting rotation acts like the following rotation matrix: + + $$ + \mathbf{R} = + \begin{bmatrix} + \cos(\theta) & -\sin(\theta) \\ + \sin(\theta) & \cos(\theta) + \end{bmatrix}. + $$ + + ```{note} + The resulting rotation rotates points in the $xy$-plane counterclockwise. + ``` + + Args: + angle: A `tf.Tensor` of shape `[..., 1]`, where the last dimension + represents an angle in radians. + name: A name for this op. Defaults to `"rotation_2d/from_euler"`. + + Returns: + A `Rotation2D`. + + Raises: + ValueError: If the shape of `angle` is invalid. + """ + name = name or "rotation_2d/from_euler" + with tf.name_scope(name): + return cls(_matrix=rotation_matrix_2d.from_euler(angle), _name=name) + + @classmethod + def from_small_euler(cls, angle, name=None): + r"""Creates a 2D rotation from a small angle. + + Uses the small angle approximation to compute the rotation. Under the + small angle assumption, $\sin(x)$$ and $$\cos(x)$ can be approximated by + their second order Taylor expansions, where $\sin(x) \approx x$ and + $\cos(x) \approx 1 - \frac{x^2}{2}$. + + The resulting rotation acts like the following rotation matrix: + + $$ + \mathbf{R} = + \begin{bmatrix} + 1.0 - 0.5\theta^2 & -\theta \\ + \theta & 1.0 - 0.5\theta^2 + \end{bmatrix}. + $$ + + ```{note} + The resulting rotation rotates points in the $xy$-plane counterclockwise. + ``` + + ```{note} + This function does not verify the smallness of the angles. + ``` + + Args: + angle: A `tf.Tensor` of shape `[..., 1]`, where the last dimension + represents an angle in radians. + name: A name for this op. Defaults to "rotation_2d/from_small_euler". + + Returns: + A `Rotation2D`. + + Raises: + ValueError: If the shape of `angle` is invalid. + """ + name = name or "rotation_2d/from_small_euler" + with tf.name_scope(name): + return cls(_matrix=rotation_matrix_2d.from_small_euler(angle), _name=name) + + def as_matrix(self, name=None): + r"""Returns the rotation matrix that represents this rotation. + + Args: + name: A name for this op. Defaults to `"as_matrix"`. + + Returns: + A `tf.Tensor` of shape `[..., 2, 2]`. + """ + with self._name_scope(name or "as_matrix"): + return tf.identity(self._matrix) + + def inverse(self, name=None): + r"""Computes the inverse of this rotation. + + Args: + name: A name for this op. Defaults to `"inverse"`. + + Returns: + A `Rotation2D` representing the inverse of this rotation. + """ + with self._name_scope(name or "inverse"): + return Rotation2D(_matrix=rotation_matrix_2d.inverse(self._matrix), + _name=self._name + "/inverse") + + def is_valid(self, atol=1e-3, name=None): + r"""Determines if this is a valid rotation. + + A rotation matrix $\mathbf{R}$ is a valid rotation matrix if + $\mathbf{R}^T\mathbf{R} = \mathbf{I}$ and $\det(\mathbf{R}) = 1$. + + Args: + atol: A `float`. The absolute tolerance parameter. + name: A name for this op. Defaults to `"is_valid"`. + + Returns: + A boolean `tf.Tensor` with shape `[..., 1]`, `True` if the corresponding + matrix is valid and `False` otherwise. + """ + with self._name_scope(name or "is_valid"): + return rotation_matrix_2d.is_valid(self._matrix, atol=atol) + + def rotate(self, point, name=None): + r"""Rotates a 2D point. + + Args: + point: A `tf.Tensor` of shape `[..., 2]`, where the last dimension + represents a 2D point and `...` represents any number of batch + dimensions, which must be broadcastable with the batch shape of this + rotation. + name: A name for this op. Defaults to `"rotate"`. + + Returns: + A `tf.Tensor` of shape `[..., 2]`, where the last dimension represents + a 2D point and `...` is the result of broadcasting the batch shapes of + `point` and this rotation matrix. + + Raises: + ValueError: If the shape of `point` is invalid. + """ + with self._name_scope(name or "rotate"): + return rotation_matrix_2d.rotate(point, self._matrix) + + def __eq__(self, other): + """Returns true if this rotation is equivalent to the other rotation.""" + return tf.math.reduce_all( + tf.math.equal(self._matrix, other._matrix), axis=[-2, -1]) + + def __matmul__(self, other): + """Composes this rotation with another rotation.""" + return Rotation2D(_matrix=self._matrix @ other._matrix,) + + def __validate__(self): + """Checks that this rotation is a valid rotation. + + Only performs static checks. + """ + rotation_matrix_2d.check_shape(self._matrix) + + @property + def shape(self): + """Returns the shape of this rotation.""" + return self._matrix.shape[:-2] + + @property + def dtype(self): + """Returns the dtype of this rotation.""" + return self._matrix.dtype + + @property + def name(self): + """Returns the name of this rotation.""" + return self._name + + @contextlib.contextmanager + def _name_scope(self, name=None): + """Helper function to standardize op scope.""" + with tf.name_scope(self.name): + with tf.name_scope(name) as scope: + yield scope + + +@tf.experimental.dispatch_for_api(tf.shape, {'input': Rotation2D}) +def rotation_2d_shape(input, out_type=tf.int32, name=None): + return tf.shape(input._matrix, out_type=out_type, name=name)[:-2] diff --git a/tensorflow_mri/python/geometry/rotation_matrix_2d_test.py b/tensorflow_mri/python/geometry/rotation_2d_test.py similarity index 72% rename from tensorflow_mri/python/geometry/rotation_matrix_2d_test.py rename to tensorflow_mri/python/geometry/rotation_2d_test.py index 7264f644..d536ec35 100644 --- a/tensorflow_mri/python/geometry/rotation_matrix_2d_test.py +++ b/tensorflow_mri/python/geometry/rotation_2d_test.py @@ -27,33 +27,41 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== -"""Tests for module `rotation_matrix_2d`.""" +"""Tests for 2D rotation.""" # This file is partly inspired by TensorFlow Graphics. from absl.testing import parameterized import numpy as np import tensorflow as tf -from tensorflow_mri.python.geometry import test_data as td -from tensorflow_mri.python.geometry import test_helpers -from tensorflow_mri.python.geometry.rotation_matrix_2d import RotationMatrix2D +from tensorflow_mri.python.geometry.rotation import test_data as td +from tensorflow_mri.python.geometry.rotation import test_helpers +from tensorflow_mri.python.geometry.rotation_2d import Rotation2D from tensorflow_mri.python.util import test_util class RotationMatrix2DTest(test_util.TestCase): - """Tests for `RotationMatrix2D`.""" + """Tests for `Rotation2D`.""" def test_shape(self): - matrix = RotationMatrix2D.from_euler([0.0]) - self.assertAllEqual([2, 2], matrix.shape) - self.assertAllEqual([2, 2], tf.shape(matrix)) + rot = Rotation2D.from_euler([0.0]) + self.assertAllEqual([], rot.shape) + self.assertAllEqual([], tf.shape(rot)) + + rot = Rotation2D.from_euler([[0.0], [np.pi]]) + self.assertAllEqual([2], rot.shape) + self.assertAllEqual([2], tf.shape(rot)) + + def test_from_matrix(self): + rot = Rotation2D.from_matrix(np.eye(2)) + self.assertAllClose(np.eye(2), rot.as_matrix()) def test_from_euler_normalized(self): """Tests that an angle maps to correct matrix.""" euler_angles = test_helpers.generate_preset_test_euler_angles(dimensions=1) - matrix = RotationMatrix2D.from_euler(euler_angles) + rot = Rotation2D.from_euler(euler_angles) self.assertAllEqual(np.ones(euler_angles.shape[0:-1] + (1,), dtype=bool), - matrix.is_valid()) + rot.is_valid()) @parameterized.named_parameters( ("0", td.ANGLE_0, td.MAT_2D_ID), @@ -63,23 +71,19 @@ def test_from_euler_normalized(self): ) def test_from_euler(self, angle, expected): """Tests that an angle maps to correct matrix.""" - matrix = RotationMatrix2D.from_euler(angle) - self.assertAllClose(expected, matrix.matrix) + self.assertAllClose(expected, Rotation2D.from_euler(angle).as_matrix()) def test_from_euler_with_small_angles_approximation_random(self): - """Tests small_angles approximation by comparing to exact calculation.""" + """Tests small angles approximation by comparing to exact calculation.""" # Only generate small angles. For a test tolerance of 1e-3, 0.17 was found # empirically to be the range where the small angle approximation works. random_euler_angles = test_helpers.generate_random_test_euler_angles( min_angle=-0.17, max_angle=0.17, dimensions=1) - exact_matrix = RotationMatrix2D.from_euler( - random_euler_angles) - approximate_matrix = ( - RotationMatrix2D.from_euler_with_small_angles_approximation( - random_euler_angles)) + exact_rot = Rotation2D.from_euler(random_euler_angles) + approx_rot = Rotation2D.from_small_euler(random_euler_angles) - self.assertAllClose(exact_matrix.matrix, approximate_matrix.matrix, + self.assertAllClose(exact_rot.as_matrix(), approx_rot.as_matrix(), atol=1e-3) def test_inverse_random(self): @@ -88,10 +92,10 @@ def test_inverse_random(self): dimensions=1) tensor_shape = random_euler_angles.shape[:-1] - random_matrix = RotationMatrix2D.from_euler(random_euler_angles) + random_rot = Rotation2D.from_euler(random_euler_angles) random_point = np.random.normal(size=tensor_shape + (2,)) - rotated_random_points = random_matrix.rotate(random_point) - predicted_invert_random_matrix = random_matrix.inverse() + rotated_random_points = random_rot.rotate(random_point) + predicted_invert_random_matrix = random_rot.inverse() predicted_invert_rotated_random_points = ( predicted_invert_random_matrix.rotate(rotated_random_points)) @@ -103,7 +107,7 @@ def test_inverse_random(self): ) def test_rotate(self, point, angle, expected): """Tests that the rotate function correctly rotates points.""" - result = RotationMatrix2D.from_euler(angle).rotate(point) + result = Rotation2D.from_euler(angle).rotate(point) self.assertAllClose(expected, result) diff --git a/tensorflow_mri/python/geometry/rotation_3d.py b/tensorflow_mri/python/geometry/rotation_3d.py new file mode 100644 index 00000000..7f09c7bc --- /dev/null +++ b/tensorflow_mri/python/geometry/rotation_3d.py @@ -0,0 +1,255 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""3D rotation.""" + +import contextlib + +import tensorflow as tf + +from tensorflow_mri.python.geometry.rotation import rotation_matrix_3d +from tensorflow_mri.python.util import api_util + + +@api_util.export("geometry.Rotation3D") +class Rotation3D(tf.experimental.ExtensionType): + """Represents a 3D rotation (or a batch thereof).""" + _matrix: tf.Tensor + _name: str = "rotation_3d" + + @classmethod + def from_matrix(cls, matrix, name=None): + r"""Creates a 3D rotation from a rotation matrix. + + Args: + matrix: A `tf.Tensor` of shape `[..., 3, 3]`, where `...` represents + any number of batch dimensions. + name: A name for this op. Defaults to `"rotation_3d/from_matrix"`. + + Returns: + A `Rotation3D`. + """ + name = name or "rotation_3d/from_matrix" + with tf.name_scope(name): + return cls(_matrix=matrix, _name=name) + + @classmethod + def from_euler(cls, angles, name=None): + r"""Creates a 3D rotation from Euler angles. + + The resulting rotation acts like the rotation matrix + $\mathbf{R} = \mathbf{R}_z\mathbf{R}_y\mathbf{R}_x$. + + ```{note} + Uses the $z$-$y$-$x$ rotation convention (Tait-Bryan angles). + ``` + + Args: + angles: A `tf.Tensor` of shape `[..., 3]`, where the last dimension + represents the three Euler angles in radians. `angles[..., 0]` + is the angles about `x`, `angles[..., 1]` is the angles about `y`, + and `angles[..., 2]` is the angles about `z`. + name: A name for this op. Defaults to `"rotation_3d/from_euler"`. + + Returns: + A `Rotation3D`. + + Raises: + ValueError: If the shape of `angles` is invalid. + """ + name = name or "rotation_3d/from_matrix" + with tf.name_scope(name): + return cls(_matrix=rotation_matrix_3d.from_euler(angles), _name=name) + + @classmethod + def from_small_euler(cls, angles, name=None): + r"""Creates a 3D rotation from small Euler angles. + + The resulting rotation acts like the rotation matrix + $\mathbf{R} = \mathbf{R}_z\mathbf{R}_y\mathbf{R}_x$. + + Uses the small angle approximation to compute the rotation. Under the + small angle assumption, $\sin(x)$$ and $$\cos(x)$ can be approximated by + their second order Taylor expansions, where $\sin(x) \approx x$ and + $\cos(x) \approx 1 - \frac{x^2}{2}$. + + ```{note} + Uses the $z$-$y$-$x$ rotation convention (Tait-Bryan angles). + ``` + + ```{note} + This function does not verify the smallness of the angles. + ``` + + Args: + angles: A `tf.Tensor` of shape `[..., 3]`, where the last dimension + represents the three Euler angles in radians. `angles[..., 0]` + is the angles about `x`, `angles[..., 1]` is the angles about `y`, + and `angles[..., 2]` is the angles about `z`. + name: A name for this op. Defaults to "rotation_3d/from_small_euler". + + Returns: + A `Rotation3D`. + + Raises: + ValueError: If the shape of `angles` is invalid. + """ + name = name or "rotation_3d/from_small_euler" + with tf.name_scope(name): + return cls(_matrix=rotation_matrix_3d.from_small_euler(angles), + _name=name) + + @classmethod + def from_axis_angle(cls, axis, angle, name=None): + """Creates a 3D rotation from an axis-angle representation. + + Args: + axis: A `tf.Tensor` of shape `[..., 3]`, where the last dimension + represents a normalized axis. + angle: A `tf.Tensor` of shape `[..., 1]`, where the last dimension + represents a normalized axis. + name: A name for this op. Defaults to "rotation_3d/from_axis_angle". + + Returns: + A `Rotation3D`. + + Raises: + ValueError: If the shape of `axis` or `angle` is invalid. + """ + name = name or "rotation_3d/from_axis_angle" + with tf.name_scope(name): + return cls(_matrix=rotation_matrix_3d.from_axis_angle(axis, angle), + _name=name) + + @classmethod + def from_quaternion(cls, quaternion, name=None): + """Creates a 3D rotation from a quaternion. + + Args: + quaternion: A `tf.Tensor` of shape `[..., 4]`, where the last dimension + represents a normalized quaternion. + name: A name for this op. Defaults to `"rotation_3d/from_quaternion"`. + + Returns: + A `Rotation3D`. + + Raises: + ValueError: If the shape of `quaternion` is invalid. + """ + name = name or "rotation_3d/from_quaternion" + with tf.name_scope(name): + return cls(_matrix=rotation_matrix_3d.from_quaternion(quaternion), + _name=name) + + def as_matrix(self, name=None): + r"""Returns the rotation matrix that represents this rotation. + + Args: + name: A name for this op. Defaults to `"as_matrix"`. + + Returns: + A `tf.Tensor` of shape `[..., 3, 3]`. + """ + with self._name_scope(name or "as_matrix"): + return tf.identity(self._matrix) + + def inverse(self, name=None): + r"""Computes the inverse of this rotation. + + Args: + name: A name for this op. Defaults to `"inverse"`. + + Returns: + A `Rotation3D` representing the inverse of this rotation. + """ + with self._name_scope(name or "inverse"): + return Rotation3D(_matrix=rotation_matrix_3d.inverse(self._matrix), + _name=self._name + "/inverse") + + def is_valid(self, atol=1e-3, name=None): + r"""Determines if this is a valid rotation. + + A rotation matrix $\mathbf{R}$ is a valid rotation matrix if + $\mathbf{R}^T\mathbf{R} = \mathbf{I}$ and $\det(\mathbf{R}) = 1$. + + Args: + atol: A `float`. The absolute tolerance parameter. + name: A name for this op. Defaults to `"is_valid"`. + + Returns: + A boolean `tf.Tensor` with shape `[..., 1]`, `True` if the corresponding + matrix is valid and `False` otherwise. + """ + with self._name_scope(name or "is_valid"): + return rotation_matrix_3d.is_valid(self._matrix, atol=atol) + + def rotate(self, point, name=None): + r"""Rotates a 3D point. + + Args: + point: A `tf.Tensor` of shape `[..., 3]`, where the last dimension + represents a 3D point and `...` represents any number of batch + dimensions, which must be broadcastable with the batch shape of this + rotation. + name: A name for this op. Defaults to `"rotate"`. + + Returns: + A `tf.Tensor` of shape `[..., 3]`, where the last dimension represents + a 3D point and `...` is the result of broadcasting the batch shapes of + `point` and this rotation matrix. + + Raises: + ValueError: If the shape of `point` is invalid. + """ + with self._name_scope(name or "rotate"): + return rotation_matrix_3d.rotate(point, self._matrix) + + def __eq__(self, other): + """Returns true if this rotation is equivalent to the other rotation.""" + return tf.math.reduce_all( + tf.math.equal(self._matrix, other._matrix), axis=[-2, -1]) + + def __matmul__(self, other): + """Composes this rotation with another rotation.""" + return Rotation3D(_matrix=self._matrix @ other._matrix, + _name=self._name + "_o_" + other._name) + + def __validate__(self): + """Checks that this rotation is a valid rotation. + + Only performs static checks. + """ + rotation_matrix_3d.check_shape(self._matrix) + + @property + def shape(self): + """Returns the shape of this rotation.""" + return self._matrix.shape[:-2] + + @property + def dtype(self): + """Returns the dtype of this rotation.""" + return self._matrix.dtype + + @property + def name(self): + """Returns the name of this rotation.""" + return self._name + + @contextlib.contextmanager + def _name_scope(self, name=None): + """Helper function to standardize op scope.""" + with tf.name_scope(self.name): + with tf.name_scope(name) as scope: + yield scope diff --git a/tensorflow_mri/python/geometry/rotation_3d_test.py b/tensorflow_mri/python/geometry/rotation_3d_test.py new file mode 100644 index 00000000..ee343a74 --- /dev/null +++ b/tensorflow_mri/python/geometry/rotation_3d_test.py @@ -0,0 +1,239 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== + +# Copyright 2020 The TensorFlow Authors +# +# 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 +# +# https://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. +"""Tests for 3D rotation.""" +# This file is partly inspired by TensorFlow Graphics. + +from absl.testing import parameterized +import numpy as np +import tensorflow as tf + +from tensorflow_mri.python.geometry.rotation import test_data as td +from tensorflow_mri.python.geometry.rotation import test_helpers +from tensorflow_mri.python.geometry.rotation_3d import Rotation3D +from tensorflow_mri.python.util import test_util + + +class RotationMatrix3DTest(test_util.TestCase): + """Tests for `Rotation3D`.""" + def test_from_axis_angle_normalized_random(self): + """Tests that axis-angles can be converted to rotation matrices.""" + tensor_shape = np.random.randint(1, 10, size=np.random.randint(3)).tolist() + random_axis = np.random.normal(size=tensor_shape + [3]) + random_axis /= np.linalg.norm(random_axis, axis=-1, keepdims=True) + random_angle = np.random.normal(size=tensor_shape + [1]) + + rotation = Rotation3D.from_axis_angle(random_axis, random_angle) + + self.assertAllEqual(rotation.is_valid(), np.ones(tensor_shape + [1])) + + @parameterized.named_parameters( + ("preset0", td.AXIS_3D_X, td.ANGLE_45, td.MAT_3D_X_45), + ("preset1", td.AXIS_3D_Y, td.ANGLE_45, td.MAT_3D_Y_45), + ("preset2", td.AXIS_3D_Z, td.ANGLE_45, td.MAT_3D_Z_45), + ("preset3", td.AXIS_3D_X, td.ANGLE_90, td.MAT_3D_X_90), + ("preset4", td.AXIS_3D_Y, td.ANGLE_90, td.MAT_3D_Y_90), + ("preset5", td.AXIS_3D_Z, td.ANGLE_90, td.MAT_3D_Z_90), + ("preset6", td.AXIS_3D_X, td.ANGLE_180, td.MAT_3D_X_180), + ("preset7", td.AXIS_3D_Y, td.ANGLE_180, td.MAT_3D_Y_180), + ("preset8", td.AXIS_3D_Z, td.ANGLE_180, td.MAT_3D_Z_180) + ) + def test_from_axis_angle(self, axis, angle, matrix): + """Tests that an axis-angle maps to correct matrix.""" + self.assertAllClose( + matrix, Rotation3D.from_axis_angle(axis, angle).as_matrix()) + + def test_from_axis_angle_random(self): + """Tests conversion to matrix.""" + tensor_shape = np.random.randint(1, 10, size=np.random.randint(3)).tolist() + random_axis = np.random.normal(size=tensor_shape + [3]) + random_axis /= np.linalg.norm(random_axis, axis=-1, keepdims=True) + random_angle = np.random.normal(size=tensor_shape + [1]) + + rotation = Rotation3D.from_axis_angle(random_axis, random_angle) + + # Checks that resulting rotation matrices are normalized. + self.assertAllEqual(rotation.is_valid(), np.ones(tensor_shape + [1])) + + @parameterized.named_parameters( + ("preset0", td.AXIS_3D_X, td.ANGLE_90, td.AXIS_3D_X, td.AXIS_3D_X), + ("preset1", td.AXIS_3D_X, td.ANGLE_90, td.AXIS_3D_Y, td.AXIS_3D_Z), + ("preset2", td.AXIS_3D_X, -td.ANGLE_90, td.AXIS_3D_Z, td.AXIS_3D_Y), + ("preset3", td.AXIS_3D_Y, -td.ANGLE_90, td.AXIS_3D_X, td.AXIS_3D_Z), + ("preset4", td.AXIS_3D_Y, td.ANGLE_90, td.AXIS_3D_Y, td.AXIS_3D_Y), + ("preset5", td.AXIS_3D_Y, td.ANGLE_90, td.AXIS_3D_Z, td.AXIS_3D_X), + ("preset6", td.AXIS_3D_Z, td.ANGLE_90, td.AXIS_3D_X, td.AXIS_3D_Y), + ("preset7", td.AXIS_3D_Z, -td.ANGLE_90, td.AXIS_3D_Y, td.AXIS_3D_X), + ("preset8", td.AXIS_3D_Z, td.ANGLE_90, td.AXIS_3D_Z, td.AXIS_3D_Z), + ) + def test_from_axis_angle_rotate_vector_preset( + self, axis, angle, point, expected): + """Tests the directionality of axis-angle rotations.""" + self.assertAllClose( + expected, Rotation3D.from_axis_angle(axis, angle).rotate(point)) + + def test_from_euler_normalized_preset(self): + """Tests that euler angles can be converted to rotation matrices.""" + euler_angles = test_helpers.generate_preset_test_euler_angles() + + matrix = Rotation3D.from_euler(euler_angles) + self.assertAllEqual( + matrix.is_valid(), np.ones(euler_angles.shape[0:-1] + (1,))) + + def test_from_euler_normalized_random(self): + """Tests that euler angles can be converted to rotation matrices.""" + random_euler_angles = test_helpers.generate_random_test_euler_angles() + + matrix = Rotation3D.from_euler(random_euler_angles) + self.assertAllEqual( + matrix.is_valid(), np.ones(random_euler_angles.shape[0:-1] + (1,))) + + @parameterized.named_parameters( + ("preset0", td.AXIS_3D_0, td.MAT_3D_ID), + ("preset1", td.ANGLE_45 * td.AXIS_3D_X, td.MAT_3D_X_45), + ("preset2", td.ANGLE_45 * td.AXIS_3D_Y, td.MAT_3D_Y_45), + ("preset3", td.ANGLE_45 * td.AXIS_3D_Z, td.MAT_3D_Z_45), + ("preset4", td.ANGLE_90 * td.AXIS_3D_X, td.MAT_3D_X_90), + ("preset5", td.ANGLE_90 * td.AXIS_3D_Y, td.MAT_3D_Y_90), + ("preset6", td.ANGLE_90 * td.AXIS_3D_Z, td.MAT_3D_Z_90), + ("preset7", td.ANGLE_180 * td.AXIS_3D_X, td.MAT_3D_X_180), + ("preset8", td.ANGLE_180 * td.AXIS_3D_Y, td.MAT_3D_Y_180), + ("preset9", td.ANGLE_180 * td.AXIS_3D_Z, td.MAT_3D_Z_180), + ) + def test_from_euler(self, angle, expected): + """Tests that Euler angles create the expected matrix.""" + rotation = Rotation3D.from_euler(angle) + self.assertAllClose(expected, rotation.as_matrix()) + + def test_from_euler_random(self): + """Tests that Euler angles produce the same result as axis-angle.""" + angles = test_helpers.generate_random_test_euler_angles() + matrix = Rotation3D.from_euler(angles) + tensor_tile = angles.shape[:-1] + + x_axis = np.tile(td.AXIS_3D_X, tensor_tile + (1,)) + y_axis = np.tile(td.AXIS_3D_Y, tensor_tile + (1,)) + z_axis = np.tile(td.AXIS_3D_Z, tensor_tile + (1,)) + x_angle = np.expand_dims(angles[..., 0], axis=-1) + y_angle = np.expand_dims(angles[..., 1], axis=-1) + z_angle = np.expand_dims(angles[..., 2], axis=-1) + x_rotation = Rotation3D.from_axis_angle(x_axis, x_angle) + y_rotation = Rotation3D.from_axis_angle(y_axis, y_angle) + z_rotation = Rotation3D.from_axis_angle(z_axis, z_angle) + expected_matrix = z_rotation @ (y_rotation @ x_rotation) + + self.assertAllClose(expected_matrix.as_matrix(), matrix.as_matrix(), rtol=1e-3) + + def test_from_quaternion_normalized_random(self): + """Tests that random quaternions can be converted to rotation matrices.""" + random_quaternion = test_helpers.generate_random_test_quaternions() + tensor_shape = random_quaternion.shape[:-1] + + random_rot = Rotation3D.from_quaternion(random_quaternion) + + self.assertAllEqual( + random_rot.is_valid(), + np.ones(tensor_shape + (1,))) + + def test_from_quaternion(self): + """Tests that a quaternion maps to correct matrix.""" + preset_quaternions = test_helpers.generate_preset_test_quaternions() + + preset_matrices = test_helpers.generate_preset_test_rotation_matrices_3d() + + self.assertAllClose( + preset_matrices, + Rotation3D.from_quaternion(preset_quaternions).as_matrix()) + + def test_inverse_normalized_random(self): + """Checks that inverted rotation matrices are valid rotations.""" + random_euler_angle = test_helpers.generate_random_test_euler_angles() + tensor_tile = random_euler_angle.shape[:-1] + + random_rot = Rotation3D.from_euler(random_euler_angle) + predicted_invert_random_rot = random_rot.inverse() + + self.assertAllEqual( + predicted_invert_random_rot.is_valid(), + np.ones(tensor_tile + (1,))) + + def test_inverse_random(self): + """Checks that inverting rotated points results in no transformation.""" + random_euler_angle = test_helpers.generate_random_test_euler_angles() + tensor_tile = random_euler_angle.shape[:-1] + random_rot = Rotation3D.from_euler(random_euler_angle) + random_point = np.random.normal(size=tensor_tile + (3,)) + + rotated_random_points = random_rot.rotate(random_point) + inv_random_rot = random_rot.inverse() + inv_rotated_random_points = inv_random_rot.rotate(rotated_random_points) + + self.assertAllClose(random_point, inv_rotated_random_points, rtol=1e-6) + + def test_is_valid_random(self): + """Tests that is_valid works as intended.""" + random_euler_angle = test_helpers.generate_random_test_euler_angles() + tensor_tile = random_euler_angle.shape[:-1] + + rotation = Rotation3D.from_euler(random_euler_angle) + pred_normalized = rotation.is_valid() + + with self.subTest(name="all_normalized"): + self.assertAllEqual(pred_normalized, + np.ones(shape=tensor_tile + (1,), dtype=bool)) + + with self.subTest(name="non_orthonormal"): + test_matrix = np.array([[2., 0., 0.], [0., 0.5, 0], [0., 0., 1.]]) + rotation = Rotation3D.from_matrix(test_matrix) + pred_normalized = rotation.is_valid() + self.assertAllEqual(pred_normalized, np.zeros(shape=(1,), dtype=bool)) + + with self.subTest(name="negative_orthonormal"): + test_matrix = np.array([[1., 0., 0.], [0., -1., 0.], [0., 0., 1.]]) + rotation = Rotation3D.from_matrix(test_matrix) + pred_normalized = rotation.is_valid() + self.assertAllEqual(pred_normalized, np.zeros(shape=(1,), dtype=bool)) + + @parameterized.named_parameters( + ("preset0", td.ANGLE_90 * td.AXIS_3D_X, td.AXIS_3D_X, td.AXIS_3D_X), + ("preset1", td.ANGLE_90 * td.AXIS_3D_X, td.AXIS_3D_Y, td.AXIS_3D_Z), + ("preset2", -td.ANGLE_90 * td.AXIS_3D_X, td.AXIS_3D_Z, td.AXIS_3D_Y), + ("preset3", -td.ANGLE_90 * td.AXIS_3D_Y, td.AXIS_3D_X, td.AXIS_3D_Z), + ("preset4", td.ANGLE_90 * td.AXIS_3D_Y, td.AXIS_3D_Y, td.AXIS_3D_Y), + ("preset5", td.ANGLE_90 * td.AXIS_3D_Y, td.AXIS_3D_Z, td.AXIS_3D_X), + ("preset6", td.ANGLE_90 * td.AXIS_3D_Z, td.AXIS_3D_X, td.AXIS_3D_Y), + ("preset7", -td.ANGLE_90 * td.AXIS_3D_Z, td.AXIS_3D_Y, td.AXIS_3D_X), + ("preset8", td.ANGLE_90 * td.AXIS_3D_Z, td.AXIS_3D_Z, td.AXIS_3D_Z), + ) + def test_rotate_vector_preset(self, angles, point, expected): + """Tests that the rotate function produces the expected results.""" + self.assertAllClose(expected, Rotation3D.from_euler(angles).rotate(point)) + + +if __name__ == "__main__": + tf.test.main() diff --git a/tensorflow_mri/python/geometry/rotation_matrix.py b/tensorflow_mri/python/geometry/rotation_matrix.py deleted file mode 100644 index 0a6babe8..00000000 --- a/tensorflow_mri/python/geometry/rotation_matrix.py +++ /dev/null @@ -1,164 +0,0 @@ -# Copyright 2022 The TensorFlow MRI 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. -# ============================================================================== - -import contextlib - -import tensorflow as tf - - -class RotationMatrix(tf.experimental.ExtensionType): - """Represents a {n}D rotation matrix. - - References: - 1. https://en.wikipedia.org/wiki/Rotation_matrix - 2. https://www.tensorflow.org/graphics/api_docs/python/tfg/geometry/transformation/rotation_matrix_2d - """ - matrix: tf.Tensor - name: str = "rotation_matrix" - - def __init__(self, matrix, name=None): - self.matrix = matrix - self.name = name or self._default_name() - - def __validate__(self): - self._validate_shape() - - def __eq__(self, other): - return tf.math.equal(self.matrix, other.matrix) - - def inverse(self, name=None): - r"""Computes the inverse of this rotation matrix. - - Args: - name: A name for this op. Defaults to `"inverse"`. - - Returns: - A `RotationMatrix{n}D` representing the inverse of this rotation matrix. - """ - with self._name_scope(name or "inverse"): - return type(self)(tf.linalg.matrix_transpose(self.matrix), - name=self.name + '_inverse') - - def is_valid(self, atol=1e-3, name=None): - r"""Determines if this matrix is a valid rotation matrix. - - A matrix $\mathbf{{R}}$ is a valid rotation matrix if - $\mathbf{{R}}^T\mathbf{{R}} = \mathbf{{I}}$ and $\det(\mathbf{{R}}) = 1$. - - Args: - atol: The absolute tolerance parameter. - name: A name for this op. Defaults to `"is_valid"`. - - Returns: - A boolean `tf.Tensor` with shape `[..., 1]`, `True` if the corresponding - matrix is valid and `False` otherwise. - """ - with self._name_scope(name or "is_valid"): - # Compute how far the determinant of the matrix is from 1. - distance_determinant = tf.abs(tf.linalg.det(self.matrix) - 1.) - - # Computes how far the product of the transposed rotation matrix with itself - # is from the identity matrix. - identity = tf.eye(tf.shape(self.matrix)[-1], dtype=self.dtype) - inverse = tf.linalg.matrix_transpose(self.matrix) - distance_identity = tf.matmul(inverse, self.matrix) - identity - distance_identity = tf.norm(distance_identity, axis=[-2, -1]) - - # Computes the mask of entries that satisfies all conditions. - mask = tf.math.logical_and(distance_determinant < atol, - distance_identity < atol) - return tf.expand_dims(mask, axis=-1) - - def rotate(self, point, name=None): - r"""Rotates a {n}D point as described by this rotation matrix. - - Args: - point: A `tf.Tensor` of shape `[..., {n}]`, where the last dimension - represents a {n}D point and `...` represents any number of batch - dimensions, which must be broadcastable with the batch shape of the - rotation matrix. - name: A name for this op. Defaults to `"rotate"`. - - Returns: - A `tf.Tensor` of shape `[..., {n}]`, where the last dimension represents - a {n}D point and `...` is the result of broadcasting the batch shapes of - `point` and this rotation matrix. - - Raises: - ValueError: If the shape of `point` is invalid. - """ - with self._name_scope(name or "rotate"): - point = tf.convert_to_tensor(point) - - if not point.shape[-1:].is_compatible_with(2): - raise ValueError( - f"point must have shape [..., 2], but got: {point.shape}") - try: - static_batch_shape = tf.broadcast_static_shape( - point.shape[:-1], self.shape[:-2]) - except ValueError as err: - raise ValueError( - f"The batch shapes of point and this rotation matrix do not " - f"broadcast: {point.shape[:-1]} vs. {self.shape[:-2]}") from err - - common_batch_shape = tf.broadcast_dynamic_shape( - tf.shape(point)[:-1], tf.shape(self.matrix)[:-2]) - point = tf.broadcast_to(point, tf.concat( - [common_batch_shape, [self._n()]], 0)) - matrix = tf.broadcast_to(self.matrix, tf.concat( - [common_batch_shape, [self._n(), self._n()]], 0)) - - rotated_point = tf.linalg.matvec(matrix, point) - - output_shape = static_batch_shape.concatenate([self._n()]) - return tf.ensure_shape(rotated_point, output_shape) - - @property - def shape(self): - """Returns the shape of this rotation matrix.""" - return self.matrix.shape - - @property - def dtype(self): - """Returns the dtype of this rotation matrix.""" - return self.matrix.dtype - - @contextlib.contextmanager - def _name_scope(self, name=None): - """Helper function to standardize op scope.""" - with tf.name_scope(self.name): - with tf.name_scope(name) as scope: - yield scope - - def _default_name(self): - return {2: 'rotation_matrix_2d', 3: 'rotation_matrix_3d'}[self._n()] - - def _validate_shape(self): - if self.matrix.shape.rank is not None: - if self.matrix.shape.rank < 2: - raise ValueError( - f"matrix must have rank >= 2, but got: {self.matrix.shape}") - if not self.matrix.shape[-2:].is_compatible_with([self._n(), self._n()]): - raise ValueError( - f"matrix must have shape [..., {self._n()}, {self._n()}], " - f"but got: {self.matrix.shape}") - - def _n(self): - return {'RotationMatrix2D': 2, 'RotationMatrix3D': 3}[type(self).__name__] - - -@tf.experimental.dispatch_for_api(tf.shape, {'input': RotationMatrix}) -def rotation_matrix_shape(input, out_type=tf.int32, name=None): - return tf.shape(input.matrix, out_type=out_type, name=name) diff --git a/tensorflow_mri/python/geometry/rotation_matrix_2d.py b/tensorflow_mri/python/geometry/rotation_matrix_2d.py deleted file mode 100644 index 5e9d836b..00000000 --- a/tensorflow_mri/python/geometry/rotation_matrix_2d.py +++ /dev/null @@ -1,154 +0,0 @@ -# Copyright 2022 The TensorFlow MRI 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. -# ============================================================================== - -# Copyright 2020 The TensorFlow Authors -# -# 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 -# -# https://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. -# ============================================================================== -"""2D rotation matrix.""" -# This file is partly inspired by TensorFlow Graphics. - -import tensorflow as tf - -from tensorflow_mri.python.geometry import rotation_matrix -from tensorflow_mri.python.util import api_util - - -FORMAT_KWARGS = dict(n=2) - - -@api_util.export("geometry.RotationMatrix2D") -class RotationMatrix2D(rotation_matrix.RotationMatrix): - __doc__ = rotation_matrix.RotationMatrix.__doc__.format(**FORMAT_KWARGS) - - @classmethod - def from_euler(cls, angle, name=None): - r"""Creates a rotation matrix from an angle. - - Converts an angle $\theta$ to a 2D rotation matrix following the equation - - $$ - \mathbf{R} = - \begin{bmatrix} - \cos(\theta) & -\sin(\theta) \\ - \sin(\theta) & \cos(\theta) - \end{bmatrix}. - $$ - - ```{note} - The resulting matrix rotates points in the $xy$-plane counterclockwise. - ``` - - Args: - angle: A `tf.Tensor` of shape `[..., 1]`, where the last dimension - represents an angle in radians. - name: A name for this op. Defaults to `"from_euler"`. - - Returns: - A `RotationMatrix2D`. - - Raises: - ValueError: If the shape of `angle` is invalid. - """ - name = name or "from_euler" - with tf.name_scope(f"rotation_matrix_2d/{name}"): - angle = tf.convert_to_tensor(angle) - - if not angle.shape[-1:].is_compatible_with([1]): - raise ValueError( - f"angle must have shape `[..., 1]`, but got: {angle.shape}") - - cos_angle = tf.math.cos(angle) - sin_angle = tf.math.sin(angle) - matrix = tf.stack([cos_angle, -sin_angle, sin_angle, cos_angle], axis=-1) - output_shape = tf.concat([tf.shape(angle)[:-1], [2, 2]], axis=-1) - return cls(tf.reshape(matrix, output_shape)) - - @classmethod - def from_euler_with_small_angles_approximation(cls, angle, name=None): - r"""Creates a rotation matrix from an angle using small angle approximation. - - Under the small angle assumption, $\sin(x)$ and $\cos(x)$ can be - approximated by their second order Taylor expansions, where - $\sin(x) \approx x$ and $\cos(x) \approx 1 - \frac{x^2}{2}$. The 2D - rotation matrix will then be approximated as - - $$ - \mathbf{R} = - \begin{bmatrix} - 1.0 - 0.5\theta^2 & -\theta \\ - \theta & 1.0 - 0.5\theta^2 - \end{bmatrix}. - $$ - - ```{note} - The resulting matrix rotates points in the $xy$-plane counterclockwise. - ``` - - ```{note} - This function does not verify the smallness of the angles. - ``` - - Args: - angle: A `tf.Tensor` of shape `[..., 1]`, where the last dimension - represents an angle in radians. - name: A name for this op. Defaults to - "from_euler_with_small_angles_approximation". - - Returns: - A `RotationMatrix2D`. - - Raises: - ValueError: If the shape of `angle` is invalid. - """ - name = name or "from_euler_with_small_angles_approximation" - with tf.name_scope(f"rotation_matrix_2d/{name}"): - angle = tf.convert_to_tensor(angle) - - if not angle.shape[-1:].is_compatible_with([1]): - raise ValueError( - f"angle must have shape `[..., 1]`, but got: {angle.shape}") - - cos_angle = 1.0 - 0.5 * angle * angle - sin_angle = angle - matrix = tf.stack([cos_angle, -sin_angle, sin_angle, cos_angle], axis=-1) - output_shape = tf.concat([tf.shape(angle)[:-1], [2, 2]], axis=-1) - return cls(tf.reshape(matrix, output_shape)) - - # The following methods are overridden only to generate the docstrings. - def inverse(self, name=None): - return super().inverse(name=name) - inverse.__doc__ = rotation_matrix.RotationMatrix.inverse.__doc__.format( - **FORMAT_KWARGS) - - def is_valid(self, atol=1e-3, name=None): - return super().is_valid(atol=atol, name=name) - is_valid.__doc__ = rotation_matrix.RotationMatrix.is_valid.__doc__.format( - **FORMAT_KWARGS) - - def rotate(self, point, name=None): - return super().rotate(point=point, name=name) - rotate.__doc__ = rotation_matrix.RotationMatrix.rotate.__doc__.format( - **FORMAT_KWARGS) diff --git a/tensorflow_mri/python/linalg/linear_operator_gram_nufft_test.py b/tensorflow_mri/python/linalg/linear_operator_gram_nufft_test.py index e69e67f7..82cb1e9f 100755 --- a/tensorflow_mri/python/linalg/linear_operator_gram_nufft_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_gram_nufft_test.py @@ -19,9 +19,9 @@ import numpy as np import tensorflow as tf +from tensorflow_mri.python.geometry import rotation_2d from tensorflow_mri.python.linalg import linear_operator_gram_nufft from tensorflow_mri.python.linalg import linear_operator_nufft -from tensorflow_mri.python.ops import geom_ops from tensorflow_mri.python.ops import image_ops from tensorflow_mri.python.ops import traj_ops from tensorflow_mri.python.util import test_util @@ -50,7 +50,8 @@ def test_general(self, density, norm, toeplitz, batch): if batch: image = tf.stack([image, image * 0.5]) trajectory = tf.stack([ - trajectory, geom_ops.rotate_2d(trajectory, [np.pi / 2])]) + trajectory, + rotation_2d.Rotation2D.from_euler([np.pi / 2]).rotate(trajectory)]) if density is not None: density = tf.stack([density, density]) diff --git a/tensorflow_mri/python/ops/geom_ops.py b/tensorflow_mri/python/ops/geom_ops.py deleted file mode 100644 index 213dc164..00000000 --- a/tensorflow_mri/python/ops/geom_ops.py +++ /dev/null @@ -1,181 +0,0 @@ -# Copyright 2021 University College London. 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. -# ============================================================================== -"""Geometry operations.""" - -import tensorflow as tf - -from tensorflow_graphics.geometry.transformation import rotation_matrix_2d -from tensorflow_graphics.geometry.transformation import rotation_matrix_3d - - -def rotate_2d(points, euler): - """Rotates an array of 2D coordinates. - - Args: - points: A `Tensor` of shape `[A1, A2, ..., An, 2]`, where the last dimension - represents a 2D point. - euler: A `Tensor` of shape `[A1, A2, ..., An, 1]`, where the last dimension - represents an angle in radians. - - Returns: - A `Tensor` of shape `[A1, A2, ..., An, 2]`, where the last dimension - represents a 2D point. - """ - return rotation_matrix_2d.rotate( - points, rotation_matrix_2d.from_euler(euler)) - - -def rotate_3d(points, euler): - """Rotates an array of 3D coordinates. - - Args: - points: A `Tensor` of shape `[A1, A2, ..., An, 3]`, where the last dimension - represents a 3D point. - euler: A `Tensor` of shape `[A1, A2, ..., An, 3]`, where the last dimension - represents the three Euler angles. - - Returns: - A `Tensor` of shape `[A1, A2, ..., An, 3]`, where the last dimension - represents a 3D point. - """ - return rotation_matrix_3d.rotate( - points, rotation_matrix_3d.from_euler(euler)) - - -def euler_to_rotation_matrix_3d(angles, order='XYZ', name='rotation_matrix_3d'): - r"""Convert an Euler angle representation to a rotation matrix. - - The resulting matrix is $$\mathbf{R} = \mathbf{R}_z\mathbf{R}_y\mathbf{R}_x$$. - - .. note:: - In the following, A1 to An are optional batch dimensions. - - Args: - angles: A tensor of shape `[A1, ..., An, 3]`, where the last dimension - represents the three Euler angles. `[A1, ..., An, 0]` is the angle about - `x` in radians `[A1, ..., An, 1]` is the angle about `y` in radians and - `[A1, ..., An, 2]` is the angle about `z` in radians. - order: A `str`. The order in which the rotations are applied. Defaults to - `"XYZ"`. - name: A name for this op that defaults to "rotation_matrix_3d_from_euler". - - Returns: - A tensor of shape `[A1, ..., An, 3, 3]`, where the last two dimensions - represent a 3d rotation matrix. - - Raises: - ValueError: If the shape of `angles` is not supported. - """ - with tf.name_scope(name): - angles = tf.convert_to_tensor(value=angles) - - if angles.shape[-1] != 3: - raise ValueError(f"The last dimension of `angles` must have size 3, " - f"but got shape: {angles.shape}") - - sin_angles = tf.math.sin(angles) - cos_angles = tf.math.cos(angles) - return _build_matrix_from_sines_and_cosines( - sin_angles, cos_angles, order=order) - - -def _build_matrix_from_sines_and_cosines(sin_angles, cos_angles, order='XYZ'): - """Builds a rotation matrix from sines and cosines of Euler angles. - - .. note:: - In the following, A1 to An are optional batch dimensions. - - Args: - sin_angles: A tensor of shape `[A1, ..., An, 3]`, where the last dimension - represents the sine of the Euler angles. - cos_angles: A tensor of shape `[A1, ..., An, 3]`, where the last dimension - represents the cosine of the Euler angles. - order: A `str`. The order in which the rotations are applied. Defaults to - `"XYZ"`. - - Returns: - A tensor of shape `[A1, ..., An, 3, 3]`, where the last two dimensions - represent a 3d rotation matrix. - - Raises: - ValueError: If any of the input arguments has an invalid value. - """ - sin_angles.shape.assert_is_compatible_with(cos_angles.shape) - output_shape = tf.concat((tf.shape(sin_angles)[:-1], (3, 3)), -1) - - sx, sy, sz = tf.unstack(sin_angles, axis=-1) - cx, cy, cz = tf.unstack(cos_angles, axis=-1) - ones = tf.ones_like(sx) - zeros = tf.zeros_like(sx) - # rx - m00 = ones - m01 = zeros - m02 = zeros - m10 = zeros - m11 = cx - m12 = -sx - m20 = zeros - m21 = sx - m22 = cx - rx = tf.stack((m00, m01, m02, - m10, m11, m12, - m20, m21, m22), - axis=-1) - rx = tf.reshape(rx, output_shape) - # ry - m00 = cy - m01 = zeros - m02 = sy - m10 = zeros - m11 = ones - m12 = zeros - m20 = -sy - m21 = zeros - m22 = cy - ry = tf.stack((m00, m01, m02, - m10, m11, m12, - m20, m21, m22), - axis=-1) - ry = tf.reshape(ry, output_shape) - # rz - m00 = cz - m01 = -sz - m02 = zeros - m10 = sz - m11 = cz - m12 = zeros - m20 = zeros - m21 = zeros - m22 = ones - rz = tf.stack((m00, m01, m02, - m10, m11, m12, - m20, m21, m22), - axis=-1) - rz = tf.reshape(rz, output_shape) - - matrix = tf.eye(output_shape[-2], output_shape[-1], - batch_shape=output_shape[:-2]) - - for r in order.upper(): - if r == 'X': - matrix = rx @ matrix - elif r == 'Y': - matrix = ry @ matrix - elif r == 'Z': - matrix = rz @ matrix - else: - raise ValueError(f"Invalid value for `order`: {order}") - - return matrix diff --git a/tensorflow_mri/python/ops/geom_ops_test.py b/tensorflow_mri/python/ops/geom_ops_test.py deleted file mode 100644 index 6721663d..00000000 --- a/tensorflow_mri/python/ops/geom_ops_test.py +++ /dev/null @@ -1,15 +0,0 @@ -# Copyright 2021 University College London. 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. -# ============================================================================== -"""Tests for module `geom_ops`.""" diff --git a/tensorflow_mri/python/ops/image_ops.py b/tensorflow_mri/python/ops/image_ops.py index 5cc32aed..24898062 100644 --- a/tensorflow_mri/python/ops/image_ops.py +++ b/tensorflow_mri/python/ops/image_ops.py @@ -26,8 +26,9 @@ import numpy as np import tensorflow as tf +from tensorflow_mri.python.geometry import rotation_2d +from tensorflow_mri.python.geometry import rotation_3d from tensorflow_mri.python.ops import array_ops -from tensorflow_mri.python.ops import geom_ops from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util from tensorflow_mri.python.util import deprecation @@ -1740,7 +1741,8 @@ def phantom(phantom_type='modified_shepp_logan', # pylint: disable=dangerous-de if isinstance(obj, Ellipse): # Apply translation and rotation to coordinates. - tx = geom_ops.rotate_2d(x - obj.pos, tf.cast(obj.phi, x.dtype)) + tx = rotation_2d.Rotation2D.from_euler(tf.cast(obj.phi, x.dtype)).rotate( + x - obj.pos) # Use object equation to generate a mask. mask = tf.math.reduce_sum( (tx ** 2) / (tf.convert_to_tensor(obj.size) ** 2), -1) <= 1.0 @@ -1748,7 +1750,8 @@ def phantom(phantom_type='modified_shepp_logan', # pylint: disable=dangerous-de image = tf.where(mask, image + obj.rho, image) elif isinstance(obj, Ellipsoid): # Apply translation and rotation to coordinates. - tx = geom_ops.rotate_3d(x - obj.pos, tf.cast(obj.phi, x.dtype)) + tx = rotation_3d.Rotation3D.from_euler(tf.cast(obj.phi, x.dtype)).rotate( + x - obj.pos) # Use object equation to generate a mask. mask = tf.math.reduce_sum( (tx ** 2) / (tf.convert_to_tensor(obj.size) ** 2), -1) <= 1.0 diff --git a/tensorflow_mri/python/ops/traj_ops.py b/tensorflow_mri/python/ops/traj_ops.py index 621196b0..bfadd63b 100755 --- a/tensorflow_mri/python/ops/traj_ops.py +++ b/tensorflow_mri/python/ops/traj_ops.py @@ -24,11 +24,10 @@ import numpy as np import tensorflow as tf import tensorflow_nufft as tfft -from tensorflow_graphics.geometry.transformation import rotation_matrix_3d # pylint: disable=wrong-import-order -from tensorflow_mri.python.geometry import rotation_matrix_2d +from tensorflow_mri.python.geometry import rotation_2d +from tensorflow_mri.python.geometry import rotation_3d from tensorflow_mri.python.ops import array_ops -from tensorflow_mri.python.ops import geom_ops from tensorflow_mri.python.ops import signal_ops from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util @@ -1044,7 +1043,7 @@ def _rotate_waveform_2d(waveform, angles): tf.shape(waveform)], 0)) # Apply rotation. - return rotation_matrix_2d.RotationMatrix2D.from_euler(angles).rotate(waveform) + return rotation_2d.Rotation2D.from_euler(angles).rotate(waveform) def _rotate_waveform_3d(waveform, angles): @@ -1065,10 +1064,10 @@ def _rotate_waveform_3d(waveform, angles): angles = tf.expand_dims(angles, -2) # Compute rotation matrix. - rot_matrix = geom_ops.euler_to_rotation_matrix_3d(angles, order='ZYX') + rot_matrix = _rotation_matrix_3d_from_euler(angles, order='ZYX') # Apply rotation to trajectory. - waveform = rotation_matrix_3d.rotate(waveform, rot_matrix) + waveform = rotation_3d.rotate(waveform, rot_matrix) return waveform @@ -1298,3 +1297,130 @@ def _find_first_greater_than(x, y): x = x - y x = tf.where(x < 0, np.inf, x) return tf.math.argmin(x) + + +def _rotation_matrix_3d_from_euler(angles, order='XYZ', name='rotation_3d'): + r"""Convert an Euler angle representation to a rotation matrix. + + The resulting matrix is $$\mathbf{R} = \mathbf{R}_z\mathbf{R}_y\mathbf{R}_x$$. + + .. note:: + In the following, A1 to An are optional batch dimensions. + + Args: + angles: A tensor of shape `[A1, ..., An, 3]`, where the last dimension + represents the three Euler angles. `[A1, ..., An, 0]` is the angle about + `x` in radians `[A1, ..., An, 1]` is the angle about `y` in radians and + `[A1, ..., An, 2]` is the angle about `z` in radians. + order: A `str`. The order in which the rotations are applied. Defaults to + `"XYZ"`. + name: A name for this op that defaults to "rotation_matrix_3d_from_euler". + + Returns: + A tensor of shape `[A1, ..., An, 3, 3]`, where the last two dimensions + represent a 3d rotation matrix. + + Raises: + ValueError: If the shape of `angles` is not supported. + """ + with tf.name_scope(name): + angles = tf.convert_to_tensor(value=angles) + + if angles.shape[-1] != 3: + raise ValueError(f"The last dimension of `angles` must have size 3, " + f"but got shape: {angles.shape}") + + sin_angles = tf.math.sin(angles) + cos_angles = tf.math.cos(angles) + return _build_matrix_from_sines_and_cosines( + sin_angles, cos_angles, order=order) + + +def _build_matrix_from_sines_and_cosines(sin_angles, cos_angles, order='XYZ'): + """Builds a rotation matrix from sines and cosines of Euler angles. + + .. note:: + In the following, A1 to An are optional batch dimensions. + + Args: + sin_angles: A tensor of shape `[A1, ..., An, 3]`, where the last dimension + represents the sine of the Euler angles. + cos_angles: A tensor of shape `[A1, ..., An, 3]`, where the last dimension + represents the cosine of the Euler angles. + order: A `str`. The order in which the rotations are applied. Defaults to + `"XYZ"`. + + Returns: + A tensor of shape `[A1, ..., An, 3, 3]`, where the last two dimensions + represent a 3d rotation matrix. + + Raises: + ValueError: If any of the input arguments has an invalid value. + """ + sin_angles.shape.assert_is_compatible_with(cos_angles.shape) + output_shape = tf.concat((tf.shape(sin_angles)[:-1], (3, 3)), -1) + + sx, sy, sz = tf.unstack(sin_angles, axis=-1) + cx, cy, cz = tf.unstack(cos_angles, axis=-1) + ones = tf.ones_like(sx) + zeros = tf.zeros_like(sx) + # rx + m00 = ones + m01 = zeros + m02 = zeros + m10 = zeros + m11 = cx + m12 = -sx + m20 = zeros + m21 = sx + m22 = cx + rx = tf.stack((m00, m01, m02, + m10, m11, m12, + m20, m21, m22), + axis=-1) + rx = tf.reshape(rx, output_shape) + # ry + m00 = cy + m01 = zeros + m02 = sy + m10 = zeros + m11 = ones + m12 = zeros + m20 = -sy + m21 = zeros + m22 = cy + ry = tf.stack((m00, m01, m02, + m10, m11, m12, + m20, m21, m22), + axis=-1) + ry = tf.reshape(ry, output_shape) + # rz + m00 = cz + m01 = -sz + m02 = zeros + m10 = sz + m11 = cz + m12 = zeros + m20 = zeros + m21 = zeros + m22 = ones + rz = tf.stack((m00, m01, m02, + m10, m11, m12, + m20, m21, m22), + axis=-1) + rz = tf.reshape(rz, output_shape) + + matrix = tf.eye(output_shape[-2], output_shape[-1], + batch_shape=output_shape[:-2]) + + for r in order.upper(): + if r == 'X': + matrix = rx @ matrix + elif r == 'Y': + matrix = ry @ matrix + elif r == 'Z': + matrix = rz @ matrix + else: + raise ValueError(f"Invalid value for `order`: {order}") + + return matrix diff --git a/tools/build/create_api.py b/tools/build/create_api.py index cdc3082b..501a8a03 100644 --- a/tools/build/create_api.py +++ b/tools/build/create_api.py @@ -42,7 +42,6 @@ from tensorflow_mri.python.ops.coil_ops import * from tensorflow_mri.python.ops.convex_ops import * from tensorflow_mri.python.ops.fft_ops import * -from tensorflow_mri.python.ops.geom_ops import * from tensorflow_mri.python.ops.image_ops import * from tensorflow_mri.python.ops.math_ops import * from tensorflow_mri.python.ops.optimizer_ops import * From 868e2b0a9abf53463ebefee3bd04c015aedb0792 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Sat, 27 Aug 2022 13:23:18 +0000 Subject: [PATCH 051/101] Small docs adjustment --- tensorflow_mri/python/geometry/rotation_2d.py | 4 ++-- tensorflow_mri/python/geometry/rotation_3d.py | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/tensorflow_mri/python/geometry/rotation_2d.py b/tensorflow_mri/python/geometry/rotation_2d.py index 5d5cacb5..0275f16e 100644 --- a/tensorflow_mri/python/geometry/rotation_2d.py +++ b/tensorflow_mri/python/geometry/rotation_2d.py @@ -33,8 +33,8 @@ def from_matrix(cls, matrix, name=None): r"""Creates a 2D rotation from a rotation matrix. Args: - matrix: A `tf.Tensor` of shape `[..., 2, 2]`, where `...` represents - any number of batch dimensions. + matrix: A `tf.Tensor` of shape `[..., 2, 2]`, where the last two + dimensions represent a rotation matrix. name: A name for this op. Defaults to `"rotation_2d/from_matrix"`. Returns: diff --git a/tensorflow_mri/python/geometry/rotation_3d.py b/tensorflow_mri/python/geometry/rotation_3d.py index 7f09c7bc..ec1eb08c 100644 --- a/tensorflow_mri/python/geometry/rotation_3d.py +++ b/tensorflow_mri/python/geometry/rotation_3d.py @@ -33,8 +33,8 @@ def from_matrix(cls, matrix, name=None): r"""Creates a 3D rotation from a rotation matrix. Args: - matrix: A `tf.Tensor` of shape `[..., 3, 3]`, where `...` represents - any number of batch dimensions. + matrix: A `tf.Tensor` of shape `[..., 3, 3]`, where the last two + dimensions represent a rotation matrix. name: A name for this op. Defaults to `"rotation_3d/from_matrix"`. Returns: From e3502e637107488481dcaafb7780857c010960e9 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Sat, 27 Aug 2022 18:13:43 +0000 Subject: [PATCH 052/101] Finalize rotation --- tensorflow_mri/python/geometry/rotation_2d.py | 59 ++++++-------- .../python/geometry/rotation_2d_test.py | 27 ++++++- tensorflow_mri/python/geometry/rotation_3d.py | 76 ++++++++----------- .../python/geometry/rotation_3d_test.py | 35 ++++++++- 4 files changed, 114 insertions(+), 83 deletions(-) diff --git a/tensorflow_mri/python/geometry/rotation_2d.py b/tensorflow_mri/python/geometry/rotation_2d.py index 0275f16e..30820df4 100644 --- a/tensorflow_mri/python/geometry/rotation_2d.py +++ b/tensorflow_mri/python/geometry/rotation_2d.py @@ -14,8 +14,6 @@ # ============================================================================== """2D rotation.""" -import contextlib - import tensorflow as tf from tensorflow_mri.python.geometry.rotation import rotation_matrix_2d @@ -23,10 +21,10 @@ @api_util.export("geometry.Rotation2D") -class Rotation2D(tf.experimental.ExtensionType): +class Rotation2D(tf.experimental.BatchableExtensionType): """Represents a 2D rotation (or a batch thereof).""" + __name__ = "tfmri.geometry.Rotation2D" _matrix: tf.Tensor - _name: str = "rotation_2d" @classmethod def from_matrix(cls, matrix, name=None): @@ -40,9 +38,8 @@ def from_matrix(cls, matrix, name=None): Returns: A `Rotation2D`. """ - name = name or "rotation_2d/from_matrix" - with tf.name_scope(name): - return cls(_matrix=matrix, _name=name) + with tf.name_scope(name or "rotation_2d/from_matrix"): + return cls(_matrix=matrix) @classmethod def from_euler(cls, angle, name=None): @@ -73,9 +70,8 @@ def from_euler(cls, angle, name=None): Raises: ValueError: If the shape of `angle` is invalid. """ - name = name or "rotation_2d/from_euler" - with tf.name_scope(name): - return cls(_matrix=rotation_matrix_2d.from_euler(angle), _name=name) + with tf.name_scope(name or "rotation_2d/from_euler"): + return cls(_matrix=rotation_matrix_2d.from_euler(angle)) @classmethod def from_small_euler(cls, angle, name=None): @@ -115,34 +111,32 @@ def from_small_euler(cls, angle, name=None): Raises: ValueError: If the shape of `angle` is invalid. """ - name = name or "rotation_2d/from_small_euler" - with tf.name_scope(name): - return cls(_matrix=rotation_matrix_2d.from_small_euler(angle), _name=name) + with tf.name_scope("rotation_2d/from_small_euler"): + return cls(_matrix=rotation_matrix_2d.from_small_euler(angle)) def as_matrix(self, name=None): r"""Returns the rotation matrix that represents this rotation. Args: - name: A name for this op. Defaults to `"as_matrix"`. + name: A name for this op. Defaults to `"rotation_2d/as_matrix"`. Returns: A `tf.Tensor` of shape `[..., 2, 2]`. """ - with self._name_scope(name or "as_matrix"): + with tf.name_scope(name or "rotation_2d/as_matrix"): return tf.identity(self._matrix) def inverse(self, name=None): r"""Computes the inverse of this rotation. Args: - name: A name for this op. Defaults to `"inverse"`. + name: A name for this op. Defaults to `"rotation_2d/inverse"`. Returns: A `Rotation2D` representing the inverse of this rotation. """ - with self._name_scope(name or "inverse"): - return Rotation2D(_matrix=rotation_matrix_2d.inverse(self._matrix), - _name=self._name + "/inverse") + with tf.name_scope(name or "rotation_2d/inverse"): + return Rotation2D(_matrix=rotation_matrix_2d.inverse(self._matrix)) def is_valid(self, atol=1e-3, name=None): r"""Determines if this is a valid rotation. @@ -152,13 +146,13 @@ def is_valid(self, atol=1e-3, name=None): Args: atol: A `float`. The absolute tolerance parameter. - name: A name for this op. Defaults to `"is_valid"`. + name: A name for this op. Defaults to `"rotation_2d/is_valid"`. Returns: A boolean `tf.Tensor` with shape `[..., 1]`, `True` if the corresponding matrix is valid and `False` otherwise. """ - with self._name_scope(name or "is_valid"): + with tf.name_scope(name or "rotation_2d/is_valid"): return rotation_matrix_2d.is_valid(self._matrix, atol=atol) def rotate(self, point, name=None): @@ -169,7 +163,7 @@ def rotate(self, point, name=None): represents a 2D point and `...` represents any number of batch dimensions, which must be broadcastable with the batch shape of this rotation. - name: A name for this op. Defaults to `"rotate"`. + name: A name for this op. Defaults to `"rotation_2d/rotate"`. Returns: A `tf.Tensor` of shape `[..., 2]`, where the last dimension represents @@ -179,7 +173,7 @@ def rotate(self, point, name=None): Raises: ValueError: If the shape of `point` is invalid. """ - with self._name_scope(name or "rotate"): + with tf.name_scope(name or "rotation_2d/rotate"): return rotation_matrix_2d.rotate(point, self._matrix) def __eq__(self, other): @@ -189,7 +183,12 @@ def __eq__(self, other): def __matmul__(self, other): """Composes this rotation with another rotation.""" - return Rotation2D(_matrix=self._matrix @ other._matrix,) + return Rotation2D(_matrix=self._matrix @ other._matrix) + + def __repr__(self): + """Returns a string representation of this rotation.""" + name = self.__name__ + return f"<{name}(shape={str(self.shape)}, dtype={self.dtype.name})>" def __validate__(self): """Checks that this rotation is a valid rotation. @@ -208,18 +207,6 @@ def dtype(self): """Returns the dtype of this rotation.""" return self._matrix.dtype - @property - def name(self): - """Returns the name of this rotation.""" - return self._name - - @contextlib.contextmanager - def _name_scope(self, name=None): - """Helper function to standardize op scope.""" - with tf.name_scope(self.name): - with tf.name_scope(name) as scope: - yield scope - @tf.experimental.dispatch_for_api(tf.shape, {'input': Rotation2D}) def rotation_2d_shape(input, out_type=tf.int32, name=None): diff --git a/tensorflow_mri/python/geometry/rotation_2d_test.py b/tensorflow_mri/python/geometry/rotation_2d_test.py index d536ec35..0fddbd4b 100644 --- a/tensorflow_mri/python/geometry/rotation_2d_test.py +++ b/tensorflow_mri/python/geometry/rotation_2d_test.py @@ -40,9 +40,10 @@ from tensorflow_mri.python.util import test_util -class RotationMatrix2DTest(test_util.TestCase): +class Rotation2DTest(test_util.TestCase): """Tests for `Rotation2D`.""" def test_shape(self): + """Tests shape.""" rot = Rotation2D.from_euler([0.0]) self.assertAllEqual([], rot.shape) self.assertAllEqual([], tf.shape(rot)) @@ -51,7 +52,31 @@ def test_shape(self): self.assertAllEqual([2], rot.shape) self.assertAllEqual([2], tf.shape(rot)) + def test_equal(self): + """Tests equality operator.""" + rot1 = Rotation2D.from_euler([0.0]) + rot2 = Rotation2D.from_euler([0.0]) + self.assertAllEqual(True, rot1 == rot2) + + rot1 = Rotation2D.from_euler([0.0]) + rot2 = Rotation2D.from_euler([np.pi]) + self.assertAllEqual(False, rot1 == rot2) + + rot1 = Rotation2D.from_euler([[0.0], [np.pi]]) + rot2 = Rotation2D.from_euler([[0.0], [np.pi]]) + self.assertAllEqual([True, True], rot1 == rot2) + + rot1 = Rotation2D.from_euler([[0.0], [0.0]]) + rot2 = Rotation2D.from_euler([[0.0], [np.pi]]) + self.assertAllEqual([True, False], rot1 == rot2) + + def test_repr(self): + rot = Rotation2D.from_euler([0.0]) + self.assertEqual( + "", repr(rot)) + def test_from_matrix(self): + """Tests that rotation can be initialized from matrix.""" rot = Rotation2D.from_matrix(np.eye(2)) self.assertAllClose(np.eye(2), rot.as_matrix()) diff --git a/tensorflow_mri/python/geometry/rotation_3d.py b/tensorflow_mri/python/geometry/rotation_3d.py index ec1eb08c..88d2ed72 100644 --- a/tensorflow_mri/python/geometry/rotation_3d.py +++ b/tensorflow_mri/python/geometry/rotation_3d.py @@ -14,8 +14,6 @@ # ============================================================================== """3D rotation.""" -import contextlib - import tensorflow as tf from tensorflow_mri.python.geometry.rotation import rotation_matrix_3d @@ -23,10 +21,10 @@ @api_util.export("geometry.Rotation3D") -class Rotation3D(tf.experimental.ExtensionType): +class Rotation3D(tf.experimental.BatchableExtensionType): """Represents a 3D rotation (or a batch thereof).""" + __name__ = "tfmri.geometry.Rotation3D" _matrix: tf.Tensor - _name: str = "rotation_3d" @classmethod def from_matrix(cls, matrix, name=None): @@ -40,9 +38,8 @@ def from_matrix(cls, matrix, name=None): Returns: A `Rotation3D`. """ - name = name or "rotation_3d/from_matrix" - with tf.name_scope(name): - return cls(_matrix=matrix, _name=name) + with tf.name_scope(name or "rotation_3d/from_matrix"): + return cls(_matrix=matrix) @classmethod def from_euler(cls, angles, name=None): @@ -68,9 +65,8 @@ def from_euler(cls, angles, name=None): Raises: ValueError: If the shape of `angles` is invalid. """ - name = name or "rotation_3d/from_matrix" - with tf.name_scope(name): - return cls(_matrix=rotation_matrix_3d.from_euler(angles), _name=name) + with tf.name_scope(name or "rotation_3d/from_euler"): + return cls(_matrix=rotation_matrix_3d.from_euler(angles)) @classmethod def from_small_euler(cls, angles, name=None): @@ -105,10 +101,8 @@ def from_small_euler(cls, angles, name=None): Raises: ValueError: If the shape of `angles` is invalid. """ - name = name or "rotation_3d/from_small_euler" - with tf.name_scope(name): - return cls(_matrix=rotation_matrix_3d.from_small_euler(angles), - _name=name) + with tf.name_scope(name or "rotation_3d/from_small_euler"): + return cls(_matrix=rotation_matrix_3d.from_small_euler(angles)) @classmethod def from_axis_angle(cls, axis, angle, name=None): @@ -127,10 +121,8 @@ def from_axis_angle(cls, axis, angle, name=None): Raises: ValueError: If the shape of `axis` or `angle` is invalid. """ - name = name or "rotation_3d/from_axis_angle" - with tf.name_scope(name): - return cls(_matrix=rotation_matrix_3d.from_axis_angle(axis, angle), - _name=name) + with tf.name_scope(name or "rotation_3d/from_axis_angle"): + return cls(_matrix=rotation_matrix_3d.from_axis_angle(axis, angle)) @classmethod def from_quaternion(cls, quaternion, name=None): @@ -147,35 +139,32 @@ def from_quaternion(cls, quaternion, name=None): Raises: ValueError: If the shape of `quaternion` is invalid. """ - name = name or "rotation_3d/from_quaternion" - with tf.name_scope(name): - return cls(_matrix=rotation_matrix_3d.from_quaternion(quaternion), - _name=name) + with tf.name_scope(name or "rotation_3d/from_quaternion"): + return cls(_matrix=rotation_matrix_3d.from_quaternion(quaternion)) def as_matrix(self, name=None): r"""Returns the rotation matrix that represents this rotation. Args: - name: A name for this op. Defaults to `"as_matrix"`. + name: A name for this op. Defaults to `"rotation_3d/as_matrix"`. Returns: A `tf.Tensor` of shape `[..., 3, 3]`. """ - with self._name_scope(name or "as_matrix"): + with tf.name_scope(name or "rotation_3d/as_matrix"): return tf.identity(self._matrix) def inverse(self, name=None): r"""Computes the inverse of this rotation. Args: - name: A name for this op. Defaults to `"inverse"`. + name: A name for this op. Defaults to `"rotation_3d/inverse"`. Returns: A `Rotation3D` representing the inverse of this rotation. """ - with self._name_scope(name or "inverse"): - return Rotation3D(_matrix=rotation_matrix_3d.inverse(self._matrix), - _name=self._name + "/inverse") + with tf.name_scope(name or "rotation_3d/inverse"): + return Rotation3D(_matrix=rotation_matrix_3d.inverse(self._matrix)) def is_valid(self, atol=1e-3, name=None): r"""Determines if this is a valid rotation. @@ -185,13 +174,13 @@ def is_valid(self, atol=1e-3, name=None): Args: atol: A `float`. The absolute tolerance parameter. - name: A name for this op. Defaults to `"is_valid"`. + name: A name for this op. Defaults to `"rotation_3d/is_valid"`. Returns: A boolean `tf.Tensor` with shape `[..., 1]`, `True` if the corresponding matrix is valid and `False` otherwise. """ - with self._name_scope(name or "is_valid"): + with tf.name_scope(name or "rotation_3d/is_valid"): return rotation_matrix_3d.is_valid(self._matrix, atol=atol) def rotate(self, point, name=None): @@ -202,7 +191,7 @@ def rotate(self, point, name=None): represents a 3D point and `...` represents any number of batch dimensions, which must be broadcastable with the batch shape of this rotation. - name: A name for this op. Defaults to `"rotate"`. + name: A name for this op. Defaults to `"rotation_3d/rotate"`. Returns: A `tf.Tensor` of shape `[..., 3]`, where the last dimension represents @@ -212,7 +201,7 @@ def rotate(self, point, name=None): Raises: ValueError: If the shape of `point` is invalid. """ - with self._name_scope(name or "rotate"): + with tf.name_scope(name or "rotation_3d/rotate"): return rotation_matrix_3d.rotate(point, self._matrix) def __eq__(self, other): @@ -222,8 +211,12 @@ def __eq__(self, other): def __matmul__(self, other): """Composes this rotation with another rotation.""" - return Rotation3D(_matrix=self._matrix @ other._matrix, - _name=self._name + "_o_" + other._name) + return Rotation3D(_matrix=self._matrix @ other._matrix) + + def __repr__(self): + """Returns a string representation of this rotation.""" + name = self.__name__ + return f"<{name}(shape={str(self.shape)}, dtype={self.dtype.name})>" def __validate__(self): """Checks that this rotation is a valid rotation. @@ -242,14 +235,7 @@ def dtype(self): """Returns the dtype of this rotation.""" return self._matrix.dtype - @property - def name(self): - """Returns the name of this rotation.""" - return self._name - - @contextlib.contextmanager - def _name_scope(self, name=None): - """Helper function to standardize op scope.""" - with tf.name_scope(self.name): - with tf.name_scope(name) as scope: - yield scope + +@tf.experimental.dispatch_for_api(tf.shape, {'input': Rotation3D}) +def rotation_3d_shape(input, out_type=tf.int32, name=None): + return tf.shape(input._matrix, out_type=out_type, name=name)[:-2] diff --git a/tensorflow_mri/python/geometry/rotation_3d_test.py b/tensorflow_mri/python/geometry/rotation_3d_test.py index ee343a74..bb96dfae 100644 --- a/tensorflow_mri/python/geometry/rotation_3d_test.py +++ b/tensorflow_mri/python/geometry/rotation_3d_test.py @@ -39,8 +39,41 @@ from tensorflow_mri.python.util import test_util -class RotationMatrix3DTest(test_util.TestCase): +class Rotation3DTest(test_util.TestCase): """Tests for `Rotation3D`.""" + def test_shape(self): + """Tests shape.""" + rot = Rotation3D.from_euler([0.0, 0.0, 0.0]) + self.assertAllEqual([], rot.shape) + self.assertAllEqual([], tf.shape(rot)) + + rot = Rotation3D.from_euler([[0.0, 0.0, 0.0], [np.pi, 0.0, 0.0]]) + self.assertAllEqual([2], rot.shape) + self.assertAllEqual([2], tf.shape(rot)) + + def test_equal(self): + """Tests equality operator.""" + rot1 = Rotation3D.from_euler([0.0, 0.0, 0.0]) + rot2 = Rotation3D.from_euler([0.0, 0.0, 0.0]) + self.assertAllEqual(True, rot1 == rot2) + + rot1 = Rotation3D.from_euler([0.0, 0.0, 0.0]) + rot2 = Rotation3D.from_euler([np.pi, 0.0, 0.0]) + self.assertAllEqual(False, rot1 == rot2) + + rot1 = Rotation3D.from_euler([[0.0, 0.0, 0.0], [np.pi, 0.0, 0.0]]) + rot2 = Rotation3D.from_euler([[0.0, 0.0, 0.0], [np.pi, 0.0, 0.0]]) + self.assertAllEqual([True, True], rot1 == rot2) + + rot1 = Rotation3D.from_euler([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]) + rot2 = Rotation3D.from_euler([[0.0, 0.0, 0.0], [np.pi, 0.0, 0.0]]) + self.assertAllEqual([True, False], rot1 == rot2) + + def test_repr(self): + rot = Rotation3D.from_euler([0.0, 0.0, 0.0]) + self.assertEqual( + "", repr(rot)) + def test_from_axis_angle_normalized_random(self): """Tests that axis-angles can be converted to rotation matrices.""" tensor_shape = np.random.randint(1, 10, size=np.random.randint(3)).tolist() From 3f129037b00a76247a7c0af2ae7838bc6087acd2 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Sun, 28 Aug 2022 18:57:36 +0000 Subject: [PATCH 053/101] Added docs to Rotation2D --- RELEASE.md | 5 ++ tensorflow_mri/python/geometry/rotation_2d.py | 62 ++++++++++++++++++- tensorflow_mri/python/geometry/rotation_3d.py | 6 +- 3 files changed, 71 insertions(+), 2 deletions(-) diff --git a/RELEASE.md b/RELEASE.md index a89ebb12..0d263bd8 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -23,6 +23,11 @@ ## Bug Fixes and Other Changes +- `tfmri`: + + - Removed the TensorFlow Graphics dependency, which should also eliminate + the common OpenEXR error. + - `tfmri.recon`: - Improved error reporting for ``least_squares``. diff --git a/tensorflow_mri/python/geometry/rotation_2d.py b/tensorflow_mri/python/geometry/rotation_2d.py index 30820df4..5fc46023 100644 --- a/tensorflow_mri/python/geometry/rotation_2d.py +++ b/tensorflow_mri/python/geometry/rotation_2d.py @@ -22,7 +22,63 @@ @api_util.export("geometry.Rotation2D") class Rotation2D(tf.experimental.BatchableExtensionType): - """Represents a 2D rotation (or a batch thereof).""" + """Represents a rotation in 2D space (or a batch thereof). + + You can initialize a `Rotation2D` object using one of the `from_*` class + methods: + + - `from_matrix`, to initialize using a + [rotation matrix](https://en.wikipedia.org/wiki/Rotation_matrix). + - `from_euler`, to initialize using an angle (in radians). + - `from_small_euler`, to initialize using an angle which is small enough + to fall under the [small angle approximation](https://en.wikipedia.org/wiki/Small-angle_approximation). + + In all cases the above methods can accept a batch, in which case the returned + `Rotation2D` object will also have a batch shape. + + Once initialized, `Rotation2D` objects expose several methods to operate + easily. These can all be used in the same way regardless of how the + `Rotation2D` was originally initialized. + + - `rotate` rotates a point or a batch of points. The batch shapes of the + point and this rotation will be broadcasted. + - `inverse` returns a new `Rotation2D` object representing the inverse of + the current rotation. + - `is_valid` can be used to check if the rotation is valid. + + Finally, the `as_*` methods can be used to obtain an explicit representation + of this rotation. + + - `as_matrix` returns the corresponding rotation matrix. + + Example: + + >>> # Initialize a rotation object using a rotation matrix. + >>> rot = tfmri.geometry.Rotation2D.from_matrix([[0.0, -1.0], [1.0, 0.0]]) + >>> print(rot) + tfmri.geometry.Rotation2D(shape=(), dtype=float32) + >>> # Rotate a point. + >>> point = tf.constant([1.0, 0.0], dtype=tf.float32) + >>> rotated = rot.rotate(point) + >>> print(rotated) + tf.Tensor([0. 1.], shape=(2,), dtype=float32) + >>> # Rotate the point back using the inverse rotation. + >>> inv_rot = rot.inverse() + >>> restored = inv_rot.rotate(rotated) + >>> print(restored) + tf.Tensor([1. 0.], shape=(2,), dtype=float32) + >>> # Get the rotation matrix for the inverse rotation. + >>> print(inv_rot.as_matrix()) + tf.Tensor( + [[ 0. 1.] + [-1. 0.]], shape=(2, 2), dtype=float32) + >>> # You can also initialize a rotation using an angle: + >>> rot2 = tfmri.geometry.Rotation2D.from_euler([np.pi / 2]) + >>> rotated2 = rot.rotate(point) + >>> np.allclose(rotated2, rotated) + True + + """ __name__ = "tfmri.geometry.Rotation2D" _matrix: tf.Tensor @@ -190,6 +246,10 @@ def __repr__(self): name = self.__name__ return f"<{name}(shape={str(self.shape)}, dtype={self.dtype.name})>" + def __str__(self): + """Returns a string representation of this rotation.""" + return self.__repr__()[1:-1] + def __validate__(self): """Checks that this rotation is a valid rotation. diff --git a/tensorflow_mri/python/geometry/rotation_3d.py b/tensorflow_mri/python/geometry/rotation_3d.py index 88d2ed72..7f856161 100644 --- a/tensorflow_mri/python/geometry/rotation_3d.py +++ b/tensorflow_mri/python/geometry/rotation_3d.py @@ -22,7 +22,7 @@ @api_util.export("geometry.Rotation3D") class Rotation3D(tf.experimental.BatchableExtensionType): - """Represents a 3D rotation (or a batch thereof).""" + """Represents a rotation in 3D space (or a batch thereof).""" __name__ = "tfmri.geometry.Rotation3D" _matrix: tf.Tensor @@ -218,6 +218,10 @@ def __repr__(self): name = self.__name__ return f"<{name}(shape={str(self.shape)}, dtype={self.dtype.name})>" + def __str__(self): + """Returns a string representation of this rotation.""" + return self.__repr__()[1:-1] + def __validate__(self): """Checks that this rotation is a valid rotation. From 5c63945c2177124a9753093ce15171617554f135 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Mon, 29 Aug 2022 13:27:30 +0000 Subject: [PATCH 054/101] Added doctest discovery --- tensorflow_mri/__init__.py | 42 +++++ .../python/geometry/rotation/euler_2d.py | 54 ++++++ tensorflow_mri/python/geometry/rotation_2d.py | 159 ++++++++++++++++-- .../python/geometry/rotation_2d_test.py | 34 +++- tensorflow_mri/python/geometry/rotation_3d.py | 64 ++++++- tensorflow_mri/python/io/twix_io.py | 24 +-- .../python/linalg/linear_operator_nufft.py | 14 +- tensorflow_mri/python/ops/traj_ops.py | 77 +++++---- tensorflow_mri/python/ops/wavelet_ops.py | 5 +- tools/build/create_api.py | 42 +++++ tools/docs/conf.py | 37 +++- tools/docs/test_docs.py | 15 -- 12 files changed, 470 insertions(+), 97 deletions(-) create mode 100644 tensorflow_mri/python/geometry/rotation/euler_2d.py delete mode 100644 tools/docs/test_docs.py diff --git a/tensorflow_mri/__init__.py b/tensorflow_mri/__init__.py index 7c3373bc..57851ed0 100644 --- a/tensorflow_mri/__init__.py +++ b/tensorflow_mri/__init__.py @@ -1,6 +1,7 @@ # This file was automatically generated by tools/build/create_api.py. # Do not edit. """TensorFlow MRI.""" +import glob as _glob import os as _os import sys as _sys @@ -54,3 +55,44 @@ __path__ = [_tfmri_api_dir] elif _tfmri_api_dir not in __path__: __path__.append(_tfmri_api_dir) + +# Hook for loading tests by `unittest`. +def load_tests(loader, tests, pattern): + """Loads all TFMRI tests, including unit tests and doc tests. + + For the parameters, see the + [`load_tests` protocol](https://docs.python.org/3/library/unittest.html#load-tests-protocol). + """ + import doctest # pylint: disable=import-outside-toplevel + + # This loads all the regular unit tests. These three lines essentially + # replicate the standard behavior if there was no `load_tests` function. + root_dir = _os.path.dirname(__file__) + unit_tests = loader.discover(start_dir=root_dir, pattern=pattern) + tests.addTests(unit_tests) + + def set_up_doc_test(test): + """Sets up a doctest. + + Runs at the beginning of every doctest. We use it to import common + packages including NumPy, TensorFlow and TensorFlow MRI. Tests are kept + more concise by not repeating these imports each time. + + Args: + test: A `DocTest` object. + """ + # pylint: disable=import-outside-toplevel,import-self + import numpy as _np + import tensorflow as _tf + import tensorflow_mri as _tfmri + # Add these packages to globals. + test.globs['np'] = _np + test.globs['tf'] = _tf + test.globs['tfmri'] = _tfmri + + # Now load all the doctests. + py_files = _glob.glob(_os.path.join(root_dir, '**/*.py'), recursive=True) + tests.addTests(doctest.DocFileSuite( + *py_files, module_relative=False, setUp=set_up_doc_test)) + + return tests diff --git a/tensorflow_mri/python/geometry/rotation/euler_2d.py b/tensorflow_mri/python/geometry/rotation/euler_2d.py new file mode 100644 index 00000000..fa7851ba --- /dev/null +++ b/tensorflow_mri/python/geometry/rotation/euler_2d.py @@ -0,0 +1,54 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== + +# Copyright 2020 The TensorFlow Authors +# +# 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 +# +# https://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. +# ============================================================================== +"""2D angles.""" + +import tensorflow as tf + + +def from_matrix(matrix): + """Converts a 2D rotation matrix to an angle. + + Args: + matrix: A `tf.Tensor` of shape `[..., 2, 2]`. + + Returns: + A `tf.Tensor` of shape `[..., 1]`. + + Raises: + ValueError: If the shape of `matrix` is invalid. + """ + matrix = tf.convert_to_tensor(matrix) + + if matrix.shape[-1] != 2 or matrix.shape[-2] != 2: + raise ValueError( + f"matrix must have shape `[..., 2, 2]`, but got: {matrix.shape}") + + angle = tf.math.atan2(matrix[..., 1, 0], matrix[..., 0, 0]) + return tf.expand_dims(angle, axis=-1) diff --git a/tensorflow_mri/python/geometry/rotation_2d.py b/tensorflow_mri/python/geometry/rotation_2d.py index 5fc46023..b3946f0b 100644 --- a/tensorflow_mri/python/geometry/rotation_2d.py +++ b/tensorflow_mri/python/geometry/rotation_2d.py @@ -16,6 +16,7 @@ import tensorflow as tf +from tensorflow_mri.python.geometry.rotation import euler_2d from tensorflow_mri.python.geometry.rotation import rotation_matrix_2d from tensorflow_mri.python.util import api_util @@ -24,6 +25,12 @@ class Rotation2D(tf.experimental.BatchableExtensionType): """Represents a rotation in 2D space (or a batch thereof). + A `Rotation2D` contains all the information needed to represent a rotation + in 2D space (or a multidimensional array of rotations) and provides + convenient methods to work with rotations. + + ## Initialization + You can initialize a `Rotation2D` object using one of the `from_*` class methods: @@ -33,12 +40,14 @@ class Rotation2D(tf.experimental.BatchableExtensionType): - `from_small_euler`, to initialize using an angle which is small enough to fall under the [small angle approximation](https://en.wikipedia.org/wiki/Small-angle_approximation). - In all cases the above methods can accept a batch, in which case the returned - `Rotation2D` object will also have a batch shape. + All of the above methods accept batched inputs, in which case the returned + `Rotation2D` object will represent a batch of rotations. + + ## Methods Once initialized, `Rotation2D` objects expose several methods to operate - easily. These can all be used in the same way regardless of how the - `Rotation2D` was originally initialized. + easily with rotations. These methods are all used in the same way regardless + of how the `Rotation2D` was originally initialized. - `rotate` rotates a point or a batch of points. The batch shapes of the point and this rotation will be broadcasted. @@ -46,10 +55,68 @@ class Rotation2D(tf.experimental.BatchableExtensionType): the current rotation. - `is_valid` can be used to check if the rotation is valid. - Finally, the `as_*` methods can be used to obtain an explicit representation - of this rotation. + ## Conversion to other representations + + The `as_*` methods can be used to obtain an explicit representation + of this rotation as a standard `tf.Tensor`. - `as_matrix` returns the corresponding rotation matrix. + - `as_euler` returns the corresponding angle (in radians). + + ## Shape and dtype + + `Rotation2D` objects have a shape and a dtype, accessible via the `shape` and + `dtype` properties. The shape represents the shape of the array of + "rotations", so it is essentially the batch shape of the corresponding + rotation matrix or angles array (i.e., a `Rotation2D` representing a single + rotation has a scalar shape). + + ```{note} + As with `tf.Tensor`s, the `shape` attribute contains the static shape + as a `tf.TensorShape` and may not be fully defined outside eager execution. + To obtain the dynamic shape of a `Rotation2D` object, use `tf.shape`. + ``` + + ## Operators + + `Rotation2D` objects also override a few operators for concise and intuitive + use. + + - `==` (equality operator) can be used to check if two `Rotation2D` objects + are equal. This checks if the rotations are equivalent, regardless of how + they were defined (`rot1 == rot2`). + - `@` (matrix multiplication operator) can be used to compose two rotations + (`rot = rot1 @ rot2`). + + ## Compatibility with TensorFlow APIs + + Some TensorFlow APIs are explicitly overriden to operate with `Rotation2D` + objects. These include: + + ```{list-table} + --- + header-rows: 1 + --- + + * - API + - Description + - Notes + * - `tf.linalg.matmul` + - Composes two `Rotation2D` objects. + - `tf.linalg.matmul(rot1, rot2)` is equivalent to `rot1 @ rot2`. + * - `tf.linalg.matvec` + - Rotates a point or a batch of points. + - `tf.linalg.matvec(rot, point)` is equivalent to `rot.rotate(point)`. + * - `tf.shape` + - Returns the dynamic shape of a `Rotation2D` object. + - + ``` + + ```{warning} + While other TensorFlow APIs may also work as expected when passed a + `Rotation2D`, this is not supported and their behavior may change in the + future. + ``` Example: @@ -71,7 +138,7 @@ class Rotation2D(tf.experimental.BatchableExtensionType): >>> print(inv_rot.as_matrix()) tf.Tensor( [[ 0. 1.] - [-1. 0.]], shape=(2, 2), dtype=float32) + [-1. 0.]], shape=(2, 2), dtype=float32) >>> # You can also initialize a rotation using an angle: >>> rot2 = tfmri.geometry.Rotation2D.from_euler([np.pi / 2]) >>> rotated2 = rot.rotate(point) @@ -167,21 +234,35 @@ def from_small_euler(cls, angle, name=None): Raises: ValueError: If the shape of `angle` is invalid. """ - with tf.name_scope("rotation_2d/from_small_euler"): + with tf.name_scope(name or "rotation_2d/from_small_euler"): return cls(_matrix=rotation_matrix_2d.from_small_euler(angle)) def as_matrix(self, name=None): - r"""Returns the rotation matrix that represents this rotation. + r"""Returns a rotation matrix representation of this rotation. Args: name: A name for this op. Defaults to `"rotation_2d/as_matrix"`. Returns: - A `tf.Tensor` of shape `[..., 2, 2]`. + A `tf.Tensor` of shape `[..., 2, 2]`, where the last two dimensions + represent a rotation matrix. """ with tf.name_scope(name or "rotation_2d/as_matrix"): return tf.identity(self._matrix) + def as_euler(self, name=None): + r"""Returns an angle representation of this rotation. + + Args: + name: A name for this op. Defaults to `"rotation_2d/as_euler"`. + + Returns: + A `tf.Tensor` of shape `[..., 1]`, where the last dimension represents an + angle in radians. + """ + with tf.name_scope(name or "rotation_2d/as_euler"): + return euler_2d.from_matrix(self._matrix) + def inverse(self, name=None): r"""Computes the inverse of this rotation. @@ -239,7 +320,10 @@ def __eq__(self, other): def __matmul__(self, other): """Composes this rotation with another rotation.""" - return Rotation2D(_matrix=self._matrix @ other._matrix) + if isinstance(other, Rotation2D): + return Rotation2D(_matrix=tf.matmul(self._matrix, other._matrix)) + raise ValueError( + f"Cannot compose a `Rotation2D` with a `{type(other).__name__}`.") def __repr__(self): """Returns a string representation of this rotation.""" @@ -259,15 +343,60 @@ def __validate__(self): @property def shape(self): - """Returns the shape of this rotation.""" + """Returns the shape of this rotation. + + Returns: + A `tf.TensorShape`. + """ return self._matrix.shape[:-2] @property def dtype(self): - """Returns the dtype of this rotation.""" + """Returns the dtype of this rotation. + + Returns: + A `tf.dtypes.DType`. + """ return self._matrix.dtype +@tf.experimental.dispatch_for_api( + tf.linalg.matmul, {'a': Rotation2D, 'b': Rotation2D}) +def matmul(a, b, + transpose_a=False, + transpose_b=False, + adjoint_a=False, + adjoint_b=False, + a_is_sparse=False, + b_is_sparse=False, + output_type=None, + name=None): + if a_is_sparse or b_is_sparse: + raise ValueError("Rotation2D does not support sparse matmul.") + return Rotation2D(_matrix=tf.linalg.matmul(a.as_matrix(), b.as_matrix(), + transpose_a=transpose_a, + transpose_b=transpose_b, + adjoint_a=adjoint_a, + adjoint_b=adjoint_b, + output_type=output_type, + name=name)) + + +@tf.experimental.dispatch_for_api(tf.linalg.matvec, {'a': Rotation2D}) +def matvec(a, b, + transpose_a=False, + adjoint_a=False, + a_is_sparse=False, + b_is_sparse=False, + name=None): + if a_is_sparse or b_is_sparse: + raise ValueError("Rotation2D does not support sparse matvec.") + return tf.linalg.matvec(a.as_matrix(), b, + transpose_a=transpose_a, + adjoint_a=adjoint_a, + name=name) + + @tf.experimental.dispatch_for_api(tf.shape, {'input': Rotation2D}) -def rotation_2d_shape(input, out_type=tf.int32, name=None): - return tf.shape(input._matrix, out_type=out_type, name=name)[:-2] +def shape(input, out_type=tf.int32, name=None): + return tf.shape(input.as_matrix(), out_type=out_type, name=name)[:-2] diff --git a/tensorflow_mri/python/geometry/rotation_2d_test.py b/tensorflow_mri/python/geometry/rotation_2d_test.py index 0fddbd4b..93341a8c 100644 --- a/tensorflow_mri/python/geometry/rotation_2d_test.py +++ b/tensorflow_mri/python/geometry/rotation_2d_test.py @@ -71,9 +71,39 @@ def test_equal(self): self.assertAllEqual([True, False], rot1 == rot2) def test_repr(self): + """Tests that repr works.""" + expected = "" rot = Rotation2D.from_euler([0.0]) - self.assertEqual( - "", repr(rot)) + self.assertEqual(expected, repr(rot)) + self.assertEqual(expected[1:-1], str(rot)) + + def test_matmul(self): + """Tests that matmul works.""" + rot = Rotation2D.from_euler([np.pi]) + composed = rot @ rot + self.assertAllClose(np.eye(2), composed.as_matrix()) + + composed = tf.linalg.matmul(rot, rot) + self.assertAllClose(np.eye(2), composed.as_matrix()) + + def test_matvec(self): + """Tests that matvec works.""" + rot = Rotation2D.from_euler([np.pi]) + vec = tf.constant([1.0, -1.0]) + self.assertAllClose(rot.rotate(vec), tf.linalg.matvec(rot, vec)) + + @parameterized.named_parameters( + ("0", [0.0]), + ("45", [np.pi / 4]), + ("90", [np.pi / 2]), + ("135", [np.pi * 3 / 4]), + ("-45", [-np.pi / 4]), + ("-90", [-np.pi / 2]), + ("-135", [-np.pi * 3 / 4]) + ) + def test_as_euler(self, angle): + rot = Rotation2D.from_euler(angle) + self.assertAllClose(angle, rot.as_euler()) def test_from_matrix(self): """Tests that rotation can be initialized from matrix.""" diff --git a/tensorflow_mri/python/geometry/rotation_3d.py b/tensorflow_mri/python/geometry/rotation_3d.py index 7f856161..6b0ab544 100644 --- a/tensorflow_mri/python/geometry/rotation_3d.py +++ b/tensorflow_mri/python/geometry/rotation_3d.py @@ -20,7 +20,6 @@ from tensorflow_mri.python.util import api_util -@api_util.export("geometry.Rotation3D") class Rotation3D(tf.experimental.BatchableExtensionType): """Represents a rotation in 3D space (or a batch thereof).""" __name__ = "tfmri.geometry.Rotation3D" @@ -143,13 +142,14 @@ def from_quaternion(cls, quaternion, name=None): return cls(_matrix=rotation_matrix_3d.from_quaternion(quaternion)) def as_matrix(self, name=None): - r"""Returns the rotation matrix that represents this rotation. + r"""Returns a rotation matrix representation of this rotation. Args: name: A name for this op. Defaults to `"rotation_3d/as_matrix"`. Returns: - A `tf.Tensor` of shape `[..., 3, 3]`. + A `tf.Tensor` of shape `[..., 3, 3]`, where the last two dimensions + represent a rotation matrix. """ with tf.name_scope(name or "rotation_3d/as_matrix"): return tf.identity(self._matrix) @@ -211,7 +211,10 @@ def __eq__(self, other): def __matmul__(self, other): """Composes this rotation with another rotation.""" - return Rotation3D(_matrix=self._matrix @ other._matrix) + if isinstance(other, Rotation3D): + return Rotation3D(_matrix=tf.matmul(self._matrix, other._matrix)) + raise ValueError( + f"Cannot compose a `Rotation2D` with a `{type(other).__name__}`.") def __repr__(self): """Returns a string representation of this rotation.""" @@ -231,15 +234,60 @@ def __validate__(self): @property def shape(self): - """Returns the shape of this rotation.""" + """Returns the shape of this rotation. + + Returns: + A `tf.TensorShape`. + """ return self._matrix.shape[:-2] @property def dtype(self): - """Returns the dtype of this rotation.""" + """Returns the dtype of this rotation. + + Returns: + A `tf.dtypes.DType`. + """ return self._matrix.dtype +@tf.experimental.dispatch_for_api( + tf.linalg.matmul, {'a': Rotation3D, 'b': Rotation3D}) +def matmul(a, b, + transpose_a=False, + transpose_b=False, + adjoint_a=False, + adjoint_b=False, + a_is_sparse=False, + b_is_sparse=False, + output_type=None, + name=None): + if a_is_sparse or b_is_sparse: + raise ValueError("Rotation3D does not support sparse matmul.") + return Rotation3D(_matrix=tf.linalg.matmul(a.as_matrix(), b.as_matrix(), + transpose_a=transpose_a, + transpose_b=transpose_b, + adjoint_a=adjoint_a, + adjoint_b=adjoint_b, + output_type=output_type, + name=name)) + + +@tf.experimental.dispatch_for_api(tf.linalg.matvec, {'a': Rotation3D}) +def matvec(a, b, + transpose_a=False, + adjoint_a=False, + a_is_sparse=False, + b_is_sparse=False, + name=None): + if a_is_sparse or b_is_sparse: + raise ValueError("Rotation3D does not support sparse matvec.") + return tf.linalg.matvec(a.as_matrix(), b, + transpose_a=transpose_a, + adjoint_a=adjoint_a, + name=name) + + @tf.experimental.dispatch_for_api(tf.shape, {'input': Rotation3D}) -def rotation_3d_shape(input, out_type=tf.int32, name=None): - return tf.shape(input._matrix, out_type=out_type, name=name)[:-2] +def shape(input, out_type=tf.int32, name=None): + return tf.shape(input.as_matrix(), out_type=out_type, name=name)[:-2] diff --git a/tensorflow_mri/python/io/twix_io.py b/tensorflow_mri/python/io/twix_io.py index f322135f..f8eeacf6 100644 --- a/tensorflow_mri/python/io/twix_io.py +++ b/tensorflow_mri/python/io/twix_io.py @@ -44,29 +44,29 @@ def parse_twix(contents): Example: >>> # Read bytes from file. - >>> contents = tf.io.read_file("/path/to/file.dat") + >>> contents = tf.io.read_file("/path/to/file.dat") # doctest: +SKIP >>> # Parse the contents. - >>> twix = tfmri.io.parse_twix(contents) + >>> twix = tfmri.io.parse_twix(contents) # doctest: +SKIP >>> # Access the first measurement. - >>> meas = twix.measurements[0] + >>> meas = twix.measurements[0] # doctest: +SKIP >>> # Get the protocol... - >>> protocol = meas.protocol + >>> protocol = meas.protocol # doctest: +SKIP >>> # You can index the protocol to access any of the protocol buffers, >>> # e.g., the measurement protocol. - >>> meas_prot = protocol['Meas'] + >>> meas_prot = protocol['Meas'] # doctest: +SKIP >>> # Protocol buffers are nested structures accessible with "dot notation" >>> # or "bracket notation". The following are equivalent: - >>> base_res = meas_prot.MEAS.sKSpace.lBaseResolution.value - >>> base_res = meas_prot['MEAS']['sKSpace']['lBaseResolution'].value + >>> base_res = meas_prot.MEAS.sKSpace.lBaseResolution.value # doctest: +SKIP + >>> base_res = meas_prot['MEAS']['sKSpace']['lBaseResolution'].value # doctest: +SKIP >>> # The measurement object also contains the scan data. - >>> scans = meas.scans + >>> scans = meas.scans # doctest: +SKIP >>> # Each scan has a header and the list of channels. - >>> scan_header = scans[0].header - >>> channels = scans[0].channels + >>> scan_header = scans[0].header # doctest: +SKIP + >>> channels = scans[0].channels # doctest: +SKIP >>> # Each channel also has its own header as well as the raw measurement >>> # data. - >>> channel_header = channels[0].header - >>> data = channels[0].data + >>> channel_header = channels[0].header # doctest: +SKIP + >>> data = channels[0].data # doctest: +SKIP Args: contents: A scalar `tf.Tensor` of type `string`. The encoded contents of a diff --git a/tensorflow_mri/python/linalg/linear_operator_nufft.py b/tensorflow_mri/python/linalg/linear_operator_nufft.py index bca38634..a08848be 100644 --- a/tensorflow_mri/python/linalg/linear_operator_nufft.py +++ b/tensorflow_mri/python/linalg/linear_operator_nufft.py @@ -57,25 +57,25 @@ class LinearOperatorNUFFT(linear_operator.LinearOperator): # pylint: disable=ab and wish to apply the full compensation, you can do so via the `preprocess` method. - >>> import tensorflow as tf - >>> import tensorflow_mri as tfmri >>> # Create some data. >>> image_shape = (128, 128) - >>> image = image_ops.phantom(shape=image_shape, dtype=tf.complex64) + >>> image = tfmri.image.phantom(shape=image_shape, dtype=tf.complex64) >>> trajectory = tfmri.sampling.radial_trajectory( - >>> 128, 128, flatten_encoding_dims=True) + ... base_resolution=128, views=129, flatten_encoding_dims=True) >>> density = tfmri.sampling.radial_density( - >>> 128, 128, flatten_encoding_dims=True) + ... base_resolution=128, views=129, flatten_encoding_dims=True) >>> # Create a NUFFT operator. >>> linop = tfmri.linalg.LinearOperatorNUFFT( - >>> image_shape, trajectory=trajectory, density=density) + ... image_shape, trajectory=trajectory, density=density) >>> # Create k-space. >>> kspace = tfmri.signal.nufft(image, trajectory) >>> # This reconstructs the image applying only partial compensation >>> # (square root of weights). >>> image = linop.transform(kspace, adjoint=True) >>> # This reconstructs the image with full compensation. - >>> image = linop.transform(linop.preprocess(kspace, adjoint=True), adjoint=True) + >>> image = linop.transform( + ... linop.preprocess(kspace, adjoint=True), adjoint=True) + """ def __init__(self, domain_shape, diff --git a/tensorflow_mri/python/ops/traj_ops.py b/tensorflow_mri/python/ops/traj_ops.py index bfadd63b..da0f66a5 100755 --- a/tensorflow_mri/python/ops/traj_ops.py +++ b/tensorflow_mri/python/ops/traj_ops.py @@ -198,26 +198,29 @@ def central_mask(shape, center_size, name=None): This function returns a boolean tensor of zeros with a central region of ones. - .. tip:: + ```{tip} Use this function to extract the calibration region from a Cartesian *k*-space. + ``` - .. tip:: + ```{tip} In MRI, one of the spatial frequency dimensions (readout dimension) is typically fully sampled. In this case, you might want to create a mask that has one less dimension than the corresponding *k*-space (e.g., 1D mask for 2D images or 2D mask for 3D images). + ``` - .. note:: + ```{note} The central region is always evenly shaped for even mask dimensions and oddly shaped for odd mask dimensions. This avoids phase artefacts when using the resulting mask to sample the frequency domain. + ``` Example: - >>> import tensorflow as tfmri + >>> mask = tfmri.sampling.central_mask([8], [4]) >>> mask.numpy() - array([False, False, True, True, True, True, False, False]) + array([False, False, True, True, True, True, False, False]) Args: shape: A 1D integer `tf.Tensor`. The shape of the output mask. @@ -274,29 +277,32 @@ def biphasic_mask(shape, """Returns a biphasic sampling mask. A biphasic sampling mask has a fully sampled central region and a partially - sampled peripheral region. The peripheral may be sampled uniformly or + sampled peripheral region. The peripheral region may be sampled uniformly or randomly. - .. tip:: + ```{tip} This type of mask describes the most commonly used sampling patterns in Cartesian MRI. + ``` - .. tip:: + ```{tip} In MRI, one of the spatial frequency dimensions (readout dimension) is typically fully sampled. In this case, you might want to create a mask that has one less dimension than the corresponding *k*-space (e.g., 1D mask for 2D images or 2D mask for 3D images). + ``` - .. note:: + ```{note} The central region is always evenly shaped for even mask dimensions and oddly shaped for odd mask dimensions. This avoids phase artefacts when using the resulting mask to sample the frequency domain. + ``` Example: - >>> import tensorflow as tfmri + >>> mask = tfmri.sampling.biphasic_mask([8], [2], [2]) >>> mask.numpy() - array([True, False, True, True, True, False, True, False]) + array([ True, False, True, True, True, False, True, False]) Args: shape: A 1D integer `tf.Tensor`. The shape of the output mask. @@ -439,17 +445,17 @@ def radial_trajectory(base_resolution, radians/voxel, ie, values are in the range `[-pi, pi]`. References: - .. [1] Winkelmann, S., Schaeffter, T., Koehler, T., Eggers, H. and - Doessel, O. (2007), An optimal radial profile order based on the golden - ratio for time-resolved MRI. IEEE Transactions on Medical Imaging, - 26(1): 68-76, https://doi.org/10.1109/TMI.2006.885337 - .. [2] Wundrak, S., Paul, J., Ulrici, J., Hell, E., Geibel, M.-A., - Bernhardt, P., Rottbauer, W. and Rasche, V. (2016), Golden ratio sparse - MRI using tiny golden angles. Magn. Reson. Med., 75: 2372-2378. - https://doi.org/10.1002/mrm.25831 - .. [3] Wong, S.T.S. and Roos, M.S. (1994), A strategy for sampling on a - sphere applied to 3D selective RF pulse design. Magn. Reson. Med., - 32: 778-784. https://doi.org/10.1002/mrm.1910320614 + 1. Winkelmann, S., Schaeffter, T., Koehler, T., Eggers, H. and + Doessel, O. (2007), An optimal radial profile order based on the golden + ratio for time-resolved MRI. IEEE Transactions on Medical Imaging, + 26(1): 68-76, https://doi.org/10.1109/TMI.2006.885337 + 2. Wundrak, S., Paul, J., Ulrici, J., Hell, E., Geibel, M.-A., + Bernhardt, P., Rottbauer, W. and Rasche, V. (2016), Golden ratio sparse + MRI using tiny golden angles. Magn. Reson. Med., 75: 2372-2378. + https://doi.org/10.1002/mrm.25831 + 3. Wong, S.T.S. and Roos, M.S. (1994), A strategy for sampling on a + sphere applied to 3D selective RF pulse design. Magn. Reson. Med., + 32: 778-784. https://doi.org/10.1002/mrm.1910320614 """ return _kspace_trajectory('radial', {'base_resolution': base_resolution, @@ -537,7 +543,7 @@ def spiral_trajectory(base_resolution, radians/voxel, ie, values are in the range `[-pi, pi]`. References: - .. [1] Pipe, J.G. and Zwart, N.R. (2014), Spiral trajectory design: A + 1. Pipe, J.G. and Zwart, N.R. (2014), Spiral trajectory design: A flexible numerical algorithm and base analytical equations. Magn. Reson. Med, 71: 278-285. https://doi.org/10.1002/mrm.24675 """ @@ -808,10 +814,11 @@ def estimate_radial_density(points, readout_os=2.0): This function supports 2D and 3D ("koosh-ball") radial trajectories. - .. warning:: + ```{warning} This function assumes that `points` represents a radial trajectory, but - cannot verify that. If used with trajectories other than radial, it will + will not verify that. If used with trajectories other than radial, it will not fail but the result will be invalid. + ``` Args: points: A `Tensor`. Must be one of the following types: `float32`, @@ -1121,13 +1128,13 @@ def estimate_density(points, grid_shape, method='jackson', max_iter=50): A `Tensor` of shape `[..., M]` containing the density of `points`. References: - .. [1] Jackson, J.I., Meyer, C.H., Nishimura, D.G. and Macovski, A. (1991), - Selection of a convolution function for Fourier inversion using gridding - (computerised tomography application). IEEE Transactions on Medical - Imaging, 10(3): 473-478. https://doi.org/10.1109/42.97598 - .. [2] Pipe, J.G. and Menon, P. (1999), Sampling density compensation in - MRI: Rationale and an iterative numerical solution. Magn. Reson. Med., - 41: 179-186. https://doi.org/10.1002/(SICI)1522-2594(199901)41:1<179::AID-MRM25>3.0.CO;2-V + 1. Jackson, J.I., Meyer, C.H., Nishimura, D.G. and Macovski, A. (1991), + Selection of a convolution function for Fourier inversion using gridding + (computerised tomography application). IEEE Transactions on Medical + Imaging, 10(3): 473-478. https://doi.org/10.1109/42.97598 + 2. Pipe, J.G. and Menon, P. (1999), Sampling density compensation in + MRI: Rationale and an iterative numerical solution. Magn. Reson. Med., + 41: 179-186. https://doi.org/10.1002/(SICI)1522-2594(199901)41:1<179::AID-MRM25>3.0.CO;2-V """ method = check_util.validate_enum( method, {'jackson', 'pipe'}, name='method') @@ -1304,8 +1311,9 @@ def _rotation_matrix_3d_from_euler(angles, order='XYZ', name='rotation_3d'): The resulting matrix is $$\mathbf{R} = \mathbf{R}_z\mathbf{R}_y\mathbf{R}_x$$. - .. note:: + ```{note} In the following, A1 to An are optional batch dimensions. + ``` Args: angles: A tensor of shape `[A1, ..., An, 3]`, where the last dimension @@ -1339,8 +1347,9 @@ def _rotation_matrix_3d_from_euler(angles, order='XYZ', name='rotation_3d'): def _build_matrix_from_sines_and_cosines(sin_angles, cos_angles, order='XYZ'): """Builds a rotation matrix from sines and cosines of Euler angles. - .. note:: + ```{note} In the following, A1 to An are optional batch dimensions. + ``` Args: sin_angles: A tensor of shape `[A1, ..., An, 3]`, where the last dimension diff --git a/tensorflow_mri/python/ops/wavelet_ops.py b/tensorflow_mri/python/ops/wavelet_ops.py index 157da17b..14e0db4f 100644 --- a/tensorflow_mri/python/ops/wavelet_ops.py +++ b/tensorflow_mri/python/ops/wavelet_ops.py @@ -734,7 +734,7 @@ def dwt_max_level(shape, wavelet_or_length, axes=None): The level returned is the minimum along all axes. Examples: - >>> import tensorflow_mri as tfmri + >>> tfmri.signal.max_wavelet_level((64, 32), 'db2') 3 @@ -837,10 +837,12 @@ def coeffs_to_tensor(coeffs, padding=0, axes=None): into a single, contiguous array. Examples: + >>> import tensorflow_mri as tfmri >>> image = tfmri.image.phantom() >>> coeffs = tfmri.signal.wavedec(image, wavelet='db2', level=3) >>> tensor, slices = tfmri.signal.wavelet_coeffs_to_tensor(coeffs) + """ coeffs, axes, ndim, ndim_transform = _prepare_coeffs_axes(coeffs, axes) @@ -945,6 +947,7 @@ def tensor_to_coeffs(coeff_tensor, coeff_slices): >>> coeffs_from_arr = tfmri.signal.tensor_to_wavelet_coeffs(tensor, slices) >>> image_recon = tfmri.signal.waverec(coeffs_from_arr, wavelet='db2') >>> # image and image_recon are equal + """ coeff_tensor = tf.convert_to_tensor(coeff_tensor) coeffs = [] diff --git a/tools/build/create_api.py b/tools/build/create_api.py index 501a8a03..6fee9620 100644 --- a/tools/build/create_api.py +++ b/tools/build/create_api.py @@ -32,6 +32,7 @@ '''# This file was automatically generated by ${script_path}. # Do not edit. """TensorFlow MRI.""" +import glob as _glob import os as _os import sys as _sys @@ -65,6 +66,47 @@ __path__ = [_tfmri_api_dir] elif _tfmri_api_dir not in __path__: __path__.append(_tfmri_api_dir) + +# Hook for loading tests by `unittest`. +def load_tests(loader, tests, pattern): + """Loads all TFMRI tests, including unit tests and doc tests. + + For the parameters, see the + [`load_tests` protocol](https://docs.python.org/3/library/unittest.html#load-tests-protocol). + """ + import doctest # pylint: disable=import-outside-toplevel + + # This loads all the regular unit tests. These three lines essentially + # replicate the standard behavior if there was no `load_tests` function. + root_dir = _os.path.dirname(__file__) + unit_tests = loader.discover(start_dir=root_dir, pattern=pattern) + tests.addTests(unit_tests) + + def set_up_doc_test(test): + """Sets up a doctest. + + Runs at the beginning of every doctest. We use it to import common + packages including NumPy, TensorFlow and TensorFlow MRI. Tests are kept + more concise by not repeating these imports each time. + + Args: + test: A `DocTest` object. + """ + # pylint: disable=import-outside-toplevel,import-self + import numpy as _np + import tensorflow as _tf + import tensorflow_mri as _tfmri + # Add these packages to globals. + test.globs['np'] = _np + test.globs['tf'] = _tf + test.globs['tfmri'] = _tfmri + + # Now load all the doctests. + py_files = _glob.glob(_os.path.join(root_dir, '**/*.py'), recursive=True) + tests.addTests(doctest.DocFileSuite( + *py_files, module_relative=False, setUp=set_up_doc_test)) + + return tests ''') diff --git a/tools/docs/conf.py b/tools/docs/conf.py index b5c795b3..bc55b2d4 100644 --- a/tools/docs/conf.py +++ b/tools/docs/conf.py @@ -256,18 +256,49 @@ def linkcode_resolve(domain, info): def process_docstring(app, what, name, obj, options, lines): # pylint: disable=missing-param-doc,unused-argument - """Process autodoc docstrings.""" - # Regular expression. + """Processes autodoc docstrings.""" + # Regular expressions. + blankline_re = re.compile(r"^\s*$") + prompt_re = re.compile(r"^\s*>>>") tf_symbol_re = re.compile(r"`(?Ptf\.[a-zA-Z0-9_.]+)`") + + # Loop initialization. `insert_lines` keeps a list of lines to be inserted + # as well as their positions. + insert_lines = [] + in_prompt = False + # Iterate line by line. for lineno, line in enumerate(lines): - m = tf_symbol_re.match(line) + # Check if we're in a prompt block. + if in_prompt: + # Check if end of prompt block. + if blankline_re.match(line): + in_prompt = False + insert_lines.append((lineno, "```")) + continue + + # Check for >>> prompt, if found insert code block (unless already in + # prompt). + m = prompt_re.match(line) + if m and not in_prompt: + in_prompt = True + # We need to insert a new line. It's not safe to modify the list we're + # iterating over, so instead we store the line in `insert_lines` and we + # insert it after the loop. + insert_lines.append((lineno, "```python")) + continue + + # Add links to TF symbols. + m = tf_symbol_re.search(line) if m: symbol = m.group('symbol') link = f"https://www.tensorflow.org/api_docs/python/{symbol.replace('.', '/')}" lines[lineno] = line.replace(f"`{symbol}`", f"[`{symbol}`]({link})") + # Now insert the lines (in reversed order so that line numbers stay valid). + for lineno, line in reversed(insert_lines): + lines.insert(lineno, line) def get_doc_url(name): diff --git a/tools/docs/test_docs.py b/tools/docs/test_docs.py deleted file mode 100644 index 98325c00..00000000 --- a/tools/docs/test_docs.py +++ /dev/null @@ -1,15 +0,0 @@ -import doctest -import pathlib -import sys -wdir = pathlib.Path().absolute() -sys.path.insert(0, str(wdir)) - -from tensorflow_mri.python.activations import complex_activations -from tensorflow_mri.python.ops import array_ops -from tensorflow_mri.python.ops import wavelet_ops - -kwargs = dict(raise_on_error=True) - -doctest.testmod(complex_activations, **kwargs) -doctest.testmod(array_ops, **kwargs) -doctest.testmod(wavelet_ops, **kwargs) From c99819e15f49b1de702d8cd7dc33e2e8113909e2 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Mon, 29 Aug 2022 17:46:43 +0000 Subject: [PATCH 055/101] Minor changes to new masks --- tensorflow_mri/_api/geometry/__init__.py | 1 - tensorflow_mri/_api/sampling/__init__.py | 4 +- tensorflow_mri/python/ops/traj_ops.py | 54 +++++++++++----------- tensorflow_mri/python/ops/traj_ops_test.py | 48 ++++++++++--------- 4 files changed, 56 insertions(+), 51 deletions(-) diff --git a/tensorflow_mri/_api/geometry/__init__.py b/tensorflow_mri/_api/geometry/__init__.py index 8a791278..c7365abe 100644 --- a/tensorflow_mri/_api/geometry/__init__.py +++ b/tensorflow_mri/_api/geometry/__init__.py @@ -3,4 +3,3 @@ """Geometric operations.""" from tensorflow_mri.python.geometry.rotation_2d import Rotation2D as Rotation2D -from tensorflow_mri.python.geometry.rotation_3d import Rotation3D as Rotation3D diff --git a/tensorflow_mri/_api/sampling/__init__.py b/tensorflow_mri/_api/sampling/__init__.py index 4c0629a9..19996e42 100644 --- a/tensorflow_mri/_api/sampling/__init__.py +++ b/tensorflow_mri/_api/sampling/__init__.py @@ -5,8 +5,8 @@ from tensorflow_mri.python.ops.traj_ops import density_grid as density_grid from tensorflow_mri.python.ops.traj_ops import frequency_grid as frequency_grid from tensorflow_mri.python.ops.traj_ops import random_sampling_mask as random_mask -from tensorflow_mri.python.ops.traj_ops import central_mask as central_mask -from tensorflow_mri.python.ops.traj_ops import biphasic_mask as biphasic_mask +from tensorflow_mri.python.ops.traj_ops import centre_mask as centre_mask +from tensorflow_mri.python.ops.traj_ops import accel_mask as accel_mask from tensorflow_mri.python.ops.traj_ops import radial_trajectory as radial_trajectory from tensorflow_mri.python.ops.traj_ops import spiral_trajectory as spiral_trajectory from tensorflow_mri.python.ops.traj_ops import radial_density as radial_density diff --git a/tensorflow_mri/python/ops/traj_ops.py b/tensorflow_mri/python/ops/traj_ops.py index da0f66a5..ab7d3fe0 100755 --- a/tensorflow_mri/python/ops/traj_ops.py +++ b/tensorflow_mri/python/ops/traj_ops.py @@ -192,8 +192,8 @@ def random_sampling_mask(shape, density=1.0, seed=None, rng=None, name=None): return tf.cast(mask, tf.bool) -@api_util.export("sampling.central_mask") -def central_mask(shape, center_size, name=None): +@api_util.export("sampling.centre_mask") +def centre_mask(shape, center_size, name=None): """Returns a central sampling mask. This function returns a boolean tensor of zeros with a central region of ones. @@ -218,7 +218,7 @@ def central_mask(shape, center_size, name=None): Example: - >>> mask = tfmri.sampling.central_mask([8], [4]) + >>> mask = tfmri.sampling.centre_mask([8], [4]) >>> mask.numpy() array([False, False, True, True, True, True, False, False]) @@ -239,7 +239,7 @@ def central_mask(shape, center_size, name=None): Raises: TypeError: If `center_size` is not of integer or floating point dtype. """ - with tf.name_scope(name or 'central_mask'): + with tf.name_scope(name or 'centre_mask'): shape = tf.convert_to_tensor(shape, dtype=tf.int32) center_size = tf.convert_to_tensor(center_size) @@ -266,19 +266,19 @@ def central_mask(shape, center_size, name=None): return mask -@api_util.export("sampling.biphasic_mask") -def biphasic_mask(shape, - acceleration, - central_size, - mask_type='equispaced', - offset=0, - rng=None, - name=None): - """Returns a biphasic sampling mask. +@api_util.export("sampling.accel_mask") +def accel_mask(shape, + acceleration, + centre_size=0, + mask_type='equispaced', + offset=0, + rng=None, + name=None): + """Returns a standard accelerated sampling mask. - A biphasic sampling mask has a fully sampled central region and a partially - sampled peripheral region. The peripheral region may be sampled uniformly or - randomly. + The returned sampling mask has two regions: a fully sampled central region + and a partially sampled peripheral region. The peripheral region may be + sampled uniformly or randomly. ```{tip} This type of mask describes the most commonly used sampling patterns in @@ -300,7 +300,7 @@ def biphasic_mask(shape, Example: - >>> mask = tfmri.sampling.biphasic_mask([8], [2], [2]) + >>> mask = tfmri.sampling.accel_mask([8], [2], [2]) >>> mask.numpy() array([ True, False, True, True, True, False, True, False]) @@ -308,8 +308,8 @@ def biphasic_mask(shape, shape: A 1D integer `tf.Tensor`. The shape of the output mask. acceleration: A 1D integer `tf.Tensor`. The acceleration factor on the peripheral region along each axis. - central_size: A 1D integer `tf.Tensor`. The size of the central region - along each axis. + centre_size: A 1D integer `tf.Tensor`. The size of the central region + along each axis. Defaults to 0. mask_type: A `str`. The type of sampling to use on the peripheral region. Must be one of `'equispaced'` or `'random'`. If `'equispaced'`, the peripheral region is sampled uniformly. If `'random'`, the peripheral @@ -329,7 +329,7 @@ def biphasic_mask(shape, Raises: ValueError: If `mask_type` is not one of `'equispaced'` or `'random'`. """ - with tf.name_scope(name or 'biphasic_mask'): + with tf.name_scope(name or 'accel_mask'): shape = tf.convert_to_tensor(shape, dtype=tf.int32) acceleration = tf.convert_to_tensor(acceleration) rank = tf.size(shape) @@ -338,15 +338,15 @@ def biphasic_mask(shape, with tf.init_scope(): rng = rng or tf.random.get_global_generator().split(1)[0] - # Allow scalar ints as offset. - if isinstance(offset, int): - offset = tf.ones([rank], dtype=tf.int32) * offset - elif offset == 'random': - offset = tf.map_fn(lambda maxval: rng.uniform([], minval=0, maxval=maxval, - dtype=tf.int32), + # Process `offset`. + if offset == 'random': + offset = tf.map_fn(lambda maxval: rng.uniform( + [], minval=0, maxval=maxval, dtype=tf.int32), acceleration, dtype=tf.int32) else: offset = tf.convert_to_tensor(offset, dtype=tf.int32) + if offset.shape.rank == 0: + offset = tf.ones([rank], dtype=tf.int32) * offset # Initialize mask. mask = tf.ones(shape, dtype=tf.bool) @@ -376,7 +376,7 @@ def fn(accum, elems): _, mask = tf.foldl(fn, (shape, acceleration, offset), initializer=(0, mask)) - return tf.math.logical_or(mask, central_mask(shape, central_size)) + return tf.math.logical_or(mask, centre_mask(shape, centre_size)) @api_util.export("sampling.radial_trajectory") diff --git a/tensorflow_mri/python/ops/traj_ops_test.py b/tensorflow_mri/python/ops/traj_ops_test.py index fb5cdfc9..edf632c5 100755 --- a/tensorflow_mri/python/ops/traj_ops_test.py +++ b/tensorflow_mri/python/ops/traj_ops_test.py @@ -103,93 +103,99 @@ def test_frequency_grid_2d(self): class CentralMaskTest(test_util.TestCase): - def test_central_mask(self): - result = traj_ops.central_mask([8], [4]) + def test_centre_mask(self): + result = traj_ops.centre_mask([8], [4]) expected = [0, 0, 1, 1, 1, 1, 0, 0] self.assertAllClose(expected, result) - result = traj_ops.central_mask([9], [5]) + result = traj_ops.centre_mask([9], [5]) expected = [0, 0, 1, 1, 1, 1, 1, 0, 0] self.assertAllClose(expected, result) - result = traj_ops.central_mask([8], [0.5]) + result = traj_ops.centre_mask([8], [0.5]) expected = [0, 0, 1, 1, 1, 1, 0, 0] self.assertAllClose(expected, result) - result = traj_ops.central_mask([9], [0.5]) + result = traj_ops.centre_mask([9], [0.5]) expected = [0, 0, 1, 1, 1, 1, 1, 0, 0] self.assertAllClose(expected, result) - result = traj_ops.central_mask([8], [5]) + result = traj_ops.centre_mask([8], [5]) expected = [0, 0, 1, 1, 1, 1, 0, 0] self.assertAllClose(expected, result) - result = traj_ops.central_mask([4, 8], [2, 4]) + result = traj_ops.centre_mask([4, 8], [2, 4]) expected = [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]] self.assertAllClose(expected, result) - result = traj_ops.central_mask([4, 8], [1.0, 0.5]) + result = traj_ops.centre_mask([4, 8], [1.0, 0.5]) expected = [[0, 0, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0]] self.assertAllClose(expected, result) - -class BiphasicMaskTest(test_util.TestCase): - def test_biphasic_mask(self): - result = traj_ops.biphasic_mask([16], [4], [0]) + +class AccelMaskTest(test_util.TestCase): + def test_accel_mask(self): + result = traj_ops.accel_mask([16], [4], [0]) expected = [1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0] self.assertAllClose(expected, result) - result = traj_ops.biphasic_mask([16], [4], [4]) + result = traj_ops.accel_mask([16], [4], [4]) expected = [1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0] self.assertAllClose(expected, result) - result = traj_ops.biphasic_mask([16], [2], [6]) + result = traj_ops.accel_mask([16], [2], [6]) expected = [1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0] self.assertAllClose(expected, result) - result = traj_ops.biphasic_mask([16], [2], [6]) + result = traj_ops.accel_mask([16], [2], [6]) expected = [1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0] self.assertAllClose(expected, result) - result = traj_ops.biphasic_mask([16], [4], [0], offset=1) + result = traj_ops.accel_mask([16], [4], [0], offset=1) expected = [0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0] self.assertAllClose(expected, result) - result = traj_ops.biphasic_mask([4, 8], [2, 2], [0, 0]) + result = traj_ops.accel_mask([4, 8], [2, 2], [0, 0]) expected = [[1, 0, 1, 0, 1, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 1, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0]] self.assertAllClose(expected, result) - result = traj_ops.biphasic_mask([4, 8], [2, 2], [0, 0], offset=[1, 0]) + result = traj_ops.accel_mask([4, 8], [2, 2], [0, 0], offset=[1, 0]) expected = [[0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 1, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 1, 0, 1, 0]] self.assertAllClose(expected, result) - result = traj_ops.biphasic_mask([4, 8], [2, 3], [0, 0], offset=[1, 0]) + result = traj_ops.accel_mask([4, 8], [2, 3], [0, 0], offset=[1, 0]) expected = [[0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 0, 1, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 0, 1, 0, 0, 1, 0]] self.assertAllClose(expected, result) - result = traj_ops.biphasic_mask([4, 8], [2, 2], [2, 2]) + result = traj_ops.accel_mask([4, 8], [2, 2], [2, 2]) expected = [[1, 0, 1, 0, 1, 0, 1, 0], [0, 0, 0, 1, 1, 0, 0, 0], [1, 0, 1, 1, 1, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0]] self.assertAllClose(expected, result) - result = traj_ops.biphasic_mask([16], [4], [0], mask_type='random') + result = traj_ops.accel_mask([16], [4], 0) + expected = [1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0] + self.assertAllClose(expected, result) + + result = traj_ops.accel_mask([16], [4]) + expected = [1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0] + self.assertAllClose(expected, result) class RadialTrajectoryTest(test_util.TestCase): From e3001997dc0db8484fe8edcb96a50c93dc687743 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Mon, 29 Aug 2022 17:58:42 +0000 Subject: [PATCH 056/101] Fixed a bug in mod relu [skip ci] --- tensorflow_mri/python/activations/complex_activations.py | 4 +++- .../python/activations/complex_activations_test.py | 7 +++++++ 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/tensorflow_mri/python/activations/complex_activations.py b/tensorflow_mri/python/activations/complex_activations.py index 292159aa..42ad50a0 100644 --- a/tensorflow_mri/python/activations/complex_activations.py +++ b/tensorflow_mri/python/activations/complex_activations.py @@ -31,8 +31,10 @@ def wrapper(x, *args, **kwargs): x = tf.convert_to_tensor(x) if x.dtype.is_complex: if split == 'abs_angle': + j = tf.dtypes.complex(tf.zeros((), dtype=x.dtype.real_dtype), + tf.ones((), dtype=x.dtype.real_dtype)) return (tf.cast(func(tf.math.abs(x), *args, **kwargs), x.dtype) * - tf.math.exp(1j * tf.math.angle(x))) + tf.math.exp(j * tf.cast(tf.math.angle(x), x.dtype))) if split == 'real_imag': return tf.dtypes.complex(func(tf.math.real(x), *args, **kwargs), func(tf.math.imag(x), *args, **kwargs)) diff --git a/tensorflow_mri/python/activations/complex_activations_test.py b/tensorflow_mri/python/activations/complex_activations_test.py index a6b55f9e..9c30aead 100644 --- a/tensorflow_mri/python/activations/complex_activations_test.py +++ b/tensorflow_mri/python/activations/complex_activations_test.py @@ -28,6 +28,13 @@ def test_complex_relu(self): result = complex_activations.complex_relu(inputs) self.assertAllClose(expected, result) + @test_util.run_all_execution_modes + def test_mod_relu(self): + inputs = [1.0 - 2.0j, 1.0 + 3.0j, -2.0 + 1.0j, -3.0 - 4.0j] + expected = [0.0 + 0.0j, 1.0 + 3.0j, 0.0 + 0.0j, -3.0 - 4.0j] + result = complex_activations.mod_relu(inputs, threshold=3.0) + self.assertAllClose(expected, result) + if __name__ == '__main__': tf.test.main() From 3e7402a4e15dc56de6b7161147851a8f9c09e502 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Mon, 29 Aug 2022 18:12:45 +0000 Subject: [PATCH 057/101] Removed deprecated arguments --- tensorflow_mri/python/losses/iqa_losses.py | 50 ++------------ tensorflow_mri/python/metrics/iqa_metrics.py | 21 ------ tensorflow_mri/python/ops/image_ops.py | 71 +++----------------- tensorflow_mri/python/ops/recon_ops.py | 9 --- tensorflow_mri/python/util/deprecation.py | 1 - 5 files changed, 14 insertions(+), 138 deletions(-) diff --git a/tensorflow_mri/python/losses/iqa_losses.py b/tensorflow_mri/python/losses/iqa_losses.py index bde0c74d..99598450 100644 --- a/tensorflow_mri/python/losses/iqa_losses.py +++ b/tensorflow_mri/python/losses/iqa_losses.py @@ -111,11 +111,6 @@ class SSIMLoss(LossFunctionWrapperIQA): `(rank of inputs) - batch_dims - 1`. Defaults to `None`. `image_dims` can always be inferred if `batch_dims` was specified, so you only need to provide one of the two. - rank: An `int`. The number of spatial dimensions. Must be 2 or 3. Defaults - to `tf.rank(y_true) - 2`. In other words, if rank is not explicitly set, - `y_true` and `y_pred` should have shape `[batch, height, width, channels]` - if processing 2D images or `[batch, depth, height, width, channels]` if - processing 3D images. multichannel: A `boolean`. Whether multichannel computation is enabled. If `False`, the inputs `y_true` and `y_pred` are not expected to have a channel dimension, i.e. they should have shape @@ -134,10 +129,6 @@ class SSIMLoss(LossFunctionWrapperIQA): for image restoration with neural networks. IEEE Transactions on computational imaging, 3(1), 47-57. """ - @deprecation.deprecated_args( - deprecation.REMOVAL_DATE['0.19.0'], - 'Use argument `image_dims` instead.', - ('rank', None)) def __init__(self, max_val=None, filter_size=11, @@ -146,7 +137,6 @@ def __init__(self, k2=0.03, batch_dims=None, image_dims=None, - rank=None, multichannel=True, complex_part=None, reduction=tf.keras.losses.Reduction.AUTO, @@ -161,7 +151,6 @@ def __init__(self, k2=k2, batch_dims=batch_dims, image_dims=image_dims, - rank=rank, multichannel=multichannel, complex_part=complex_part) @@ -201,11 +190,6 @@ class SSIMMultiscaleLoss(LossFunctionWrapperIQA): `(rank of inputs) - batch_dims - 1`. Defaults to `None`. `image_dims` can always be inferred if `batch_dims` was specified, so you only need to provide one of the two. - rank: An `int`. The number of spatial dimensions. Must be 2 or 3. Defaults - to `tf.rank(y_true) - 2`. In other words, if rank is not explicitly set, - `y_true` and `y_pred` should have shape `[batch, height, width, channels]` - if processing 2D images or `[batch, depth, height, width, channels]` if - processing 3D images. multichannel: A `boolean`. Whether multichannel computation is enabled. If `False`, the inputs `y_true` and `y_pred` are not expected to have a channel dimension, i.e. they should have shape @@ -224,10 +208,6 @@ class SSIMMultiscaleLoss(LossFunctionWrapperIQA): for image restoration with neural networks. IEEE Transactions on computational imaging, 3(1), 47-57. """ - @deprecation.deprecated_args( - deprecation.REMOVAL_DATE['0.19.0'], - 'Use argument `image_dims` instead.', - ('rank', None)) def __init__(self, max_val=None, power_factors=image_ops._MSSSIM_WEIGHTS, @@ -237,7 +217,6 @@ def __init__(self, k2=0.03, batch_dims=None, image_dims=None, - rank=None, multichannel=True, complex_part=None, reduction=tf.keras.losses.Reduction.AUTO, @@ -253,20 +232,15 @@ def __init__(self, k2=k2, batch_dims=batch_dims, image_dims=image_dims, - rank=rank, multichannel=multichannel, complex_part=complex_part) @api_util.export("losses.ssim_loss") -@deprecation.deprecated_args( - deprecation.REMOVAL_DATE['0.19.0'], - 'Use argument `image_dims` instead.', - ('rank', None)) @tf.keras.utils.register_keras_serializable(package="MRI") def ssim_loss(y_true, y_pred, max_val=None, filter_size=11, filter_sigma=1.5, - k1=0.01, k2=0.03, batch_dims=None, image_dims=None, rank=None): + k1=0.01, k2=0.03, batch_dims=None, image_dims=None): r"""Computes the structural similarity (SSIM) loss. The SSIM loss is equal to :math:`1.0 - \textrm{SSIM}`. @@ -305,11 +279,6 @@ def ssim_loss(y_true, y_pred, max_val=None, `(rank of inputs) - batch_dims - 1`. Defaults to `None`. `image_dims` can always be inferred if `batch_dims` was specified, so you only need to provide one of the two. - rank: An `int`. The number of spatial dimensions. Must be 2 or 3. Defaults - to `tf.rank(y_true) - 2`. In other words, if rank is not explicitly set, - `y_true` and `y_pred` should have shape `[batch, height, width, channels]` - if processing 2D images or `[batch, depth, height, width, channels]` if - processing 3D images. Returns: A `Tensor` of type `float32` and shape `batch_shape` containing an SSIM @@ -327,21 +296,16 @@ def ssim_loss(y_true, y_pred, max_val=None, k1=k1, k2=k2, batch_dims=batch_dims, - image_dims=image_dims, - rank=rank) + image_dims=image_dims) @api_util.export("losses.ssim_multiscale_loss") -@deprecation.deprecated_args( - deprecation.REMOVAL_DATE['0.19.0'], - 'Use argument `image_dims` instead.', - ('rank', None)) @tf.keras.utils.register_keras_serializable(package="MRI") def ssim_multiscale_loss(y_true, y_pred, max_val=None, power_factors=image_ops._MSSSIM_WEIGHTS, # pylint: disable=protected-access filter_size=11, filter_sigma=1.5, k1=0.01, k2=0.03, - batch_dims=None, image_dims=None, rank=None): + batch_dims=None, image_dims=None): r"""Computes the multiscale structural similarity (MS-SSIM) loss. The MS-SSIM loss is equal to :math:`1.0 - \textrm{MS-SSIM}`. @@ -387,11 +351,6 @@ def ssim_multiscale_loss(y_true, y_pred, max_val=None, `(rank of inputs) - batch_dims - 1`. Defaults to `None`. `image_dims` can always be inferred if `batch_dims` was specified, so you only need to provide one of the two. - rank: An `int`. The number of spatial dimensions. Must be 2 or 3. Defaults - to `tf.rank(y_true) - 2`. In other words, if rank is not explicitly set, - `y_true` and `y_pred` should have shape `[batch, height, width, channels]` - if processing 2D images or `[batch, depth, height, width, channels]` if - processing 3D images. Returns: A `Tensor` of type `float32` and shape `batch_shape` containing an SSIM @@ -410,8 +369,7 @@ def ssim_multiscale_loss(y_true, y_pred, max_val=None, k1=k1, k2=k2, batch_dims=batch_dims, - image_dims=image_dims, - rank=rank) + image_dims=image_dims) # For backward compatibility. diff --git a/tensorflow_mri/python/metrics/iqa_metrics.py b/tensorflow_mri/python/metrics/iqa_metrics.py index c23c5090..a4cf1488 100755 --- a/tensorflow_mri/python/metrics/iqa_metrics.py +++ b/tensorflow_mri/python/metrics/iqa_metrics.py @@ -111,11 +111,6 @@ class PSNR(MeanMetricWrapperIQA): `(rank of inputs) - batch_dims - 1`. Defaults to `None`. `image_dims` can always be inferred if `batch_dims` was specified, so you only need to provide one of the two. - rank: An `int`. The number of spatial dimensions. Must be 2 or 3. Defaults - to `tf.rank(y_true) - 2`. In other words, if rank is not explicitly set, - `y_true` and `y_pred` should have shape `[batch, height, width, channels]` - if processing 2D images or `[batch, depth, height, width, channels]` if - processing 3D images. multichannel: A `boolean`. Whether multichannel computation is enabled. If `False`, the inputs `y_true` and `y_pred` are not expected to have a channel dimension, i.e. they should have shape @@ -128,10 +123,6 @@ class PSNR(MeanMetricWrapperIQA): name: String name of the metric instance. dtype: Data type of the metric result. """ - @deprecation.deprecated_args( - deprecation.REMOVAL_DATE['0.19.0'], - 'Use argument `image_dims` instead.', - ('rank', None)) def __init__(self, max_val=None, batch_dims=None, @@ -209,10 +200,6 @@ class SSIM(MeanMetricWrapperIQA): Image quality assessment: from error visibility to structural similarity. IEEE transactions on image processing, 13(4), 600-612. """ - @deprecation.deprecated_args( - deprecation.REMOVAL_DATE['0.19.0'], - 'Use argument `image_dims` instead.', - ('rank', None)) def __init__(self, max_val=None, filter_size=11, @@ -221,7 +208,6 @@ def __init__(self, k2=0.03, batch_dims=None, image_dims=None, - rank=None, multichannel=True, complex_part=None, name='ssim', @@ -237,7 +223,6 @@ def __init__(self, k2=k2, batch_dims=batch_dims, image_dims=image_dims, - rank=rank, multichannel=multichannel, complex_part=complex_part) @@ -298,10 +283,6 @@ class SSIMMultiscale(MeanMetricWrapperIQA): Thrity-Seventh Asilomar Conference on Signals, Systems & Computers, 2003 (Vol. 2, pp. 1398-1402). Ieee. """ - @deprecation.deprecated_args( - deprecation.REMOVAL_DATE['0.19.0'], - 'Use argument `image_dims` instead.', - ('rank', None)) def __init__(self, max_val=None, filter_size=11, @@ -310,7 +291,6 @@ def __init__(self, k2=0.03, batch_dims=None, image_dims=None, - rank=None, multichannel=True, complex_part=None, name='ms_ssim', @@ -326,7 +306,6 @@ def __init__(self, k2=k2, batch_dims=batch_dims, image_dims=image_dims, - rank=rank, multichannel=multichannel, complex_part=complex_part) diff --git a/tensorflow_mri/python/ops/image_ops.py b/tensorflow_mri/python/ops/image_ops.py index 24898062..5c41851f 100644 --- a/tensorflow_mri/python/ops/image_ops.py +++ b/tensorflow_mri/python/ops/image_ops.py @@ -35,16 +35,11 @@ @api_util.export("image.psnr") -@deprecation.deprecated_args( - deprecation.REMOVAL_DATE['0.19.0'], - 'Use argument `image_dims` instead.', - ('rank', None)) def psnr(img1, img2, max_val=None, batch_dims=None, image_dims=None, - rank=None, name='psnr'): """Computes the peak signal-to-noise ratio (PSNR) between two N-D images. @@ -76,11 +71,6 @@ def psnr(img1, `(rank of inputs) - batch_dims - 1`. Defaults to `None`. `image_dims` can always be inferred if `batch_dims` was specified, so you only need to provide one of the two. - rank: An `int`. The number of spatial dimensions. Must be 2 or 3. Defaults - to `tf.rank(img1) - 2`. In other words, if rank is not explicitly set, - `img1` and `img2` should have shape `[batch, height, width, channels]` - if processing 2D images or `[batch, depth, height, width, channels]` if - processing 3D images. name: Namespace to embed the computation in. Returns: @@ -88,9 +78,6 @@ def psnr(img1, `tf.float32` and shape `batch_shape`. """ with tf.name_scope(name): - image_dims = deprecation.deprecated_argument_lookup( - 'image_dims', image_dims, 'rank', rank) - img1 = tf.convert_to_tensor(img1) img2 = tf.convert_to_tensor(img2) # Default `max_val` to maximum dynamic range for the input dtype. @@ -175,10 +162,6 @@ def psnr3d(img1, img2, max_val, name='psnr3d'): @api_util.export("image.ssim") -@deprecation.deprecated_args( - deprecation.REMOVAL_DATE['0.19.0'], - 'Use argument `image_dims` instead.', - ('rank', None)) def ssim(img1, img2, max_val=None, @@ -188,7 +171,6 @@ def ssim(img1, k2=0.03, batch_dims=None, image_dims=None, - rank=None, name='ssim'): """Computes the structural similarity index (SSIM) between two N-D images. @@ -229,11 +211,6 @@ def ssim(img1, `(rank of inputs) - batch_dims - 1`. Defaults to `None`. `image_dims` can always be inferred if `batch_dims` was specified, so you only need to provide one of the two. - rank: An `int`. The number of spatial dimensions. Must be 2 or 3. Defaults - to `tf.rank(img1) - 2`. In other words, if rank is not explicitly set, - `img1` and `img2` should have shape `[batch, height, width, channels]` - if processing 2D images or `[batch, depth, height, width, channels]` if - processing 3D images. name: Namespace to embed the computation in. Returns: @@ -247,9 +224,6 @@ def ssim(img1, 2004, doi: 10.1109/TIP.2003.819861. """ with tf.name_scope(name): - image_dims = deprecation.deprecated_argument_lookup( - 'image_dims', image_dims, 'rank', rank) - img1 = tf.convert_to_tensor(img1) img2 = tf.convert_to_tensor(img2) # Default `max_val` to maximum dynamic range for the input dtype. @@ -397,10 +371,6 @@ def ssim3d(img1, @api_util.export("image.ssim_multiscale") -@deprecation.deprecated_args( - deprecation.REMOVAL_DATE['0.19.0'], - 'Use argument `image_dims` instead.', - ('rank', None)) def ssim_multiscale(img1, img2, max_val=None, @@ -411,7 +381,6 @@ def ssim_multiscale(img1, k2=0.03, batch_dims=None, image_dims=None, - rank=None, name='ssim_multiscale'): """Computes the multiscale SSIM (MS-SSIM) between two N-D images. @@ -459,11 +428,6 @@ def ssim_multiscale(img1, `(rank of inputs) - batch_dims - 1`. Defaults to `None`. `image_dims` can always be inferred if `batch_dims` was specified, so you only need to provide one of the two. - rank: An `int`. The number of spatial dimensions. Must be 2 or 3. Defaults - to `tf.rank(img1) - 2`. In other words, if rank is not explicitly set, - `img1` and `img2` should have shape `[batch, height, width, channels]` - if processing 2D images or `[batch, depth, height, width, channels]` if - processing 3D images. name: Namespace to embed the computation in. Returns: @@ -477,9 +441,6 @@ def ssim_multiscale(img1, Vol.2, doi: 10.1109/ACSSC.2003.1292216. """ with tf.name_scope(name): - image_dims = deprecation.deprecated_argument_lookup( - 'image_dims', image_dims, 'rank', rank) - # Convert to tensor if needed. img1 = tf.convert_to_tensor(img1, name='img1') img2 = tf.convert_to_tensor(img2, name='img2') @@ -938,7 +899,7 @@ def image_gradients(image, method='sobel', norm=False, image, batch_dims, image_dims) kernels = _gradient_operators( - method, norm=norm, rank=image_dims, dtype=image.dtype.real_dtype) + method, norm=norm, image_dims=image_dims, dtype=image.dtype.real_dtype) return _filter_image(image, kernels) @@ -981,7 +942,7 @@ def gradient_magnitude(image, method='sobel', norm=False, return tf.norm(gradients, axis=-1) -def _gradient_operators(method, norm=False, rank=2, dtype=tf.float32): +def _gradient_operators(method, norm=False, image_dims=2, dtype=tf.float32): """Returns a set of operators to compute image gradients. Args: @@ -993,7 +954,7 @@ def _gradient_operators(method, norm=False, rank=2, dtype=tf.float32): Returns: A `Tensor` of shape `[num_kernels] + kernel_shape`, where `kernel_shape` is - `[3] * rank`. + `[3] * image_dims`. Raises: ValueError: If passed an invalid `method`. @@ -1012,15 +973,15 @@ def _gradient_operators(method, norm=False, rank=2, dtype=tf.float32): if norm: avg_operator /= tf.math.reduce_sum(tf.math.abs(avg_operator)) diff_operator /= tf.math.reduce_sum(tf.math.abs(diff_operator)) - kernels = [None] * rank - for d in range(rank): - kernels[d] = tf.ones([3] * rank, dtype=tf.float32) - for i in range(rank): + kernels = [None] * image_dims + for d in range(image_dims): + kernels[d] = tf.ones([3] * image_dims, dtype=tf.float32) + for i in range(image_dims): if i == d: operator_1d = diff_operator else: operator_1d = avg_operator - operator_shape = [1] * rank + operator_shape = [1] * image_dims operator_shape[i] = operator_1d.shape[0] operator_1d = tf.reshape(operator_1d, operator_shape) kernels[d] *= operator_1d @@ -1103,16 +1064,11 @@ def _filter_image(image, kernels): @api_util.export("image.gmsd") -@deprecation.deprecated_args( - deprecation.REMOVAL_DATE['0.19.0'], - 'Use argument `image_dims` instead.', - ('rank', None)) def gmsd(img1, img2, max_val=1.0, batch_dims=None, image_dims=None, - rank=None, name=None): """Computes the gradient magnitude similarity deviation (GMSD). @@ -1141,11 +1097,6 @@ def gmsd(img1, `image.shape.rank - batch_dims - 1`. Defaults to `None`. `image_dims` can always be inferred if `batch_dims` was specified, so you only need to provide one of the two. - rank: An `int`. The number of spatial dimensions. Must be 2 or 3. Defaults - to `tf.rank(img1) - 2`. In other words, if rank is not explicitly set, - `img1` and `img2` should have shape `[batch, height, width, channels]` - if processing 2D images or `[batch, depth, height, width, channels]` if - processing 3D images. name: Namespace to embed the computation in. Returns: @@ -1160,8 +1111,6 @@ def gmsd(img1, """ with tf.name_scope(name or 'gmsd'): # Check and prepare inputs. - image_dims = deprecation.deprecated_argument_lookup( - 'image_dims', image_dims, 'rank', rank) iqa_inputs = _validate_iqa_inputs( img1, img2, max_val, batch_dims, image_dims) img1, img2 = iqa_inputs.img1, iqa_inputs.img2 @@ -1231,7 +1180,7 @@ def gmsd2d(img1, img2, max_val=1.0, name=None): in IEEE Transactions on Image Processing, vol. 23, no. 2, pp. 684-695, Feb. 2014, doi: 10.1109/TIP.2013.2293423. """ - return gmsd(img1, img2, max_val=max_val, rank=2, name=(name or 'gmsd2d')) + return gmsd(img1, img2, max_val=max_val, image_dims=2, name=(name or 'gmsd2d')) @api_util.export("image.gmsd3d") @@ -1261,7 +1210,7 @@ def gmsd3d(img1, img2, max_val=1.0, name=None): in IEEE Transactions on Image Processing, vol. 23, no. 2, pp. 684-695, Feb. 2014, doi: 10.1109/TIP.2013.2293423. """ - return gmsd(img1, img2, max_val=max_val, rank=3, name=(name or 'gmsd3d')) + return gmsd(img1, img2, max_val=max_val, image_dims=3, name=(name or 'gmsd3d')) def _validate_iqa_inputs(img1, img2, max_val, batch_dims, image_dims): diff --git a/tensorflow_mri/python/ops/recon_ops.py b/tensorflow_mri/python/ops/recon_ops.py index b393eab1..7c7fcdb5 100644 --- a/tensorflow_mri/python/ops/recon_ops.py +++ b/tensorflow_mri/python/ops/recon_ops.py @@ -834,15 +834,10 @@ def _flatten_last_dimensions(x): @api_util.export("recon.partial_fourier", "recon.pf") -@deprecation.deprecated_args( - deprecation.REMOVAL_DATE['0.19.0'], - 'Use argument `preserve_phase` instead.', - ('return_complex', None)) def reconstruct_pf(kspace, factors, preserve_phase=None, return_kspace=False, - return_complex=None, method='zerofill', **kwargs): """Reconstructs an MR image using partial Fourier methods. @@ -863,8 +858,6 @@ def reconstruct_pf(kspace, be complex-valued. return_kspace: A `boolean`. If `True`, returns the filled *k*-space instead of the reconstructed images. This is always complex-valued. - return_complex: A `boolean`. If `True`, returns complex instead of - real-valued images. method: A `string`. The partial Fourier reconstruction algorithm. Must be one of `"zerofill"`, `"homodyne"` (homodyne detection method) or `"pocs"` (projection onto convex sets method). @@ -911,8 +904,6 @@ def reconstruct_pf(kspace, f"`factors` must be greater than or equal to 0.5, but got: {factors}")) tf.debugging.assert_less_equal(factors, 1.0, message=( f"`factors` must be less than or equal to 1.0, but got: {factors}")) - preserve_phase = deprecation.deprecated_argument_lookup( - 'preserve_phase', preserve_phase, 'return_complex', return_complex) if preserve_phase is None: preserve_phase = False diff --git a/tensorflow_mri/python/util/deprecation.py b/tensorflow_mri/python/util/deprecation.py index b8ba3101..7003bb12 100755 --- a/tensorflow_mri/python/util/deprecation.py +++ b/tensorflow_mri/python/util/deprecation.py @@ -19,7 +19,6 @@ # The following dictionary contains the removal date for deprecations # at a given release. REMOVAL_DATE = { - '0.19.0': '2022-09-01', '0.20.0': '2022-10-01' } From 7f6b538d29999fc8454212ec672ed6f8442a6577 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Tue, 30 Aug 2022 13:03:33 +0000 Subject: [PATCH 058/101] Add FFTW planning rigor envvar --- .devcontainer/devcontainer.json | 2 +- tensorflow_mri/cc/kernels/fft_kernels.cc | 36 ++++++++++++++++++++---- 2 files changed, 31 insertions(+), 7 deletions(-) diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index 4558c0a4..f813b572 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -14,7 +14,7 @@ ], // Enable plotting. "mounts": [ - "type=bind,source=/tmp/.X11-unix,target=/tmp/.X11-unix", + "type=bind,source=/tmp/.X11-unix,target=/tmp/.X11-unix" ], // Enable plotting. "containerEnv": { diff --git a/tensorflow_mri/cc/kernels/fft_kernels.cc b/tensorflow_mri/cc/kernels/fft_kernels.cc index 05c89afd..dba99be7 100644 --- a/tensorflow_mri/cc/kernels/fft_kernels.cc +++ b/tensorflow_mri/cc/kernels/fft_kernels.cc @@ -155,6 +155,8 @@ class FFTCPU : public FFTBase { using FFTBase::FFTBase; protected: + static unsigned FftwPlanningRigor; + int Rank() const override { return FFTRank; } bool IsForward() const override { return Forward; } bool IsReal() const override { return _Real; } @@ -185,7 +187,7 @@ class FFTCPU : public FFTBase { const Tensor& in, Tensor* out) { auto device = ctx->eigen_device(); auto worker_threads = ctx->device()->tensorflow_cpu_worker_threads(); - auto num_threads = worker_threads->num_threads; + auto num_threads = worker_threads->num_threads; const bool is_complex128 = in.dtype() == DT_COMPLEX128 || out->dtype() == DT_COMPLEX128; @@ -214,7 +216,7 @@ class FFTCPU : public FFTBase { int batch_size = input.dimension(0); constexpr auto fft_sign = Forward ? FFTW_FORWARD : FFTW_BACKWARD; - constexpr auto fft_flags = FFTW_ESTIMATE; + auto fft_flags = FftwPlanningRigor; #pragma omp critical { @@ -267,12 +269,34 @@ class FFTCPU : public FFTBase { output.device(device) = output / output.constant(num_points); } } - - private: - // Used to control access to FFTW planner. - mutex mu_; }; +unsigned GetFftwPlanningRigor(const string& envvar, + const string& default_value) { + const char* str = getenv(envvar.c_str()); + if (str == nullptr || strcmp(str, "") == 0) { + // envvar is not set, use default value. + str = default_value.c_str(); + } + + if (strcmp(str, "estimate") == 0) { + return FFTW_ESTIMATE; + } else if (strcmp(str, "measure") == 0) { + return FFTW_MEASURE; + } else if (strcmp(str, "patient") == 0) { + return FFTW_PATIENT; + } else if (strcmp(str, "exhaustive") == 0) { + return FFTW_EXHAUSTIVE; + } else { + LOG(FATAL) << "Invalid value for environment variable " << envvar << ": " << str; + } +} + +template +unsigned FFTCPU::FftwPlanningRigor = GetFftwPlanningRigor( + "TFMRI_FFTW_PLANNING_RIGOR", "measure" +); + // Environment variable `TFMRI_USE_CUSTOM_FFT` can be used to specify whether to // use custom FFT kernels. static bool InitModule() { From 736cd165bde5ff6f9993cc764c4b992a5a714a6b Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Tue, 30 Aug 2022 13:07:13 +0000 Subject: [PATCH 059/101] Updated copyright notice for FFT kernels --- tensorflow_mri/cc/kernels/fft_kernels.cc | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/tensorflow_mri/cc/kernels/fft_kernels.cc b/tensorflow_mri/cc/kernels/fft_kernels.cc index dba99be7..fa1b9cf3 100644 --- a/tensorflow_mri/cc/kernels/fft_kernels.cc +++ b/tensorflow_mri/cc/kernels/fft_kernels.cc @@ -1,3 +1,18 @@ +/* Copyright 2022 The TensorFlow MRI 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. +==============================================================================*/ + /* Copyright 2015 The TensorFlow Authors. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); @@ -12,6 +27,9 @@ 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. ==============================================================================*/ +// This file is inspired by "tensorflow/tensorflow/core/kernels/fft_ops.cc", +// but CPU kernels have been modified to use the FFTW library. The original +// GPU kernels have been removed. #include "tensorflow/core/platform/errors.h" #define EIGEN_USE_THREADS From 73da9b599b714be6db319a46a34a621f0094e94d Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Tue, 30 Aug 2022 15:25:48 +0000 Subject: [PATCH 060/101] Refactored coils module --- RELEASE.md | 20 +- tensorflow_mri/__init__.py | 1 - tensorflow_mri/_api/coils/__init__.py | 8 - tensorflow_mri/python/coils/__init__.py | 1 + .../coil_ops.py => coils/coil_combination.py} | 58 ++-- .../python/coils/coil_combination_test.py | 77 ++++ .../python/coils/coil_compression.py | 116 +++---- .../python/coils/coil_compression_test.py | 115 +++++- .../python/coils/coil_sensitivities.py | 328 ++++++++++-------- .../python/coils/coil_sensitivities_test.py | 269 +++++++------- .../python/models/variational_network.py | 2 +- tensorflow_mri/python/ops/coil_ops_test.py | 258 -------------- tensorflow_mri/python/ops/recon_ops.py | 8 +- tools/docs/guide/conventions.ipynb | 30 ++ 14 files changed, 626 insertions(+), 665 deletions(-) rename tensorflow_mri/python/{ops/coil_ops.py => coils/coil_combination.py} (55%) mode change 100755 => 100644 create mode 100644 tensorflow_mri/python/coils/coil_combination_test.py delete mode 100755 tensorflow_mri/python/ops/coil_ops_test.py create mode 100644 tools/docs/guide/conventions.ipynb diff --git a/RELEASE.md b/RELEASE.md index 0d263bd8..003981af 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -8,9 +8,27 @@ ## Major Features and Improvements +- `tf`: + + - Added custom FFT kernels for CPU. These can be used directly through the + standard core TF APIs `tf.signal.fft`, `tf.signal.fft2d` and + `tf.signal.fft3d`. + +- `tfmri.activations`: + + - Added new functions `complex_relu` and `mod_relu`. + +- `tfmri.callbacks`: + + - The `TensorBoardImages` callback can now create multiple summaries. + +- `tfmri.coils`: + + - Added new function `estimate_sensitivities_from_kspace`. + - `tfmri.geometry`: - - Added new extension types `Rotation2D` and `Rotation3D`. + - Added new extension type `Rotation2D`. - `tfmri.layers`: diff --git a/tensorflow_mri/__init__.py b/tensorflow_mri/__init__.py index 57851ed0..339a57ca 100644 --- a/tensorflow_mri/__init__.py +++ b/tensorflow_mri/__init__.py @@ -9,7 +9,6 @@ # TODO(jmontalt): Remove these imports on release 1.0.0. from tensorflow_mri.python.ops.array_ops import * -from tensorflow_mri.python.ops.coil_ops import * from tensorflow_mri.python.ops.convex_ops import * from tensorflow_mri.python.ops.fft_ops import * from tensorflow_mri.python.ops.image_ops import * diff --git a/tensorflow_mri/_api/coils/__init__.py b/tensorflow_mri/_api/coils/__init__.py index 28b90a4b..65220783 100644 --- a/tensorflow_mri/_api/coils/__init__.py +++ b/tensorflow_mri/_api/coils/__init__.py @@ -1,11 +1,3 @@ # This file was automatically generated by tools/build/create_api.py. # Do not edit. """Parallel imaging operations.""" - -from tensorflow_mri.python.coils.coil_compression import compress_coils_with_calibration_data as compress_coils_with_calibration_data -from tensorflow_mri.python.coils.coil_compression import compress_coils as compress_coils -from tensorflow_mri.python.coils.coil_compression import CoilCompressorSVD as CoilCompressorSVD -from tensorflow_mri.python.coils.coil_compression import get_coil_compressor as get_coil_compressor -from tensorflow_mri.python.coils.coil_sensitivities import estimate_sensitivities_with_calibration_data as estimate_sensitivities_with_calibration_data -from tensorflow_mri.python.coils.coil_sensitivities import estimate_coil_sensitivities as estimate_sensitivities -from tensorflow_mri.python.ops.coil_ops import combine_coils as combine_coils diff --git a/tensorflow_mri/python/coils/__init__.py b/tensorflow_mri/python/coils/__init__.py index 08c989db..c4c17921 100644 --- a/tensorflow_mri/python/coils/__init__.py +++ b/tensorflow_mri/python/coils/__init__.py @@ -14,5 +14,6 @@ # ============================================================================== """Operators for coil arrays.""" +from tensorflow_mri.python.coils import coil_combination from tensorflow_mri.python.coils import coil_compression from tensorflow_mri.python.coils import coil_sensitivities diff --git a/tensorflow_mri/python/ops/coil_ops.py b/tensorflow_mri/python/coils/coil_combination.py old mode 100755 new mode 100644 similarity index 55% rename from tensorflow_mri/python/ops/coil_ops.py rename to tensorflow_mri/python/coils/coil_combination.py index 617abec7..773b85cf --- a/tensorflow_mri/python/ops/coil_ops.py +++ b/tensorflow_mri/python/coils/coil_combination.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. @@ -12,67 +12,57 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== -"""Coil array operations. -This module contains functions to operate with MR coil arrays, such as -estimating coil sensitivities and combining multi-coil images. -""" - -import abc -import collections -import functools - -import numpy as np import tensorflow as tf -import tensorflow.experimental.numpy as tnp -from tensorflow_mri.python.ops import array_ops -from tensorflow_mri.python.ops import fft_ops from tensorflow_mri.python.util import api_util -from tensorflow_mri.python.util import check_util @api_util.export("coils.combine_coils") -def combine_coils(images, maps=None, coil_axis=-1, keepdims=False): - """Sum of squares or adaptive coil combination. +def combine_coils(images, maps=None, coil_axis=-1, keepdims=False, name=None): + """Combines a multicoil image into a single-coil image. + + Supports sum of squares (when `maps` is `None`) and adaptive combination. Args: images: A `Tensor`. The input images. - maps: A `Tensor`. The coil sensitivity maps. This argument is optional. + maps: A `Tensor`. The Wcoil sensitivity maps. This argument is optional. If `maps` is provided, it must have the same shape and type as `images`. In this case an adaptive coil combination is performed using the specified maps. If `maps` is `None`, a simple estimate of `maps` is used (ie, images are combined using the sum of squares method). coil_axis: An `int`. The coil axis. Defaults to -1. keepdims: A `boolean`. If `True`, retains the coil dimension with size 1. + name: A name for the operation. Defaults to "combine_coils". Returns: A `Tensor`. The combined images. References: - .. [1] Roemer, P.B., Edelstein, W.A., Hayes, C.E., Souza, S.P. and + 1. Roemer, P.B., Edelstein, W.A., Hayes, C.E., Souza, S.P. and Mueller, O.M. (1990), The NMR phased array. Magn Reson Med, 16: 192-225. https://doi.org/10.1002/mrm.1910160203 - .. [2] Bydder, M., Larkman, D. and Hajnal, J. (2002), Combination of signals + 2. Bydder, M., Larkman, D. and Hajnal, J. (2002), Combination of signals from array coils using image-based estimation of coil sensitivity profiles. Magn. Reson. Med., 47: 539-548. https://doi.org/10.1002/mrm.10092 """ - images = tf.convert_to_tensor(images) - if maps is not None: - maps = tf.convert_to_tensor(maps) + with tf.name_scope(name or "combine_coils"): + images = tf.convert_to_tensor(images) + if maps is not None: + maps = tf.convert_to_tensor(maps) - if maps is None: - combined = tf.math.sqrt( - tf.math.reduce_sum(images * tf.math.conj(images), - axis=coil_axis, keepdims=keepdims)) + if maps is None: + combined = tf.math.sqrt( + tf.math.reduce_sum(images * tf.math.conj(images), + axis=coil_axis, keepdims=keepdims)) - else: - combined = tf.math.divide_no_nan( - tf.math.reduce_sum(images * tf.math.conj(maps), - axis=coil_axis, keepdims=keepdims), - tf.math.reduce_sum(maps * tf.math.conj(maps), - axis=coil_axis, keepdims=keepdims)) + else: + combined = tf.math.divide_no_nan( + tf.math.reduce_sum(images * tf.math.conj(maps), + axis=coil_axis, keepdims=keepdims), + tf.math.reduce_sum(maps * tf.math.conj(maps), + axis=coil_axis, keepdims=keepdims)) - return combined + return combined diff --git a/tensorflow_mri/python/coils/coil_combination_test.py b/tensorflow_mri/python/coils/coil_combination_test.py new file mode 100644 index 00000000..315519a2 --- /dev/null +++ b/tensorflow_mri/python/coils/coil_combination_test.py @@ -0,0 +1,77 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== + +from absl.testing import parameterized +import tensorflow as tf + +from tensorflow_mri.python.coils import coil_combination +from tensorflow_mri.python.util import test_util + + +class CoilCombineTest(test_util.TestCase): + """Tests for coil combination op.""" + + @parameterized.product(coil_axis=[0, -1], + keepdims=[True, False]) + @test_util.run_in_graph_and_eager_modes + def test_sos(self, coil_axis, keepdims): # pylint: disable=missing-param-doc + """Test sum of squares combination.""" + + images = self._random_complex((20, 20, 8)) + + combined = coil_combination.combine_coils( + images, coil_axis=coil_axis, keepdims=keepdims) + + ref = tf.math.sqrt( + tf.math.reduce_sum(images * tf.math.conj(images), + axis=coil_axis, keepdims=keepdims)) + + self.assertAllEqual(combined.shape, ref.shape) + self.assertAllClose(combined, ref) + + + @parameterized.product(coil_axis=[0, -1], + keepdims=[True, False]) + @test_util.run_in_graph_and_eager_modes + def test_adaptive(self, coil_axis, keepdims): # pylint: disable=missing-param-doc + """Test adaptive combination.""" + + images = self._random_complex((20, 20, 8)) + maps = self._random_complex((20, 20, 8)) + + combined = coil_combination.combine_coils( + images, maps=maps, coil_axis=coil_axis, keepdims=keepdims) + + ref = tf.math.reduce_sum(images * tf.math.conj(maps), + axis=coil_axis, keepdims=keepdims) + + ref /= tf.math.reduce_sum(maps * tf.math.conj(maps), + axis=coil_axis, keepdims=keepdims) + + self.assertAllEqual(combined.shape, ref.shape) + self.assertAllClose(combined, ref) + + def setUp(self): + super().setUp() + tf.random.set_seed(0) + + def _random_complex(self, shape): + return tf.dtypes.complex( + tf.random.normal(shape), + tf.random.normal(shape)) + + +if __name__ == '__main__': + tf.test.main() diff --git a/tensorflow_mri/python/coils/coil_compression.py b/tensorflow_mri/python/coils/coil_compression.py index 2ee08716..a35f863d 100644 --- a/tensorflow_mri/python/coils/coil_compression.py +++ b/tensorflow_mri/python/coils/coil_compression.py @@ -16,66 +16,12 @@ import abc -import numpy as np import tensorflow as tf -from tensorflow_mri.python.ops import signal_ops from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util -@api_util.export("coils.compress_coils_with_calibration_data") -def compress_coils_with_calibration_data( - kspace, - operator, - calib_data=None, - calib_window=None, - method='svd', - **kwargs): - # For convenience. - rank = operator.rank - - if calib_data is None: - # Calibration data was not provided. Get calibration data by low-pass - # filtering the input k-space. - calib_data = signal_ops.filter_kspace( - kspace, - trajectory=operator.trajectory, - filter_fn=calib_window, - filter_rank=rank, - separable=True) - - # Reshape to single batch dimension. - coil_axis = -2 if operator.is_non_cartesian else -(rank + 1) - batch_shape_static = calib_data.shape[:coil_axis] - batch_shape = tf.shape(calib_data)[:coil_axis] - calib_shape = tf.shape(calib_data)[coil_axis:] - calib_data = tf.reshape(calib_data, tf.concat([[-1], calib_shape], 0)) - kspace_shape = tf.shape(kspace)[coil_axis:] - kspace = tf.reshape(kspace, tf.concat([[-1], kspace_shape], 0)) - - # Apply compression for each element in batch. - def compress_coils_fn(inputs): - ksp, cal = inputs - return get_coil_compressor(method, - coil_axis=coil_axis, - **kwargs).fit(cal).transform(ksp) - output_shape = [kwargs.get('out_coils')] + kspace.shape[2:].as_list() - fn_output_signature = tf.TensorSpec(shape=output_shape, dtype=kspace.dtype) - kspace = tf.map_fn(compress_coils_fn, (kspace, calib_data), - fn_output_signature=fn_output_signature) - - # Restore batch shape. - output_shape = tf.shape(kspace)[1:] - output_shape_static = kspace.shape[1:] - kspace = tf.reshape(kspace, - tf.concat([batch_shape, output_shape], 0)) - kspace = tf.ensure_shape( - kspace, batch_shape_static.concatenate(output_shape_static)) - - return kspace - - @api_util.export("coils.compress_coils") def compress_coils(kspace, coil_axis=-1, @@ -132,10 +78,10 @@ def compress_coils(kspace, compression for cartesian sampling. In Proceedings of the 21st Annual Meeting of ISMRM, Salt Lake City, Utah, USA (Vol. 47). """ - return get_coil_compressor(method, - coil_axis=coil_axis, - out_coils=out_coils, - **kwargs).fit_transform(kspace) + return make_coil_compressor(method, + coil_axis=coil_axis, + out_coils=out_coils, + **kwargs).fit_transform(kspace) class CoilCompressor(): @@ -315,8 +261,7 @@ def explained_variance_ratio(self): return self._explained_variance_ratio -@api_util.export("coils.get_coil_compressor") -def get_coil_compressor(method, **kwargs): +def make_coil_compressor(method, **kwargs): """Creates a coil compressor based on the specified method. Args: @@ -332,3 +277,54 @@ def get_coil_compressor(method, **kwargs): if method == 'svd': return CoilCompressorSVD(**kwargs) raise NotImplementedError(f"Method {method} not implemented.") + + +# def compress_coils_with_calibration_data( +# kspace, +# operator, +# calib_data=None, +# calib_window=None, +# method='svd', +# **kwargs): +# # For convenience. +# rank = operator.rank + +# if calib_data is None: +# # Calibration data was not provided. Get calibration data by low-pass +# # filtering the input k-space. +# calib_data = signal_ops.filter_kspace( +# kspace, +# trajectory=operator.trajectory, +# filter_fn=calib_window, +# filter_rank=rank, +# separable=True) + +# # Reshape to single batch dimension. +# coil_axis = -2 if operator.is_non_cartesian else -(rank + 1) +# batch_shape_static = calib_data.shape[:coil_axis] +# batch_shape = tf.shape(calib_data)[:coil_axis] +# calib_shape = tf.shape(calib_data)[coil_axis:] +# calib_data = tf.reshape(calib_data, tf.concat([[-1], calib_shape], 0)) +# kspace_shape = tf.shape(kspace)[coil_axis:] +# kspace = tf.reshape(kspace, tf.concat([[-1], kspace_shape], 0)) + +# # Apply compression for each element in batch. +# def compress_coils_fn(inputs): +# ksp, cal = inputs +# return get_coil_compressor(method, +# coil_axis=coil_axis, +# **kwargs).fit(cal).transform(ksp) +# output_shape = [kwargs.get('out_coils')] + kspace.shape[2:].as_list() +# fn_output_signature = tf.TensorSpec(shape=output_shape, dtype=kspace.dtype) +# kspace = tf.map_fn(compress_coils_fn, (kspace, calib_data), +# fn_output_signature=fn_output_signature) + +# # Restore batch shape. +# output_shape = tf.shape(kspace)[1:] +# output_shape_static = kspace.shape[1:] +# kspace = tf.reshape(kspace, +# tf.concat([batch_shape, output_shape], 0)) +# kspace = tf.ensure_shape( +# kspace, batch_shape_static.concatenate(output_shape_static)) + +# return kspace diff --git a/tensorflow_mri/python/coils/coil_compression_test.py b/tensorflow_mri/python/coils/coil_compression_test.py index 7a89a420..972bc721 100644 --- a/tensorflow_mri/python/coils/coil_compression_test.py +++ b/tensorflow_mri/python/coils/coil_compression_test.py @@ -1,4 +1,4 @@ -# Copyright 2022 The TensorFlow MRI Authors. All Rights Reserved. +# Copyright 2021 University College London. 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. @@ -12,4 +12,115 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== -"""Tests for coil compression.""" +"""Tests for module `coil_compression`.""" + +import itertools + +import tensorflow as tf + +from tensorflow_mri.python.coils import coil_compression +from tensorflow_mri.python.util import io_util +from tensorflow_mri.python.util import test_util + + +class CoilCompressionTest(test_util.TestCase): + """Tests for coil compression op.""" + + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.data = io_util.read_hdf5('tests/data/coil_ops_data.h5') + + @test_util.run_in_graph_and_eager_modes + def test_coil_compression_svd(self): + """Test SVD coil compression.""" + kspace = self.data['cc/kspace'] + result = self.data['cc/result/svd'] + + cc_kspace = coil_compression.compress_coils(kspace) + + self.assertAllClose(cc_kspace, result, rtol=1e-2, atol=1e-2) + + @test_util.run_in_graph_and_eager_modes + def test_coil_compression_svd_two_step(self): + """Test SVD coil compression using two-step API.""" + kspace = self.data['cc/kspace'] + result = self.data['cc/result/svd'] + + compressor = coil_compression.CoilCompressorSVD(out_coils=16) + compressor = compressor.fit(kspace) + cc_kspace = compressor.transform(kspace) + self.assertAllClose(cc_kspace, result[..., :16], rtol=1e-2, atol=1e-2) + + @test_util.run_in_graph_and_eager_modes + def test_coil_compression_svd_transposed(self): + """Test SVD coil compression using two-step API.""" + kspace = self.data['cc/kspace'] + result = self.data['cc/result/svd'] + + kspace = tf.transpose(kspace, [2, 0, 1]) + cc_kspace = coil_compression.compress_coils(kspace, coil_axis=0) + cc_kspace = tf.transpose(cc_kspace, [1, 2, 0]) + + self.assertAllClose(cc_kspace, result, rtol=1e-2, atol=1e-2) + + @test_util.run_in_graph_and_eager_modes + def test_coil_compression_svd_basic(self): + """Test coil compression using SVD method with basic arrays.""" + shape = (20, 20, 8) + data = tf.dtypes.complex( + tf.random.stateless_normal(shape, [32, 43]), + tf.random.stateless_normal(shape, [321, 321])) + + params = { + 'out_coils': [None, 4], + 'variance_ratio': [None, 0.75]} + + values = itertools.product(*params.values()) + params = [dict(zip(params.keys(), v)) for v in values] + + for p in params: + with self.subTest(**p): + if p['out_coils'] is not None and p['variance_ratio'] is not None: + with self.assertRaisesRegex( + ValueError, + "Cannot specify both `out_coils` and `variance_ratio`"): + coil_compression.compress_coils(data, **p) + continue + + # Test op. + compressed_data = coil_compression.compress_coils(data, **p) + + # Flatten input data. + encoding_dims = tf.shape(data)[:-1] + input_coils = tf.shape(data)[-1] + data = tf.reshape(data, (-1, tf.shape(data)[-1])) + samples = tf.shape(data)[0] + + # Calculate compression matrix. + # This should be equivalent to TF line below. Not sure why + # not. Giving up. + # u, s, vh = np.linalg.svd(data, full_matrices=False) + # v = vh.T.conj() + s, u, v = tf.linalg.svd(data, full_matrices=False) + matrix = tf.cond(samples > input_coils, lambda v=v: v, lambda u=u: u) + + out_coils = input_coils + if p['variance_ratio'] and not p['out_coils']: + variance = s ** 2 / 399.0 + out_coils = tf.math.count_nonzero( + tf.math.cumsum(variance / tf.math.reduce_sum(variance), axis=0) <= + p['variance_ratio']) + if p['out_coils']: + out_coils = p['out_coils'] + matrix = matrix[:, :out_coils] + + ref_data = tf.matmul(data, matrix) + ref_data = tf.reshape( + ref_data, tf.concat([encoding_dims, [out_coils]], 0)) + + self.assertAllClose(compressed_data, ref_data) + + +if __name__ == '__main__': + tf.test.main() diff --git a/tensorflow_mri/python/coils/coil_sensitivities.py b/tensorflow_mri/python/coils/coil_sensitivities.py index bd7b887e..5798743e 100644 --- a/tensorflow_mri/python/coils/coil_sensitivities.py +++ b/tensorflow_mri/python/coils/coil_sensitivities.py @@ -14,85 +14,23 @@ # ============================================================================== """Coil sensitivity estimation.""" +import collections import functools import numpy as np import tensorflow as tf +import tensorflow.experimental.numpy as tnp from tensorflow_mri.python.ops import array_ops from tensorflow_mri.python.ops import fft_ops -from tensorflow_mri.python.ops import signal_ops from tensorflow_mri.python.recon import recon_adjoint from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util -@api_util.export("coils.estimate_sensitivities_with_calibration_data") -def estimate_sensitivities_with_calibration_data( - kspace, - operator, - calib_data=None, - calib_window=None, - method='walsh', - **kwargs): - method = 'lowpass' - - # For convenience. - rank = operator.rank - - if calib_data is None: - # Calibration data was not provided. Get calibration data by low-pass - # filtering the input k-space. - calib_data = signal_ops.filter_kspace( - kspace, - trajectory=operator.trajectory, - filter_fn=calib_window, - filter_rank=rank, - separable=True) - - # Reconstruct image. - calib_data = recon_adjoint.recon_adjoint(calib_data, operator) - - if method == 'lowpass': - return calib_data - - # ESPIRiT method takes in k-space data, so convert back to k-space in this - # case. - if method == 'espirit': - axes = list(range(-rank, 0)) - calib_data = fft_ops.fftn(calib_data, axes=axes, norm='ortho', shift=True) - - # Reshape to single batch dimension. - batch_shape_static = calib_data.shape[:-(rank + 1)] - batch_shape = tf.shape(calib_data)[:-(rank + 1)] - calib_shape = tf.shape(calib_data)[-(rank + 1):] - calib_data = tf.reshape(calib_data, tf.concat([[-1], calib_shape], 0)) - - # Apply estimation for each element in batch. - sensitivities = tf.map_fn( - functools.partial(estimate_coil_sensitivities, - coil_axis=-(rank + 1), - method=method, - **kwargs), - calib_data) - - # Restore batch shape. - output_shape = tf.shape(sensitivities)[1:] - output_shape_static = sensitivities.shape[1:] - sensitivities = tf.reshape(sensitivities, - tf.concat([batch_shape, output_shape], 0)) - sensitivities = tf.ensure_shape( - sensitivities, batch_shape_static.concatenate(output_shape_static)) - - return sensitivities - - @api_util.export("coils.estimate_sensitivities") -def estimate_coil_sensitivities(input_, - coil_axis=-1, - method='walsh', - **kwargs): - """Estimate coil sensitivity maps. +def estimate(input_, coil_axis=-1, method='walsh', **kwargs): + """Estimates coil sensitivity maps. This method supports 2D and 3D inputs. @@ -118,91 +56,89 @@ def estimate_coil_sensitivities(input_, This function accepts the following method-specific keyword arguments: - * For `method="walsh"`: + - For `method="walsh"`: - * **filter_size**: An `int`. The size of the smoothing filter. + - **filter_size**: An `int`. The size of the smoothing filter. - * For `method="inati"`: + - For `method="inati"`: - * **filter_size**: An `int`. The size of the smoothing filter. - * **max_iter**: An `int`. The maximum number of iterations. - * **tol**: A `float`. The convergence tolerance. + - **filter_size**: An `int`. The size of the smoothing filter. + - **max_iter**: An `int`. The maximum number of iterations. + - **tol**: A `float`. The convergence tolerance. - * For `method="espirit"`: + - For `method="espirit"`: - * **calib_size**: An `int` or a list of `ints`. The size of the + - **calib_size**: An `int` or a list of `ints`. The size of the calibration region. If `None`, this is set to `input_.shape[:-1]` (ie, use full input for calibration). Defaults to 24. - * **kernel_size**: An `int` or a list of `ints`. The kernel size. Defaults + - **kernel_size**: An `int` or a list of `ints`. The kernel size. Defaults to 6. - * **num_maps**: An `int`. The number of output maps. Defaults to 2. - * **null_threshold**: A `float`. The threshold used to determine the size + - **num_maps**: An `int`. The number of output maps. Defaults to 2. + - **null_threshold**: A `float`. The threshold used to determine the size of the null-space. Defaults to 0.02. - * **eigen_threshold**: A `float`. The threshold used to determine the + - **eigen_threshold**: A `float`. The threshold used to determine the locations where coil sensitivity maps should be masked out. Defaults to 0.95. - * **image_shape**: A `tf.TensorShape` or a list of `ints`. The shape of + - **image_shape**: A `tf.TensorShape` or a list of `ints`. The shape of the output maps. If `None`, this is set to `input_.shape`. Defaults to `None`. References: - .. [1] Walsh, D.O., Gmitro, A.F. and Marcellin, M.W. (2000), Adaptive - reconstruction of phased array MR imagery. Magn. Reson. Med., 43: - 682-690. https://doi.org/10.1002/(SICI)1522-2594(200005)43:5<682::AID-MRM10>3.0.CO;2-G - - .. [2] Inati, S.J., Hansen, M.S. and Kellman, P. (2014). A fast optimal - method for coil sensitivity estimation and adaptive coil combination for - complex images. Proceedings of the 2014 Joint Annual Meeting - ISMRM-ESMRMB. - - .. [3] Uecker, M., Lai, P., Murphy, M.J., Virtue, P., Elad, M., Pauly, J.M., - Vasanawala, S.S. and Lustig, M. (2014), ESPIRiT—an eigenvalue approach - to autocalibrating parallel MRI: Where SENSE meets GRAPPA. Magn. Reson. - Med., 71: 990-1001. https://doi.org/10.1002/mrm.24751 + 1. Walsh, D.O., Gmitro, A.F. and Marcellin, M.W. (2000), Adaptive + reconstruction of phased array MR imagery. Magn. Reson. Med., 43: + 682-690. https://doi.org/10.1002/(SICI)1522-2594(200005)43:5<682::AID-MRM10>3.0.CO;2-G + 2. Inati, S.J., Hansen, M.S. and Kellman, P. (2014). A fast optimal + method for coil sensitivity estimation and adaptive coil combination for + complex images. Proceedings of the 2014 Joint Annual Meeting + ISMRM-ESMRMB. + 3. Uecker, M., Lai, P., Murphy, M.J., Virtue, P., Elad, M., Pauly, J.M., + Vasanawala, S.S. and Lustig, M. (2014), ESPIRiT—an eigenvalue approach + to autocalibrating parallel MRI: Where SENSE meets GRAPPA. Magn. Reson. + Med., 71: 990-1001. https://doi.org/10.1002/mrm.24751 """ # pylint: disable=missing-raises-doc - input_ = tf.convert_to_tensor(input_) - tf.debugging.assert_rank_at_least(input_, 2, message=( - f"Argument `input_` must have rank of at least 2, but got shape: " - f"{input_.shape}")) - coil_axis = check_util.validate_type(coil_axis, int, name='coil_axis') - method = check_util.validate_enum( - method, {'walsh', 'inati', 'espirit'}, name='method') - - # Move coil axis to innermost dimension if not already there. - if coil_axis != -1: - rank = input_.shape.rank - canonical_coil_axis = coil_axis + rank if coil_axis < 0 else coil_axis - perm = ( - [ax for ax in range(rank) if not ax == canonical_coil_axis] + - [canonical_coil_axis]) - input_ = tf.transpose(input_, perm) - - if method == 'walsh': - maps = _estimate_coil_sensitivities_walsh(input_, **kwargs) - elif method == 'inati': - maps = _estimate_coil_sensitivities_inati(input_, **kwargs) - elif method == 'espirit': - maps = _estimate_coil_sensitivities_espirit(input_, **kwargs) - else: - raise RuntimeError("This should never happen.") - - # If necessary, move coil axis back to its original location. - if coil_axis != -1: - inv_perm = tf.math.invert_permutation(perm) - if method == 'espirit': - # When using ESPIRiT method, output has an additional `maps` dimension. - inv_perm = tf.concat([inv_perm, [tf.shape(inv_perm)[0]]], 0) - maps = tf.transpose(maps, inv_perm) - - return maps - - - -def _estimate_coil_sensitivities_walsh(images, filter_size=5): + with tf.name_scope(kwargs.get("name", "estimate_sensitivities")): + input_ = tf.convert_to_tensor(input_) + tf.debugging.assert_rank_at_least(input_, 2, message=( + f"Argument `input_` must have rank of at least 2, but got shape: " + f"{input_.shape}")) + coil_axis = check_util.validate_type(coil_axis, int, name='coil_axis') + method = check_util.validate_enum( + method, {'walsh', 'inati', 'espirit'}, name='method') + + # Move coil axis to innermost dimension if not already there. + if coil_axis != -1: + rank = input_.shape.rank + canonical_coil_axis = coil_axis + rank if coil_axis < 0 else coil_axis + perm = ( + [ax for ax in range(rank) if not ax == canonical_coil_axis] + + [canonical_coil_axis]) + input_ = tf.transpose(input_, perm) + + if method == 'walsh': + maps = _estimate_walsh(input_, **kwargs) + elif method == 'inati': + maps = _estimate_inati(input_, **kwargs) + elif method == 'espirit': + maps = _estimate_espirit(input_, **kwargs) + else: + raise RuntimeError("This should never happen.") + + # If necessary, move coil axis back to its original location. + if coil_axis != -1: + inv_perm = tf.math.invert_permutation(perm) + if method == 'espirit': + # When using ESPIRiT method, output has an additional `maps` dimension. + inv_perm = tf.concat([inv_perm, [tf.shape(inv_perm)[0]]], 0) + maps = tf.transpose(maps, inv_perm) + + return maps + + +def _estimate_walsh(images, filter_size=5): """Estimate coil sensitivity maps using Walsh's method. - For the parameters, see `estimate_coil_sensitivities`. + For the parameters, see `estimate`. """ rank = images.shape.rank - 1 image_shape = tf.shape(images)[:-1] @@ -237,13 +173,13 @@ def _estimate_coil_sensitivities_walsh(images, filter_size=5): return maps -def _estimate_coil_sensitivities_inati(images, - filter_size=5, - max_iter=5, - tol=1e-3): +def _estimate_inati(images, + filter_size=5, + max_iter=5, + tol=1e-3): """Estimate coil sensitivity maps using Inati's fast method. - For the parameters, see `estimate_coil_sensitivities`. + For the parameters, see `estimate`. """ rank = images.shape.rank - 1 spatial_axes = list(range(rank)) @@ -318,16 +254,16 @@ def _body(i, state): return tf.reshape(state.maps, images.shape) -def _estimate_coil_sensitivities_espirit(kspace, - calib_size=24, - kernel_size=6, - num_maps=2, - null_threshold=0.02, - eigen_threshold=0.95, - image_shape=None): +def _estimate_espirit(kspace, + calib_size=24, + kernel_size=6, + num_maps=2, + null_threshold=0.02, + eigen_threshold=0.95, + image_shape=None): """Estimate coil sensitivity maps using the ESPIRiT method. - For the parameters, see `estimate_coil_sensitivities`. + For the parameters, see `estimate`. """ kspace = tf.convert_to_tensor(kspace) rank = kspace.shape.rank - 1 @@ -471,4 +407,106 @@ def _apply_uniform_filter(tensor, size=5): return output +@api_util.export("coils.estimate_sensitivities_from_kspace") +def estimate_from_kspace( + kspace, + operator, + calib_data=None, + calib_fn=None, + method='walsh', + **kwargs): + """Estimates coil sensitivities from *k*-space data. + + This function is designed to standardize the computation of coil + sensitivities in different contexts. It accepts a `kspace` tensor which may + be 2D/3D and Cartesian/non-Cartesian. It never takes images as inputs. + + In addition to the `kspace` tensor, this function needs a linear `operator` + which represents the MR imaging matrix. This will be used internally to + reconstruct images from the *k*-space data. + + This function also accepts an optional `calib_data` tensor or an optional + `calib_fn` function. These can be used to provide the calibration data + directly or to specify the rules to extract it from the full *k*-space data, + respectively. + + Args: + kspace: A `tf.Tensor` containing the *k*-space data. Must be compatible + with `operator`. See + [Conventions](https://mrphys.github.io/tensorflow-mri/guide/conventions/) + for details on the common structure of *k*-space tensors. + operator: A `tfmri.linalg.LinearOperator` representing the imaging matrix. + calib_data: A `tf.Tensor` containing the calibration data. Must be + compatible with `operator`. If `None`, the calibration data will be + extracted from the `kspace` tensor using the `calib_fn` function. + calib_fn: A callable which extracts the calibration data from the input + `kspace`. Must have signature `calib_fn(kspace, operator) -> calib_data`. + If `None`, `calib_data` will be used for calibration. If `calib_data` is + also `None`, `kspace` will be used directly for calibration. + method: A `str` specifying which coil sensitivity estimation algorithm to + use. Must be one of `'direct'`, `'walsh'`, `'inati'` or `'espirit'`. + Defaults to `'walsh'`. + **kwargs: Additional keyword arguments depending on the `method`. For a + list of available arguments, see `tfmri.coils.estimate_sensitivites`. + + Returns: + A `tf.Tensor` of shape `[..., coils, *spatial_dims]` containing the coil + sensitivities. + + Raises: + ValueError: If both `calib_data` and `calib_fn` are provided. + """ + with tf.name_scope(kwargs.get('name', 'estimate_sensitivities_from_kspace')): + rank = operator.rank + kspace = tf.convert_to_tensor(kspace) + + if calib_data is None and calib_fn is None: + calib_data = kspace + elif calib_data is None and calib_fn is not None: + calib_data = calib_fn(kspace, operator) + elif calib_data is not None and calib_fn is None: + calib_data = tf.convert_to_tensor(calib_data) + else: + raise ValueError( + "Only one of `calib_data` and `calib_fn` may be specified.") + + # Reconstruct image. + calib_data = recon_adjoint.recon_adjoint(calib_data, operator) + + # If method is `'direct'`, we simply return the reconstructed calibration + # data. + if method == 'direct': + return calib_data + + # ESPIRiT method takes in k-space data, so convert back to k-space in this + # case. + if method == 'espirit': + axes = list(range(-rank, 0)) + calib_data = fft_ops.fftn(calib_data, axes=axes, norm='ortho', shift=True) + + # Reshape to single batch dimension. + batch_shape_static = calib_data.shape[:-(rank + 1)] + batch_shape = tf.shape(calib_data)[:-(rank + 1)] + calib_shape = tf.shape(calib_data)[-(rank + 1):] + calib_data = tf.reshape(calib_data, tf.concat([[-1], calib_shape], 0)) + + # Apply estimation for each element in batch. + maps = tf.map_fn( + functools.partial(estimate, + coil_axis=-(rank + 1), + method=method, + **kwargs), + calib_data) + + # Restore batch shape. + output_shape = tf.shape(maps)[1:] + output_shape_static = maps.shape[1:] + maps = tf.reshape(maps, + tf.concat([batch_shape, output_shape], 0)) + maps = tf.ensure_shape( + maps, batch_shape_static.concatenate(output_shape_static)) + + return maps + + _prod = lambda iterable: functools.reduce(lambda x, y: x * y, iterable) diff --git a/tensorflow_mri/python/coils/coil_sensitivities_test.py b/tensorflow_mri/python/coils/coil_sensitivities_test.py index f33f20ca..893364e7 100644 --- a/tensorflow_mri/python/coils/coil_sensitivities_test.py +++ b/tensorflow_mri/python/coils/coil_sensitivities_test.py @@ -12,9 +12,8 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== -"""Coil sensitivity estimation.""" +"""Tests for module `coil_sensitivities`.""" -import numpy as np import tensorflow as tf from tensorflow_mri.python.coils import coil_sensitivities @@ -22,163 +21,131 @@ from tensorflow_mri.python.ops import fft_ops from tensorflow_mri.python.ops import image_ops from tensorflow_mri.python.ops import traj_ops +from tensorflow_mri.python.util import io_util from tensorflow_mri.python.util import test_util -import matplotlib.pyplot as plt -from tensorflow_mri.python.util import plot_util +class EstimateTest(test_util.TestCase): + """Tests for ops related to estimation of coil sensitivity maps.""" + @classmethod + def setUpClass(cls): -class CoilSensitivitiesTest(test_util.TestCase): + super().setUpClass() + cls.data = io_util.read_hdf5('tests/data/coil_ops_data.h5') - def test_coil_sensitivities(self): - # Simulate k-space. - image_shape = (8, 8) + @test_util.run_in_graph_and_eager_modes + def test_walsh(self): + """Test Walsh's method.""" + # GPU results are close, but about 1-2% of values show deviations up to + # 1e-3. This is probably related to TF issue: + # https://github.com/tensorflow/tensorflow/issues/45756 + # In the meantime, we run these tests on the CPU only. Same applies to all + # other tests in this class. + with tf.device('/cpu:0'): + maps = coil_sensitivities.estimate( + self.data['images'], method='walsh') + + self.assertAllClose(maps, self.data['maps/walsh'], rtol=1e-2, atol=1e-2) + + @test_util.run_in_graph_and_eager_modes + def test_walsh_transposed(self): + """Test Walsh's method with a transposed array.""" + with tf.device('/cpu:0'): + maps = coil_sensitivities.estimate( + tf.transpose(self.data['images'], [2, 0, 1]), + coil_axis=0, method='walsh') + + self.assertAllClose(maps, tf.transpose(self.data['maps/walsh'], [2, 0, 1]), + rtol=1e-2, atol=1e-2) + + @test_util.run_in_graph_and_eager_modes + def test_inati(self): + """Test Inati's method.""" + with tf.device('/cpu:0'): + maps = coil_sensitivities.estimate( + self.data['images'], method='inati') + + self.assertAllClose(maps, self.data['maps/inati'], rtol=1e-4, atol=1e-4) + + @test_util.run_in_graph_and_eager_modes + def test_espirit(self): + """Test ESPIRiT method.""" + with tf.device('/cpu:0'): + maps = coil_sensitivities.estimate( + self.data['kspace'], method='espirit') + + self.assertAllClose(maps, self.data['maps/espirit'], rtol=1e-2, atol=1e-2) + + @test_util.run_in_graph_and_eager_modes + def test_espirit_transposed(self): + """Test ESPIRiT method with a transposed array.""" + with tf.device('/cpu:0'): + maps = coil_sensitivities.estimate( + tf.transpose(self.data['kspace'], [2, 0, 1]), + coil_axis=0, method='espirit') + + self.assertAllClose( + maps, tf.transpose(self.data['maps/espirit'], [2, 0, 1, 3]), + rtol=1e-2, atol=1e-2) + + @test_util.run_in_graph_and_eager_modes + def test_walsh_3d(self): + """Test Walsh method with 3D image.""" + with tf.device('/cpu:0'): + image = image_ops.phantom(shape=[64, 64, 64], num_coils=4) + # Currently only testing if it runs. + maps = coil_sensitivities.estimate(image, # pylint: disable=unused-variable + coil_axis=0, + method='walsh') + + +class EstimateFromKspaceTest(test_util.TestCase): + def test_estimate_from_kspace(self): + image_shape = [128, 128] image = image_ops.phantom(shape=image_shape, num_coils=4, dtype=tf.complex64) - kspace = fft_ops.fftn(image, axes=(-2, -1), shift=True) - - # Create a mask. - mask = traj_ops.random_sampling_mask( - shape=image_shape, - density=traj_ops.density_grid(image_shape, - outer_density=0.2, - inner_cutoff=0.1, - outer_cutoff=0.1)) + kspace = fft_ops.fftn(image, axes=[-2, -1], shift=True) + mask = traj_ops.accel_mask(image_shape, [2, 2], [32, 32]) + kspace = tf.where(mask, kspace, tf.zeros_like(kspace)) operator = linear_operator_mri.LinearOperatorMRI( image_shape=image_shape, mask=mask) - sens = coil_sensitivities.coil_sensitivities(kspace, - operator) - - expected = [ - [[0.43218857-4.6583355e-09j, 0.43218845-8.7869850e-11j, - 0.43218854-6.1883219e-09j, 0.43218854-6.1883219e-09j, - 0.43218854-6.1883219e-09j, 0.43218854-6.1883219e-09j, - 0.43218845-8.7869850e-11j, 0.43218857-4.6583355e-09j], - [0.43218845-8.7869850e-11j, 0.4321886 -3.5613092e-09j, - 0.4321885 +1.2543831e-08j, 0.4321885 +1.2543831e-08j, - 0.4321885 +1.2543831e-08j, 0.4321885 +1.2543831e-08j, - 0.4321886 -3.5613092e-09j, 0.43218845-8.7869850e-11j], - [0.43218854-6.1883219e-09j, 0.4321885 +1.2543831e-08j, - 0.4321885 -4.5338737e-09j, 0.4321885 -4.5338737e-09j, - 0.4321885 -4.5338737e-09j, 0.4321885 -4.5338737e-09j, - 0.4321885 +1.2543831e-08j, 0.43218854-6.1883219e-09j], - [0.43218854-6.1883219e-09j, 0.4321885 +1.2543831e-08j, - 0.4321885 -4.5338737e-09j, 0.4321885 -4.5338737e-09j, - 0.4321885 -4.5338737e-09j, 0.4321885 -4.5338737e-09j, - 0.4321885 +1.2543831e-08j, 0.43218854-6.1883219e-09j], - [0.43218854-6.1883219e-09j, 0.4321885 +1.2543831e-08j, - 0.4321885 -4.5338737e-09j, 0.4321885 -4.5338737e-09j, - 0.4321885 -4.5338737e-09j, 0.4321885 -4.5338737e-09j, - 0.4321885 +1.2543831e-08j, 0.43218854-6.1883219e-09j], - [0.43218854-6.1883219e-09j, 0.4321885 +1.2543831e-08j, - 0.4321885 -4.5338737e-09j, 0.4321885 -4.5338737e-09j, - 0.4321885 -4.5338737e-09j, 0.4321885 -4.5338737e-09j, - 0.4321885 +1.2543831e-08j, 0.43218854-6.1883219e-09j], - [0.43218845-8.7869850e-11j, 0.4321886 -3.5613092e-09j, - 0.4321885 +1.2543831e-08j, 0.4321885 +1.2543831e-08j, - 0.4321885 +1.2543831e-08j, 0.4321885 +1.2543831e-08j, - 0.4321886 -3.5613092e-09j, 0.43218845-8.7869850e-11j], - [0.43218857-4.6583355e-09j, 0.43218845-8.7869850e-11j, - 0.43218854-6.1883219e-09j, 0.43218854-6.1883219e-09j, - 0.43218854-6.1883219e-09j, 0.43218854-6.1883219e-09j, - 0.43218845-8.7869850e-11j, 0.43218857-4.6583355e-09j]], - [[0.482938 -6.7950569e-02j, 0.48293796-6.7950562e-02j, - 0.48293793-6.7950577e-02j, 0.48293793-6.7950577e-02j, - 0.48293793-6.7950577e-02j, 0.48293793-6.7950577e-02j, - 0.48293796-6.7950562e-02j, 0.482938 -6.7950569e-02j], - [0.48293796-6.7950562e-02j, 0.4829379 -6.7950562e-02j, - 0.4829379 -6.7950569e-02j, 0.4829379 -6.7950569e-02j, - 0.4829379 -6.7950569e-02j, 0.4829379 -6.7950569e-02j, - 0.4829379 -6.7950562e-02j, 0.48293796-6.7950562e-02j], - [0.48293793-6.7950577e-02j, 0.4829379 -6.7950569e-02j, - 0.48293784-6.7950577e-02j, 0.48293784-6.7950577e-02j, - 0.48293784-6.7950577e-02j, 0.48293784-6.7950577e-02j, - 0.4829379 -6.7950569e-02j, 0.48293793-6.7950577e-02j], - [0.48293793-6.7950577e-02j, 0.4829379 -6.7950569e-02j, - 0.48293784-6.7950577e-02j, 0.48293784-6.7950577e-02j, - 0.48293784-6.7950577e-02j, 0.48293784-6.7950577e-02j, - 0.4829379 -6.7950569e-02j, 0.48293793-6.7950577e-02j], - [0.48293793-6.7950577e-02j, 0.4829379 -6.7950569e-02j, - 0.48293784-6.7950577e-02j, 0.48293784-6.7950577e-02j, - 0.48293784-6.7950577e-02j, 0.48293784-6.7950577e-02j, - 0.4829379 -6.7950569e-02j, 0.48293793-6.7950577e-02j], - [0.48293793-6.7950577e-02j, 0.4829379 -6.7950569e-02j, - 0.48293784-6.7950577e-02j, 0.48293784-6.7950577e-02j, - 0.48293784-6.7950577e-02j, 0.48293784-6.7950577e-02j, - 0.4829379 -6.7950569e-02j, 0.48293793-6.7950577e-02j], - [0.48293796-6.7950562e-02j, 0.4829379 -6.7950562e-02j, - 0.4829379 -6.7950569e-02j, 0.4829379 -6.7950569e-02j, - 0.4829379 -6.7950569e-02j, 0.4829379 -6.7950569e-02j, - 0.4829379 -6.7950562e-02j, 0.48293796-6.7950562e-02j], - [0.482938 -6.7950569e-02j, 0.48293796-6.7950562e-02j, - 0.48293793-6.7950577e-02j, 0.48293793-6.7950577e-02j, - 0.48293793-6.7950577e-02j, 0.48293793-6.7950577e-02j, - 0.48293796-6.7950562e-02j, 0.482938 -6.7950569e-02j]], - [[0.48752287-6.2960379e-02j, 0.4875229 -6.2960386e-02j, - 0.48752284-6.2960386e-02j, 0.48752284-6.2960386e-02j, - 0.48752284-6.2960386e-02j, 0.48752284-6.2960386e-02j, - 0.4875229 -6.2960386e-02j, 0.48752287-6.2960379e-02j], - [0.4875229 -6.2960386e-02j, 0.4875229 -6.2960394e-02j, - 0.48752287-6.2960371e-02j, 0.48752287-6.2960371e-02j, - 0.48752287-6.2960371e-02j, 0.48752287-6.2960371e-02j, - 0.4875229 -6.2960394e-02j, 0.4875229 -6.2960386e-02j], - [0.48752284-6.2960386e-02j, 0.48752287-6.2960371e-02j, - 0.48752296-6.2960409e-02j, 0.48752296-6.2960409e-02j, - 0.48752296-6.2960409e-02j, 0.48752296-6.2960409e-02j, - 0.48752287-6.2960371e-02j, 0.48752284-6.2960386e-02j], - [0.48752284-6.2960386e-02j, 0.48752287-6.2960371e-02j, - 0.48752296-6.2960409e-02j, 0.48752296-6.2960409e-02j, - 0.48752296-6.2960409e-02j, 0.48752296-6.2960409e-02j, - 0.48752287-6.2960371e-02j, 0.48752284-6.2960386e-02j], - [0.48752284-6.2960386e-02j, 0.48752287-6.2960371e-02j, - 0.48752296-6.2960409e-02j, 0.48752296-6.2960409e-02j, - 0.48752296-6.2960409e-02j, 0.48752296-6.2960409e-02j, - 0.48752287-6.2960371e-02j, 0.48752284-6.2960386e-02j], - [0.48752284-6.2960386e-02j, 0.48752287-6.2960371e-02j, - 0.48752296-6.2960409e-02j, 0.48752296-6.2960409e-02j, - 0.48752296-6.2960409e-02j, 0.48752296-6.2960409e-02j, - 0.48752287-6.2960371e-02j, 0.48752284-6.2960386e-02j], - [0.4875229 -6.2960386e-02j, 0.4875229 -6.2960394e-02j, - 0.48752287-6.2960371e-02j, 0.48752287-6.2960371e-02j, - 0.48752287-6.2960371e-02j, 0.48752287-6.2960371e-02j, - 0.4875229 -6.2960394e-02j, 0.4875229 -6.2960386e-02j], - [0.48752287-6.2960379e-02j, 0.4875229 -6.2960386e-02j, - 0.48752284-6.2960386e-02j, 0.48752284-6.2960386e-02j, - 0.48752284-6.2960386e-02j, 0.48752284-6.2960386e-02j, - 0.4875229 -6.2960386e-02j, 0.48752287-6.2960379e-02j]], - [[0.57736677+1.9284124e-02j, 0.57736677+1.9284116e-02j, - 0.5773667 +1.9284122e-02j, 0.5773667 +1.9284122e-02j, - 0.5773667 +1.9284122e-02j, 0.5773667 +1.9284122e-02j, - 0.57736677+1.9284116e-02j, 0.57736677+1.9284124e-02j], - [0.57736677+1.9284116e-02j, 0.57736677+1.9284124e-02j, - 0.57736677+1.9284150e-02j, 0.57736677+1.9284150e-02j, - 0.57736677+1.9284150e-02j, 0.57736677+1.9284150e-02j, - 0.57736677+1.9284124e-02j, 0.57736677+1.9284116e-02j], - [0.5773667 +1.9284122e-02j, 0.57736677+1.9284150e-02j, - 0.5773668 +1.9284131e-02j, 0.5773668 +1.9284131e-02j, - 0.5773668 +1.9284131e-02j, 0.5773668 +1.9284131e-02j, - 0.57736677+1.9284150e-02j, 0.5773667 +1.9284122e-02j], - [0.5773667 +1.9284122e-02j, 0.57736677+1.9284150e-02j, - 0.5773668 +1.9284131e-02j, 0.5773668 +1.9284131e-02j, - 0.5773668 +1.9284131e-02j, 0.5773668 +1.9284131e-02j, - 0.57736677+1.9284150e-02j, 0.5773667 +1.9284122e-02j], - [0.5773667 +1.9284122e-02j, 0.57736677+1.9284150e-02j, - 0.5773668 +1.9284131e-02j, 0.5773668 +1.9284131e-02j, - 0.5773668 +1.9284131e-02j, 0.5773668 +1.9284131e-02j, - 0.57736677+1.9284150e-02j, 0.5773667 +1.9284122e-02j], - [0.5773667 +1.9284122e-02j, 0.57736677+1.9284150e-02j, - 0.5773668 +1.9284131e-02j, 0.5773668 +1.9284131e-02j, - 0.5773668 +1.9284131e-02j, 0.5773668 +1.9284131e-02j, - 0.57736677+1.9284150e-02j, 0.5773667 +1.9284122e-02j], - [0.57736677+1.9284116e-02j, 0.57736677+1.9284124e-02j, - 0.57736677+1.9284150e-02j, 0.57736677+1.9284150e-02j, - 0.57736677+1.9284150e-02j, 0.57736677+1.9284150e-02j, - 0.57736677+1.9284124e-02j, 0.57736677+1.9284116e-02j], - [0.57736677+1.9284124e-02j, 0.57736677+1.9284116e-02j, - 0.5773667 +1.9284122e-02j, 0.5773667 +1.9284122e-02j, - 0.5773667 +1.9284122e-02j, 0.5773667 +1.9284122e-02j, - 0.57736677+1.9284116e-02j, 0.57736677+1.9284124e-02j]]] - - self.assertAllClose(expected, sens) + # Test with direct *k*-space. + image = fft_ops.ifftn(kspace, axes=[-2, -1], norm='ortho', shift=True) + maps = coil_sensitivities.estimate_from_kspace( + kspace, operator, method='direct') + self.assertAllClose(image, maps) + + # Test with calibration data. + calib_mask = traj_ops.centre_mask(image_shape, [32, 32]) + calib_data = tf.where(calib_mask, kspace, tf.zeros_like(kspace)) + calib_image = fft_ops.ifftn( + calib_data, axes=[-2, -1], norm='ortho', shift=True) + maps = coil_sensitivities.estimate_from_kspace( + kspace, operator, calib_data=calib_data, method='direct') + self.assertAllClose(calib_image, maps) + + # Test with calibration function. + calib_fn = lambda x, _: tf.where(calib_mask, x, tf.zeros_like(x)) + maps = coil_sensitivities.estimate_from_kspace( + kspace, operator, calib_fn=calib_fn, method='direct') + self.assertAllClose(calib_image, maps) + + # Test Walsh. + expected = coil_sensitivities.estimate( + calib_image, coil_axis=-3, method='walsh') + maps = coil_sensitivities.estimate_from_kspace( + kspace, operator, calib_data=calib_data, method='walsh') + self.assertAllClose(expected, maps) + + # Test batch. + kspace_batch = tf.stack([kspace, 2 * kspace], axis=0) + expected = tf.stack([calib_image, 2 * calib_image], axis=0) + maps = coil_sensitivities.estimate_from_kspace( + kspace_batch, operator, calib_fn=calib_fn, method='direct') + self.assertAllClose(expected, maps) + + +if __name__ == '__main__': + tf.test.main() diff --git a/tensorflow_mri/python/models/variational_network.py b/tensorflow_mri/python/models/variational_network.py index fa044491..6b6be994 100644 --- a/tensorflow_mri/python/models/variational_network.py +++ b/tensorflow_mri/python/models/variational_network.py @@ -20,7 +20,7 @@ from tensorflow_mri.python.activations import complex_activations from tensorflow_mri.python.layers import data_consistency, normalization from tensorflow_mri.python.models import graph_like_model -from tensorflow_mri.python.ops import coil_ops, math_ops +from tensorflow_mri.python.ops import math_ops from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import keras_util from tensorflow_mri.python.util import layer_util diff --git a/tensorflow_mri/python/ops/coil_ops_test.py b/tensorflow_mri/python/ops/coil_ops_test.py deleted file mode 100755 index 7a37c8b7..00000000 --- a/tensorflow_mri/python/ops/coil_ops_test.py +++ /dev/null @@ -1,258 +0,0 @@ -# Copyright 2021 University College London. 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. -# ============================================================================== -"""Tests for module `coil_ops`.""" - -import itertools - -from absl.testing import parameterized -import tensorflow as tf - -from tensorflow_mri.python.ops import coil_ops -from tensorflow_mri.python.ops import image_ops -from tensorflow_mri.python.util import io_util -from tensorflow_mri.python.util import test_util - -# Many tests on this file have high tolerance for numerical errors, likely due -# to issues with `tf.linalg.svd`. TODO: come up with a better solution. - -class SensMapsTest(test_util.TestCase): - """Tests for ops related to estimation of coil sensitivity maps.""" - - @classmethod - def setUpClass(cls): - - super().setUpClass() - cls.data = io_util.read_hdf5('tests/data/coil_ops_data.h5') - - @test_util.run_in_graph_and_eager_modes - def test_walsh(self): - """Test Walsh's method.""" - # GPU results are close, but about 1-2% of values show deviations up to - # 1e-3. This is probably related to TF issue: - # https://github.com/tensorflow/tensorflow/issues/45756 - # In the meantime, we run these tests on the CPU only. Same applies to all - # other tests in this class. - with tf.device('/cpu:0'): - maps = coil_ops.estimate_coil_sensitivities( - self.data['images'], method='walsh') - - self.assertAllClose(maps, self.data['maps/walsh'], rtol=1e-2, atol=1e-2) - - @test_util.run_in_graph_and_eager_modes - def test_walsh_transposed(self): - """Test Walsh's method with a transposed array.""" - with tf.device('/cpu:0'): - maps = coil_ops.estimate_coil_sensitivities( - tf.transpose(self.data['images'], [2, 0, 1]), - coil_axis=0, method='walsh') - - self.assertAllClose(maps, tf.transpose(self.data['maps/walsh'], [2, 0, 1]), - rtol=1e-2, atol=1e-2) - - @test_util.run_in_graph_and_eager_modes - def test_inati(self): - """Test Inati's method.""" - with tf.device('/cpu:0'): - maps = coil_ops.estimate_coil_sensitivities( - self.data['images'], method='inati') - - self.assertAllClose(maps, self.data['maps/inati'], rtol=1e-4, atol=1e-4) - - @test_util.run_in_graph_and_eager_modes - def test_espirit(self): - """Test ESPIRiT method.""" - with tf.device('/cpu:0'): - maps = coil_ops.estimate_coil_sensitivities( - self.data['kspace'], method='espirit') - - self.assertAllClose(maps, self.data['maps/espirit'], rtol=1e-2, atol=1e-2) - - @test_util.run_in_graph_and_eager_modes - def test_espirit_transposed(self): - """Test ESPIRiT method with a transposed array.""" - with tf.device('/cpu:0'): - maps = coil_ops.estimate_coil_sensitivities( - tf.transpose(self.data['kspace'], [2, 0, 1]), - coil_axis=0, method='espirit') - - self.assertAllClose( - maps, tf.transpose(self.data['maps/espirit'], [2, 0, 1, 3]), - rtol=1e-2, atol=1e-2) - - @test_util.run_in_graph_and_eager_modes - def test_walsh_3d(self): - """Test Walsh method with 3D image.""" - with tf.device('/cpu:0'): - image = image_ops.phantom(shape=[64, 64, 64], num_coils=4) - # Currently only testing if it runs. - maps = coil_ops.estimate_coil_sensitivities(image, # pylint: disable=unused-variable - coil_axis=0, - method='walsh') - - -class CoilCombineTest(test_util.TestCase): - """Tests for coil combination op.""" - - @parameterized.product(coil_axis=[0, -1], - keepdims=[True, False]) - @test_util.run_in_graph_and_eager_modes - def test_sos(self, coil_axis, keepdims): # pylint: disable=missing-param-doc - """Test sum of squares combination.""" - - images = self._random_complex((20, 20, 8)) - - combined = coil_ops.combine_coils( - images, coil_axis=coil_axis, keepdims=keepdims) - - ref = tf.math.sqrt( - tf.math.reduce_sum(images * tf.math.conj(images), - axis=coil_axis, keepdims=keepdims)) - - self.assertAllEqual(combined.shape, ref.shape) - self.assertAllClose(combined, ref) - - - @parameterized.product(coil_axis=[0, -1], - keepdims=[True, False]) - @test_util.run_in_graph_and_eager_modes - def test_adaptive(self, coil_axis, keepdims): # pylint: disable=missing-param-doc - """Test adaptive combination.""" - - images = self._random_complex((20, 20, 8)) - maps = self._random_complex((20, 20, 8)) - - combined = coil_ops.combine_coils( - images, maps=maps, coil_axis=coil_axis, keepdims=keepdims) - - ref = tf.math.reduce_sum(images * tf.math.conj(maps), - axis=coil_axis, keepdims=keepdims) - - ref /= tf.math.reduce_sum(maps * tf.math.conj(maps), - axis=coil_axis, keepdims=keepdims) - - self.assertAllEqual(combined.shape, ref.shape) - self.assertAllClose(combined, ref) - - def setUp(self): - super().setUp() - tf.random.set_seed(0) - - def _random_complex(self, shape): - return tf.dtypes.complex( - tf.random.normal(shape), - tf.random.normal(shape)) - - -class CoilCompressionTest(test_util.TestCase): - """Tests for coil compression op.""" - - @classmethod - def setUpClass(cls): - super().setUpClass() - cls.data = io_util.read_hdf5('tests/data/coil_ops_data.h5') - - @test_util.run_in_graph_and_eager_modes - def test_coil_compression_svd(self): - """Test SVD coil compression.""" - kspace = self.data['cc/kspace'] - result = self.data['cc/result/svd'] - - cc_kspace = coil_ops.compress_coils(kspace) - - self.assertAllClose(cc_kspace, result, rtol=1e-2, atol=1e-2) - - @test_util.run_in_graph_and_eager_modes - def test_coil_compression_svd_two_step(self): - """Test SVD coil compression using two-step API.""" - kspace = self.data['cc/kspace'] - result = self.data['cc/result/svd'] - - compressor = coil_ops.CoilCompressorSVD(out_coils=16) - compressor = compressor.fit(kspace) - cc_kspace = compressor.transform(kspace) - self.assertAllClose(cc_kspace, result[..., :16], rtol=1e-2, atol=1e-2) - - @test_util.run_in_graph_and_eager_modes - def test_coil_compression_svd_transposed(self): - """Test SVD coil compression using two-step API.""" - kspace = self.data['cc/kspace'] - result = self.data['cc/result/svd'] - - kspace = tf.transpose(kspace, [2, 0, 1]) - cc_kspace = coil_ops.compress_coils(kspace, coil_axis=0) - cc_kspace = tf.transpose(cc_kspace, [1, 2, 0]) - - self.assertAllClose(cc_kspace, result, rtol=1e-2, atol=1e-2) - - @test_util.run_in_graph_and_eager_modes - def test_coil_compression_svd_basic(self): - """Test coil compression using SVD method with basic arrays.""" - shape = (20, 20, 8) - data = tf.dtypes.complex( - tf.random.stateless_normal(shape, [32, 43]), - tf.random.stateless_normal(shape, [321, 321])) - - params = { - 'out_coils': [None, 4], - 'variance_ratio': [None, 0.75]} - - values = itertools.product(*params.values()) - params = [dict(zip(params.keys(), v)) for v in values] - - for p in params: - with self.subTest(**p): - if p['out_coils'] is not None and p['variance_ratio'] is not None: - with self.assertRaisesRegex( - ValueError, - "Cannot specify both `out_coils` and `variance_ratio`"): - coil_ops.compress_coils(data, **p) - continue - - # Test op. - compressed_data = coil_ops.compress_coils(data, **p) - - # Flatten input data. - encoding_dims = tf.shape(data)[:-1] - input_coils = tf.shape(data)[-1] - data = tf.reshape(data, (-1, tf.shape(data)[-1])) - samples = tf.shape(data)[0] - - # Calculate compression matrix. - # This should be equivalent to TF line below. Not sure why - # not. Giving up. - # u, s, vh = np.linalg.svd(data, full_matrices=False) - # v = vh.T.conj() - s, u, v = tf.linalg.svd(data, full_matrices=False) - matrix = tf.cond(samples > input_coils, lambda v=v: v, lambda u=u: u) - - out_coils = input_coils - if p['variance_ratio'] and not p['out_coils']: - variance = s ** 2 / 399.0 - out_coils = tf.math.count_nonzero( - tf.math.cumsum(variance / tf.math.reduce_sum(variance), axis=0) <= - p['variance_ratio']) - if p['out_coils']: - out_coils = p['out_coils'] - matrix = matrix[:, :out_coils] - - ref_data = tf.matmul(data, matrix) - ref_data = tf.reshape( - ref_data, tf.concat([encoding_dims, [out_coils]], 0)) - - self.assertAllClose(compressed_data, ref_data) - - -if __name__ == '__main__': - tf.test.main() diff --git a/tensorflow_mri/python/ops/recon_ops.py b/tensorflow_mri/python/ops/recon_ops.py index 7c7fcdb5..5c2085ba 100644 --- a/tensorflow_mri/python/ops/recon_ops.py +++ b/tensorflow_mri/python/ops/recon_ops.py @@ -22,12 +22,12 @@ import tensorflow as tf +from tensorflow_mri.python.coils import coil_combination from tensorflow_mri.python.linalg import conjugate_gradient from tensorflow_mri.python.linalg import linear_operator_gram_matrix from tensorflow_mri.python.linalg import linear_operator_gram_mri from tensorflow_mri.python.linalg import linear_operator_mri from tensorflow_mri.python.ops import array_ops -from tensorflow_mri.python.ops import coil_ops from tensorflow_mri.python.ops import convex_ops from tensorflow_mri.python.ops import fft_ops from tensorflow_mri.python.ops import image_ops @@ -736,9 +736,9 @@ def reconstruct_grappa(kspace, # Combine coils if requested. if combine_coils: - result = coil_ops.combine_coils(result, - maps=sensitivities, - coil_axis=-rank-1) + result = coil_combination.combine_coils(result, + maps=sensitivities, + coil_axis=-rank-1) return result diff --git a/tools/docs/guide/conventions.ipynb b/tools/docs/guide/conventions.ipynb new file mode 100644 index 00000000..628e8ccd --- /dev/null +++ b/tools/docs/guide/conventions.ipynb @@ -0,0 +1,30 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.2 64-bit", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.8.2" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "0adcc2737ebf6a4a119f135174df96668767fca1ef1112612db5ecadf2b6d608" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 0a9ef14a7efdccaf713b3ae5dd817195f925a270 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Tue, 30 Aug 2022 19:44:27 +0000 Subject: [PATCH 061/101] Universal family, renamed centre -> center --- RELEASE.md | 5 +- tensorflow_mri/_api/coils/__init__.py | 6 + tensorflow_mri/_api/sampling/__init__.py | 2 +- tensorflow_mri/_api/signal/__init__.py | 6 +- .../python/coils/coil_sensitivities.py | 107 +++++++++++++----- .../python/coils/coil_sensitivities_test.py | 16 +-- tensorflow_mri/python/ops/traj_ops.py | 14 +-- tensorflow_mri/python/ops/traj_ops_test.py | 16 +-- tools/build/create_api.py | 1 - tools/docs/guide/universal.ipynb | 32 ++++++ 10 files changed, 149 insertions(+), 56 deletions(-) create mode 100644 tools/docs/guide/universal.ipynb diff --git a/RELEASE.md b/RELEASE.md index 003981af..27e818e1 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -24,7 +24,7 @@ - `tfmri.coils`: - - Added new function `estimate_sensitivities_from_kspace`. + - Added new function `estimate_sensitivities_universal`. - `tfmri.geometry`: @@ -36,7 +36,8 @@ - `tfmri.sampling`: - - Added operator ``spiral_waveform`` to public API. + - Added operator `spiral_waveform` to public API. + - Added new functions `accel_mask` and `center_mask`. ## Bug Fixes and Other Changes diff --git a/tensorflow_mri/_api/coils/__init__.py b/tensorflow_mri/_api/coils/__init__.py index 65220783..bc190fc4 100644 --- a/tensorflow_mri/_api/coils/__init__.py +++ b/tensorflow_mri/_api/coils/__init__.py @@ -1,3 +1,9 @@ # This file was automatically generated by tools/build/create_api.py. # Do not edit. """Parallel imaging operations.""" + +from tensorflow_mri.python.coils.coil_combination import combine_coils as combine_coils +from tensorflow_mri.python.coils.coil_compression import compress_coils as compress_coils +from tensorflow_mri.python.coils.coil_compression import CoilCompressorSVD as CoilCompressorSVD +from tensorflow_mri.python.coils.coil_sensitivities import estimate as estimate_sensitivities +from tensorflow_mri.python.coils.coil_sensitivities import estimate_universal as estimate_sensitivities_universal diff --git a/tensorflow_mri/_api/sampling/__init__.py b/tensorflow_mri/_api/sampling/__init__.py index 19996e42..09cb474b 100644 --- a/tensorflow_mri/_api/sampling/__init__.py +++ b/tensorflow_mri/_api/sampling/__init__.py @@ -5,7 +5,7 @@ from tensorflow_mri.python.ops.traj_ops import density_grid as density_grid from tensorflow_mri.python.ops.traj_ops import frequency_grid as frequency_grid from tensorflow_mri.python.ops.traj_ops import random_sampling_mask as random_mask -from tensorflow_mri.python.ops.traj_ops import centre_mask as centre_mask +from tensorflow_mri.python.ops.traj_ops import center_mask as center_mask from tensorflow_mri.python.ops.traj_ops import accel_mask as accel_mask from tensorflow_mri.python.ops.traj_ops import radial_trajectory as radial_trajectory from tensorflow_mri.python.ops.traj_ops import spiral_trajectory as spiral_trajectory diff --git a/tensorflow_mri/_api/signal/__init__.py b/tensorflow_mri/_api/signal/__init__.py index fb4161e1..b6f632a6 100644 --- a/tensorflow_mri/_api/signal/__init__.py +++ b/tensorflow_mri/_api/signal/__init__.py @@ -9,6 +9,9 @@ from tensorflow_mri.python.ops.wavelet_ops import dwt_max_level as max_wavelet_level from tensorflow_mri.python.ops.wavelet_ops import coeffs_to_tensor as wavelet_coeffs_to_tensor from tensorflow_mri.python.ops.wavelet_ops import tensor_to_coeffs as tensor_to_wavelet_coeffs +from tensorflow_mri.python.ops.fft_ops import fftn as fft +from tensorflow_mri.python.ops.fft_ops import ifftn as ifft +from tensorflow_nufft.python.ops.nufft_ops import nufft as nufft from tensorflow_mri.python.ops.signal_ops import hann as hann from tensorflow_mri.python.ops.signal_ops import hamming as hamming from tensorflow_mri.python.ops.signal_ops import atanfilt as atanfilt @@ -16,6 +19,3 @@ from tensorflow_mri.python.ops.signal_ops import separable_window as separable_window from tensorflow_mri.python.ops.signal_ops import filter_kspace as filter_kspace from tensorflow_mri.python.ops.signal_ops import crop_kspace as crop_kspace -from tensorflow_mri.python.ops.fft_ops import fftn as fft -from tensorflow_mri.python.ops.fft_ops import ifftn as ifft -from tensorflow_nufft.python.ops.nufft_ops import nufft as nufft diff --git a/tensorflow_mri/python/coils/coil_sensitivities.py b/tensorflow_mri/python/coils/coil_sensitivities.py index 5798743e..5cba7f43 100644 --- a/tensorflow_mri/python/coils/coil_sensitivities.py +++ b/tensorflow_mri/python/coils/coil_sensitivities.py @@ -407,42 +407,97 @@ def _apply_uniform_filter(tensor, size=5): return output -@api_util.export("coils.estimate_sensitivities_from_kspace") -def estimate_from_kspace( - kspace, +@api_util.export("coils.estimate_sensitivities_universal") +def estimate_universal( + meas_data, operator, calib_data=None, calib_fn=None, method='walsh', **kwargs): - """Estimates coil sensitivities from *k*-space data. + """Estimates coil sensitivities (universal). This function is designed to standardize the computation of coil - sensitivities in different contexts. It accepts a `kspace` tensor which may - be 2D/3D and Cartesian/non-Cartesian. It never takes images as inputs. - - In addition to the `kspace` tensor, this function needs a linear `operator` - which represents the MR imaging matrix. This will be used internally to - reconstruct images from the *k*-space data. + sensitivities in different contexts. The `meas_data` argument can accept + arbitrary measurement data (e.g., N-dimensional, Cartesian/non-Cartesian + *k*-space tensors). In addition, this function expects a linear `operator` + which describes the action of the measurement system (e.g., the MR imaging + experiment). This function also accepts an optional `calib_data` tensor or an optional - `calib_fn` function. These can be used to provide the calibration data - directly or to specify the rules to extract it from the full *k*-space data, - respectively. + `calib_fn` function, in case the calibration should be performed with data + other than `meas_data`. `calib_data` may be used to provide the calibration + data directly, whereas `calib_fn` may be used to specify the rules to extract + it from `meas_data`. + + ```{note} + This function is part of the + [universal family](https://mrphys.github.io/tensorflow-mri/guide/universal/) + of operators designed to work flexibly with any linear system. + ``` + + Example: + >>> # Create an example image. + >>> image_shape = [256, 256] + >>> image = tfmri.image.phantom(shape=image_shape, + ... num_coils=8, + ... dtype=tf.complex64) + >>> kspace = tfmri.signal.fft(image, axes=[-2, -1], shift=True) + >>> # Create an acceleration mask with 4x undersampling along the last axis + >>> # and 24 calibration lines. + >>> mask = tfmri.sampling.accel_mask(shape=image_shape, + ... acceleration=[1, 4], + ... center_size=[256, 24]) + >>> # Create a linear operator describing a basic MR experiment with + >>> # Cartesian undersampling. This operator maps an image to the + >>> # corresponding *k*-space data (by performing an FFT and masking the + >>> # measured values). + >>> linop_mri = tfmri.linalg.LinearOperatorMRI( + ... image_shape=image_shape, mask=mask) + >>> # Generate *k*-space data using the system operator. + >>> kspace = linop_mri.transform(image) + >>> # To compute the sensitivity maps, we typically want to use only the + >>> # fully-sampled central region of *k*-space. Let's create a mask that + >>> # retrieves only the 24 calibration lines. + >>> calib_mask = tfmri.sampling.center_mask(shape=image_shape, + ... center_size=[256, 24]) + >>> # We can create a function that extracts the calibration data from + >>> # an arbitrary *k*-space by applying the calibration mask below. + >>> def calib_fn(meas_data, operator): + ... # Returns `meas_data` where `calib_mask` is `True`, 0 otherwise. + ... return tf.where(calib_mask, meas_data, tf.zeros_like(meas_data)) + >>> # Finally, compute the coil sensitivities using the above function + >>> # to extract the calibration data. + >>> maps = tfmri.coils.estimate_sensitivities_universal( + ... kspace, linop_mri, calib_fn=calib_fn) Args: - kspace: A `tf.Tensor` containing the *k*-space data. Must be compatible - with `operator`. See - [Conventions](https://mrphys.github.io/tensorflow-mri/guide/conventions/) - for details on the common structure of *k*-space tensors. - operator: A `tfmri.linalg.LinearOperator` representing the imaging matrix. + meas_data: A `tf.Tensor` containing the measurement or observation data. + Must be compatible with the range of `operator`, i.e., it should be a + plausible output of the system operator. Accordingly, it should be a + plausible input for the adjoint of the system operator. + ```{tip} + In MRI, this is usually the *k*-space data. + ``` + operator: A `tfmri.linalg.LinearOperator` describing the action of the + measurement system, i.e., mapping an object Its range must be compatible with `meas_data`, i.e., + its adjoint should be able to process `meas_data` correctly. + ```{tip} + In MRI, this is usually an operator mapping images to the corresponding + *k*-space data. For most MRI experiments, you can use + `tfmri.linalg.LinearOperatorMRI`. + ``` calib_data: A `tf.Tensor` containing the calibration data. Must be compatible with `operator`. If `None`, the calibration data will be - extracted from the `kspace` tensor using the `calib_fn` function. + extracted from the `meas_data` tensor using the `calib_fn` function. + ```{tip} + In MRI, this is usually the central, fully-sampled region of *k*-space. + ``` calib_fn: A callable which extracts the calibration data from the input - `kspace`. Must have signature `calib_fn(kspace, operator) -> calib_data`. - If `None`, `calib_data` will be used for calibration. If `calib_data` is - also `None`, `kspace` will be used directly for calibration. + `meas_data`. Must have signature + `calib_fn(meas_data, operator) -> calib_data`. If `None`, `calib_data` + will be used for calibration. If `calib_data` is also `None`, `meas_data` + will be used directly for calibration. method: A `str` specifying which coil sensitivity estimation algorithm to use. Must be one of `'direct'`, `'walsh'`, `'inati'` or `'espirit'`. Defaults to `'walsh'`. @@ -456,14 +511,14 @@ def estimate_from_kspace( Raises: ValueError: If both `calib_data` and `calib_fn` are provided. """ - with tf.name_scope(kwargs.get('name', 'estimate_sensitivities_from_kspace')): + with tf.name_scope(kwargs.get('name', 'estimate_sensitivities_universal')): rank = operator.rank - kspace = tf.convert_to_tensor(kspace) + meas_data = tf.convert_to_tensor(meas_data) if calib_data is None and calib_fn is None: - calib_data = kspace + calib_data = meas_data elif calib_data is None and calib_fn is not None: - calib_data = calib_fn(kspace, operator) + calib_data = calib_fn(meas_data, operator) elif calib_data is not None and calib_fn is None: calib_data = tf.convert_to_tensor(calib_data) else: diff --git a/tensorflow_mri/python/coils/coil_sensitivities_test.py b/tensorflow_mri/python/coils/coil_sensitivities_test.py index 893364e7..913d93c3 100644 --- a/tensorflow_mri/python/coils/coil_sensitivities_test.py +++ b/tensorflow_mri/python/coils/coil_sensitivities_test.py @@ -99,8 +99,8 @@ def test_walsh_3d(self): method='walsh') -class EstimateFromKspaceTest(test_util.TestCase): - def test_estimate_from_kspace(self): +class EstimateUniversalTest(test_util.TestCase): + def test_estimate_universal(self): image_shape = [128, 128] image = image_ops.phantom(shape=image_shape, num_coils=4, dtype=tf.complex64) @@ -113,36 +113,36 @@ def test_estimate_from_kspace(self): # Test with direct *k*-space. image = fft_ops.ifftn(kspace, axes=[-2, -1], norm='ortho', shift=True) - maps = coil_sensitivities.estimate_from_kspace( + maps = coil_sensitivities.estimate_universal( kspace, operator, method='direct') self.assertAllClose(image, maps) # Test with calibration data. - calib_mask = traj_ops.centre_mask(image_shape, [32, 32]) + calib_mask = traj_ops.center_mask(image_shape, [32, 32]) calib_data = tf.where(calib_mask, kspace, tf.zeros_like(kspace)) calib_image = fft_ops.ifftn( calib_data, axes=[-2, -1], norm='ortho', shift=True) - maps = coil_sensitivities.estimate_from_kspace( + maps = coil_sensitivities.estimate_universal( kspace, operator, calib_data=calib_data, method='direct') self.assertAllClose(calib_image, maps) # Test with calibration function. calib_fn = lambda x, _: tf.where(calib_mask, x, tf.zeros_like(x)) - maps = coil_sensitivities.estimate_from_kspace( + maps = coil_sensitivities.estimate_universal( kspace, operator, calib_fn=calib_fn, method='direct') self.assertAllClose(calib_image, maps) # Test Walsh. expected = coil_sensitivities.estimate( calib_image, coil_axis=-3, method='walsh') - maps = coil_sensitivities.estimate_from_kspace( + maps = coil_sensitivities.estimate_universal( kspace, operator, calib_data=calib_data, method='walsh') self.assertAllClose(expected, maps) # Test batch. kspace_batch = tf.stack([kspace, 2 * kspace], axis=0) expected = tf.stack([calib_image, 2 * calib_image], axis=0) - maps = coil_sensitivities.estimate_from_kspace( + maps = coil_sensitivities.estimate_universal( kspace_batch, operator, calib_fn=calib_fn, method='direct') self.assertAllClose(expected, maps) diff --git a/tensorflow_mri/python/ops/traj_ops.py b/tensorflow_mri/python/ops/traj_ops.py index ab7d3fe0..511d6c3e 100755 --- a/tensorflow_mri/python/ops/traj_ops.py +++ b/tensorflow_mri/python/ops/traj_ops.py @@ -192,8 +192,8 @@ def random_sampling_mask(shape, density=1.0, seed=None, rng=None, name=None): return tf.cast(mask, tf.bool) -@api_util.export("sampling.centre_mask") -def centre_mask(shape, center_size, name=None): +@api_util.export("sampling.center_mask") +def center_mask(shape, center_size, name=None): """Returns a central sampling mask. This function returns a boolean tensor of zeros with a central region of ones. @@ -218,7 +218,7 @@ def centre_mask(shape, center_size, name=None): Example: - >>> mask = tfmri.sampling.centre_mask([8], [4]) + >>> mask = tfmri.sampling.center_mask([8], [4]) >>> mask.numpy() array([False, False, True, True, True, True, False, False]) @@ -239,7 +239,7 @@ def centre_mask(shape, center_size, name=None): Raises: TypeError: If `center_size` is not of integer or floating point dtype. """ - with tf.name_scope(name or 'centre_mask'): + with tf.name_scope(name or 'center_mask'): shape = tf.convert_to_tensor(shape, dtype=tf.int32) center_size = tf.convert_to_tensor(center_size) @@ -269,7 +269,7 @@ def centre_mask(shape, center_size, name=None): @api_util.export("sampling.accel_mask") def accel_mask(shape, acceleration, - centre_size=0, + center_size=0, mask_type='equispaced', offset=0, rng=None, @@ -308,7 +308,7 @@ def accel_mask(shape, shape: A 1D integer `tf.Tensor`. The shape of the output mask. acceleration: A 1D integer `tf.Tensor`. The acceleration factor on the peripheral region along each axis. - centre_size: A 1D integer `tf.Tensor`. The size of the central region + center_size: A 1D integer `tf.Tensor`. The size of the central region along each axis. Defaults to 0. mask_type: A `str`. The type of sampling to use on the peripheral region. Must be one of `'equispaced'` or `'random'`. If `'equispaced'`, the @@ -376,7 +376,7 @@ def fn(accum, elems): _, mask = tf.foldl(fn, (shape, acceleration, offset), initializer=(0, mask)) - return tf.math.logical_or(mask, centre_mask(shape, centre_size)) + return tf.math.logical_or(mask, center_mask(shape, center_size)) @api_util.export("sampling.radial_trajectory") diff --git a/tensorflow_mri/python/ops/traj_ops_test.py b/tensorflow_mri/python/ops/traj_ops_test.py index edf632c5..ad0cb748 100755 --- a/tensorflow_mri/python/ops/traj_ops_test.py +++ b/tensorflow_mri/python/ops/traj_ops_test.py @@ -103,35 +103,35 @@ def test_frequency_grid_2d(self): class CentralMaskTest(test_util.TestCase): - def test_centre_mask(self): - result = traj_ops.centre_mask([8], [4]) + def test_center_mask(self): + result = traj_ops.center_mask([8], [4]) expected = [0, 0, 1, 1, 1, 1, 0, 0] self.assertAllClose(expected, result) - result = traj_ops.centre_mask([9], [5]) + result = traj_ops.center_mask([9], [5]) expected = [0, 0, 1, 1, 1, 1, 1, 0, 0] self.assertAllClose(expected, result) - result = traj_ops.centre_mask([8], [0.5]) + result = traj_ops.center_mask([8], [0.5]) expected = [0, 0, 1, 1, 1, 1, 0, 0] self.assertAllClose(expected, result) - result = traj_ops.centre_mask([9], [0.5]) + result = traj_ops.center_mask([9], [0.5]) expected = [0, 0, 1, 1, 1, 1, 1, 0, 0] self.assertAllClose(expected, result) - result = traj_ops.centre_mask([8], [5]) + result = traj_ops.center_mask([8], [5]) expected = [0, 0, 1, 1, 1, 1, 0, 0] self.assertAllClose(expected, result) - result = traj_ops.centre_mask([4, 8], [2, 4]) + result = traj_ops.center_mask([4, 8], [2, 4]) expected = [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]] self.assertAllClose(expected, result) - result = traj_ops.centre_mask([4, 8], [1.0, 0.5]) + result = traj_ops.center_mask([4, 8], [1.0, 0.5]) expected = [[0, 0, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0], diff --git a/tools/build/create_api.py b/tools/build/create_api.py index 6fee9620..e64cedb2 100644 --- a/tools/build/create_api.py +++ b/tools/build/create_api.py @@ -40,7 +40,6 @@ # TODO(jmontalt): Remove these imports on release 1.0.0. from tensorflow_mri.python.ops.array_ops import * -from tensorflow_mri.python.ops.coil_ops import * from tensorflow_mri.python.ops.convex_ops import * from tensorflow_mri.python.ops.fft_ops import * from tensorflow_mri.python.ops.image_ops import * diff --git a/tools/docs/guide/universal.ipynb b/tools/docs/guide/universal.ipynb new file mode 100644 index 00000000..097c9c19 --- /dev/null +++ b/tools/docs/guide/universal.ipynb @@ -0,0 +1,32 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Universal operators\n", + "\n", + "Coming soon..." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.2 64-bit", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.8.2" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "0adcc2737ebf6a4a119f135174df96668767fca1ef1112612db5ecadf2b6d608" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From a5ce0dd2581ac0fb6243959f73285c8d3b7de6fd Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Tue, 30 Aug 2022 19:45:01 +0000 Subject: [PATCH 062/101] Remove conventions guide --- tools/docs/guide/conventions.ipynb | 30 ------------------------------ 1 file changed, 30 deletions(-) delete mode 100644 tools/docs/guide/conventions.ipynb diff --git a/tools/docs/guide/conventions.ipynb b/tools/docs/guide/conventions.ipynb deleted file mode 100644 index 628e8ccd..00000000 --- a/tools/docs/guide/conventions.ipynb +++ /dev/null @@ -1,30 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.8.2 64-bit", - "language": "python", - "name": "python3" - }, - "language_info": { - "name": "python", - "version": "3.8.2" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "0adcc2737ebf6a4a119f135174df96668767fca1ef1112612db5ecadf2b6d608" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 72b26571d78715d6b85dbcdacab79a1e7d5c8ac5 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Tue, 30 Aug 2022 20:01:54 +0000 Subject: [PATCH 063/101] Add GitHub PR extension --- .devcontainer/devcontainer.json | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index f813b572..9022d9f2 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -6,7 +6,8 @@ "extensions": [ "ms-python.python", "ms-vscode.cpptools", - "github.copilot" + "github.copilot", + "github.vscode-pull-request-github" ], // Enable GPUs. "runArgs": [ From b1cb92368bb9b713fc12951f14c47a932c83b0eb Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Tue, 30 Aug 2022 20:05:07 +0000 Subject: [PATCH 064/101] Updated some docstrings --- tensorflow_mri/python/coils/coil_combination.py | 8 ++++---- tensorflow_mri/python/coils/coil_combination_test.py | 1 + tensorflow_mri/python/coils/coil_compression.py | 2 +- 3 files changed, 6 insertions(+), 5 deletions(-) diff --git a/tensorflow_mri/python/coils/coil_combination.py b/tensorflow_mri/python/coils/coil_combination.py index 773b85cf..d4e93209 100644 --- a/tensorflow_mri/python/coils/coil_combination.py +++ b/tensorflow_mri/python/coils/coil_combination.py @@ -25,18 +25,18 @@ def combine_coils(images, maps=None, coil_axis=-1, keepdims=False, name=None): Supports sum of squares (when `maps` is `None`) and adaptive combination. Args: - images: A `Tensor`. The input images. - maps: A `Tensor`. The Wcoil sensitivity maps. This argument is optional. + images: A `tf.Tensor`. The input images. + maps: A `tf.Tensor`. The Wcoil sensitivity maps. This argument is optional. If `maps` is provided, it must have the same shape and type as `images`. In this case an adaptive coil combination is performed using the specified maps. If `maps` is `None`, a simple estimate of `maps` is used (ie, images are combined using the sum of squares method). coil_axis: An `int`. The coil axis. Defaults to -1. - keepdims: A `boolean`. If `True`, retains the coil dimension with size 1. + keepdims: A boolean. If `True`, retains the coil dimension with size 1. name: A name for the operation. Defaults to "combine_coils". Returns: - A `Tensor`. The combined images. + A `tf.Tensor`. The combined images. References: 1. Roemer, P.B., Edelstein, W.A., Hayes, C.E., Souza, S.P. and diff --git a/tensorflow_mri/python/coils/coil_combination_test.py b/tensorflow_mri/python/coils/coil_combination_test.py index 315519a2..86fa3c91 100644 --- a/tensorflow_mri/python/coils/coil_combination_test.py +++ b/tensorflow_mri/python/coils/coil_combination_test.py @@ -12,6 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== +"""Tests for module `coil_combination`.""" from absl.testing import parameterized import tensorflow as tf diff --git a/tensorflow_mri/python/coils/coil_compression.py b/tensorflow_mri/python/coils/coil_compression.py index a35f863d..6fb50710 100644 --- a/tensorflow_mri/python/coils/coil_compression.py +++ b/tensorflow_mri/python/coils/coil_compression.py @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== -"""Coil sensitivity estimation.""" +"""Coil compression.""" import abc From 008e65154e15eba412fa31cfe144da550f7e55ff Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Tue, 30 Aug 2022 21:20:15 +0000 Subject: [PATCH 065/101] Some fixes to coil sensitivities --- tensorflow_mri/_api/coils/__init__.py | 4 +-- .../python/coils/coil_sensitivities.py | 16 ++++++------ .../python/coils/coil_sensitivities_test.py | 26 +++++++++---------- 3 files changed, 23 insertions(+), 23 deletions(-) diff --git a/tensorflow_mri/_api/coils/__init__.py b/tensorflow_mri/_api/coils/__init__.py index bc190fc4..300a3855 100644 --- a/tensorflow_mri/_api/coils/__init__.py +++ b/tensorflow_mri/_api/coils/__init__.py @@ -5,5 +5,5 @@ from tensorflow_mri.python.coils.coil_combination import combine_coils as combine_coils from tensorflow_mri.python.coils.coil_compression import compress_coils as compress_coils from tensorflow_mri.python.coils.coil_compression import CoilCompressorSVD as CoilCompressorSVD -from tensorflow_mri.python.coils.coil_sensitivities import estimate as estimate_sensitivities -from tensorflow_mri.python.coils.coil_sensitivities import estimate_universal as estimate_sensitivities_universal +from tensorflow_mri.python.coils.coil_sensitivities import estimate_sensitivities as estimate_sensitivities +from tensorflow_mri.python.coils.coil_sensitivities import estimate_sensitivities_universal as estimate_sensitivities_universal diff --git a/tensorflow_mri/python/coils/coil_sensitivities.py b/tensorflow_mri/python/coils/coil_sensitivities.py index 5cba7f43..5b0e3df6 100644 --- a/tensorflow_mri/python/coils/coil_sensitivities.py +++ b/tensorflow_mri/python/coils/coil_sensitivities.py @@ -29,7 +29,7 @@ @api_util.export("coils.estimate_sensitivities") -def estimate(input_, coil_axis=-1, method='walsh', **kwargs): +def estimate_sensitivities(input_, coil_axis=-1, method='walsh', **kwargs): """Estimates coil sensitivity maps. This method supports 2D and 3D inputs. @@ -408,7 +408,7 @@ def _apply_uniform_filter(tensor, size=5): @api_util.export("coils.estimate_sensitivities_universal") -def estimate_universal( +def estimate_sensitivities_universal( meas_data, operator, calib_data=None, @@ -431,9 +431,9 @@ def estimate_universal( it from `meas_data`. ```{note} - This function is part of the - [universal family](https://mrphys.github.io/tensorflow-mri/guide/universal/) - of operators designed to work flexibly with any linear system. + This function is part of the family of + [universal operators](https://mrphys.github.io/tensorflow-mri/guide/universal/), + a set of functions designed to work flexibly with any linear system. ``` Example: @@ -480,8 +480,8 @@ def estimate_universal( In MRI, this is usually the *k*-space data. ``` operator: A `tfmri.linalg.LinearOperator` describing the action of the - measurement system, i.e., mapping an object Its range must be compatible with `meas_data`, i.e., - its adjoint should be able to process `meas_data` correctly. + measurement system. `operator` maps the causal factors to the measurement + or observation data. Its range must be compatible with `meas_data`. ```{tip} In MRI, this is usually an operator mapping images to the corresponding *k*-space data. For most MRI experiments, you can use @@ -547,7 +547,7 @@ def estimate_universal( # Apply estimation for each element in batch. maps = tf.map_fn( - functools.partial(estimate, + functools.partial(estimate_sensitivities, coil_axis=-(rank + 1), method=method, **kwargs), diff --git a/tensorflow_mri/python/coils/coil_sensitivities_test.py b/tensorflow_mri/python/coils/coil_sensitivities_test.py index 913d93c3..4edca41b 100644 --- a/tensorflow_mri/python/coils/coil_sensitivities_test.py +++ b/tensorflow_mri/python/coils/coil_sensitivities_test.py @@ -42,7 +42,7 @@ def test_walsh(self): # In the meantime, we run these tests on the CPU only. Same applies to all # other tests in this class. with tf.device('/cpu:0'): - maps = coil_sensitivities.estimate( + maps = coil_sensitivities.estimate_sensitivities( self.data['images'], method='walsh') self.assertAllClose(maps, self.data['maps/walsh'], rtol=1e-2, atol=1e-2) @@ -51,7 +51,7 @@ def test_walsh(self): def test_walsh_transposed(self): """Test Walsh's method with a transposed array.""" with tf.device('/cpu:0'): - maps = coil_sensitivities.estimate( + maps = coil_sensitivities.estimate_sensitivities( tf.transpose(self.data['images'], [2, 0, 1]), coil_axis=0, method='walsh') @@ -62,7 +62,7 @@ def test_walsh_transposed(self): def test_inati(self): """Test Inati's method.""" with tf.device('/cpu:0'): - maps = coil_sensitivities.estimate( + maps = coil_sensitivities.estimate_sensitivities( self.data['images'], method='inati') self.assertAllClose(maps, self.data['maps/inati'], rtol=1e-4, atol=1e-4) @@ -71,7 +71,7 @@ def test_inati(self): def test_espirit(self): """Test ESPIRiT method.""" with tf.device('/cpu:0'): - maps = coil_sensitivities.estimate( + maps = coil_sensitivities.estimate_sensitivities( self.data['kspace'], method='espirit') self.assertAllClose(maps, self.data['maps/espirit'], rtol=1e-2, atol=1e-2) @@ -80,7 +80,7 @@ def test_espirit(self): def test_espirit_transposed(self): """Test ESPIRiT method with a transposed array.""" with tf.device('/cpu:0'): - maps = coil_sensitivities.estimate( + maps = coil_sensitivities.estimate_sensitivities( tf.transpose(self.data['kspace'], [2, 0, 1]), coil_axis=0, method='espirit') @@ -94,13 +94,13 @@ def test_walsh_3d(self): with tf.device('/cpu:0'): image = image_ops.phantom(shape=[64, 64, 64], num_coils=4) # Currently only testing if it runs. - maps = coil_sensitivities.estimate(image, # pylint: disable=unused-variable + maps = coil_sensitivities.estimate_sensitivities(image, # pylint: disable=unused-variable coil_axis=0, method='walsh') class EstimateUniversalTest(test_util.TestCase): - def test_estimate_universal(self): + def test_estimate_sensitivities_universal(self): image_shape = [128, 128] image = image_ops.phantom(shape=image_shape, num_coils=4, dtype=tf.complex64) @@ -113,7 +113,7 @@ def test_estimate_universal(self): # Test with direct *k*-space. image = fft_ops.ifftn(kspace, axes=[-2, -1], norm='ortho', shift=True) - maps = coil_sensitivities.estimate_universal( + maps = coil_sensitivities.estimate_sensitivities_universal( kspace, operator, method='direct') self.assertAllClose(image, maps) @@ -122,27 +122,27 @@ def test_estimate_universal(self): calib_data = tf.where(calib_mask, kspace, tf.zeros_like(kspace)) calib_image = fft_ops.ifftn( calib_data, axes=[-2, -1], norm='ortho', shift=True) - maps = coil_sensitivities.estimate_universal( + maps = coil_sensitivities.estimate_sensitivities_universal( kspace, operator, calib_data=calib_data, method='direct') self.assertAllClose(calib_image, maps) # Test with calibration function. calib_fn = lambda x, _: tf.where(calib_mask, x, tf.zeros_like(x)) - maps = coil_sensitivities.estimate_universal( + maps = coil_sensitivities.estimate_sensitivities_universal( kspace, operator, calib_fn=calib_fn, method='direct') self.assertAllClose(calib_image, maps) # Test Walsh. - expected = coil_sensitivities.estimate( + expected = coil_sensitivities.estimate_sensitivities( calib_image, coil_axis=-3, method='walsh') - maps = coil_sensitivities.estimate_universal( + maps = coil_sensitivities.estimate_sensitivities_universal( kspace, operator, calib_data=calib_data, method='walsh') self.assertAllClose(expected, maps) # Test batch. kspace_batch = tf.stack([kspace, 2 * kspace], axis=0) expected = tf.stack([calib_image, 2 * calib_image], axis=0) - maps = coil_sensitivities.estimate_universal( + maps = coil_sensitivities.estimate_sensitivities_universal( kspace_batch, operator, calib_fn=calib_fn, method='direct') self.assertAllClose(expected, maps) From 4676e296c02ae2fb73ab22687bc019113d75261e Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Tue, 30 Aug 2022 23:22:01 +0000 Subject: [PATCH 066/101] Improved docs for custom FFT kernels --- tensorflow_mri/_api/coils/__init__.py | 1 + tools/docs/guide/fft.ipynb | 53 +++++++++++++++++++++++---- 2 files changed, 47 insertions(+), 7 deletions(-) diff --git a/tensorflow_mri/_api/coils/__init__.py b/tensorflow_mri/_api/coils/__init__.py index 300a3855..3507aab3 100644 --- a/tensorflow_mri/_api/coils/__init__.py +++ b/tensorflow_mri/_api/coils/__init__.py @@ -5,5 +5,6 @@ from tensorflow_mri.python.coils.coil_combination import combine_coils as combine_coils from tensorflow_mri.python.coils.coil_compression import compress_coils as compress_coils from tensorflow_mri.python.coils.coil_compression import CoilCompressorSVD as CoilCompressorSVD +from tensorflow_mri.python.coils.coil_compression import compress_coils_universal as compress_coils_universal from tensorflow_mri.python.coils.coil_sensitivities import estimate_sensitivities as estimate_sensitivities from tensorflow_mri.python.coils.coil_sensitivities import estimate_sensitivities_universal as estimate_sensitivities_universal diff --git a/tools/docs/guide/fft.ipynb b/tools/docs/guide/fft.ipynb index 311da510..72099ca6 100644 --- a/tools/docs/guide/fft.ipynb +++ b/tools/docs/guide/fft.ipynb @@ -20,23 +20,62 @@ "\n", "The custom FFT kernels are automatically registered to the TensorFlow framework when importing TensorFlow MRI. If you have imported TensorFlow MRI, then the standard FFT ops will use the optimized kernels automatically.\n", "\n", - ":::{tip}\n", + "```{tip}\n", "You only need to `import tensorflow_mri` in order to use the custom FFT kernels. You can then access them as usual through `tf.signal.fft`, `tf.signal.fft2d` and `tf.signal.fft3d`.\n", - ":::\n", + "```\n", "\n", "The only caveat is that the [FFTW license](https://www.fftw.org/doc/License-and-Copyright.html) is more restrictive than the [Apache 2.0 license](https://www.apache.org/licenses/LICENSE-2.0) used by TensorFlow MRI. In particular, GNU GPL requires you to distribute any derivative software under equivalent terms.\n", "\n", - ":::{warning}\n", + "```{warning}\n", "If you intend to use custom FFT kernels for commercial purposes, you will need to purchase a commercial FFTW license.\n", - ":::\n", + "```\n", "\n", "### Disable the use of custom FFT kernels\n", "\n", "You can control whether custom FFT kernels are used via the `TFMRI_USE_CUSTOM_FFT` environment variable. When set to false, TensorFlow MRI will not register its custom FFT kernels, falling back to the standard FFT kernels in core TensorFlow. If the variable is unset, its value defaults to true.\n", "\n", - ":::{tip}\n", - "Set `TFMRI_USE_CUSTOM_FFT=0` to disable the custom FFT kernels. This must be done **before** importing TensorFlow MRI. Setting or changing the value of `TFMRI_USE_CUSTOM_FFT` after importing the package will have no effect.\n", - ":::" + "````{tip}\n", + "Set `TFMRI_USE_CUSTOM_FFT=0` to disable the custom FFT kernels.\n", + "\n", + "```python\n", + "os.environ[\"TFMRI_USE_CUSTOM_FFT\"] = \"0\"\n", + "import tensorflow_mri as tfmri\n", + "```\n", + "\n", + "```{attention}\n", + "`TFMRI_USE_CUSTOM_FFT` must be set **before** importing TensorFlow MRI. Setting or changing its value after importing the package will have no effect.\n", + "```\n", + "````\n", + "\n", + "### Customize the behavior of custom FFT kernels\n", + "\n", + "FFTW allows you to control the rigor of the planning process. The more rigorously a plan is created, the more efficient the actual FFT execution is likely to be, at the expense of a longer planning time. TensorFlow MRI lets you control the FFTW planning rigor through the `TFMRI_FFTW_PLANNING_RIGOR` environment variable. Valid values for this variable are:\n", + "\n", + "- `\"estimate\"` specifies that, instead of actual measurements of different algorithms, a simple heuristic is used to pick a (probably sub-optimal) plan quickly.\n", + "- `\"measure\"` tells FFTW to find an optimized plan by actually computing several FFTs and measuring their execution time. Depending on your machine, this can take some time (often a few seconds). This is the default planning option.\n", + "- `\"patient\"` is like `\"measure\"`, but considers a wider range of algorithms and often produces a “more optimal” plan (especially for large transforms), but at the expense of several times longer planning time (especially for large transforms).\n", + "- `\"exhaustive\"` is like `\"patient\"`, but considers an even wider range of algorithms, including many that we think are unlikely to be fast, to produce the most optimal plan but with a substantially increased planning time.\n", + "\n", + "````{tip}\n", + "Set the environment variable `TFMRI_FFTW_PLANNING_RIGOR` to control the planning rigor.\n", + "\n", + "```python\n", + "os.environ[\"TFMRI_FFTW_PLANNING_RIGOR\"] = \"estimate\"\n", + "import tensorflow_mri as tfmri\n", + "```\n", + "\n", + "```{attention}\n", + "`TFMRI_FFTW_PLANNING_RIGOR` must be set **before** importing TensorFlow MRI. Setting or changing its value after importing the package will have no effect.\n", + "```\n", + "````\n", + "\n", + "```{note}\n", + "FFTW accumulates \"wisdom\" each time the planner is called, and this wisdom is persisted across invocations of the FFT kernels (during the same process). Therefore, more rigorous planning options will result in long planning times during the first FFT invocation, but may result in faster execution during subsequent invocations. When performing a large amount of similar FFT invocations (e.g., while training a model or performing iterative reconstructions), you are more likely to benefit from more rigorous planning.\n", + "```\n", + "\n", + "```{seealso}\n", + "The FFTW [planner flags](https://www.fftw.org/doc/Planner-Flags.html) documentation page.\n", + "```" ] } ], From 626fc4f750c620b18e8610d8119056c866b095c6 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 31 Aug 2022 12:01:20 +0000 Subject: [PATCH 067/101] Fixed a bug in U-Net --- RELEASE.md | 3 + tensorflow_mri/python/models/conv_endec.py | 146 +++++++++-------- .../python/models/conv_endec_test.py | 150 +++++++++++++++++- 3 files changed, 229 insertions(+), 70 deletions(-) diff --git a/RELEASE.md b/RELEASE.md index 27e818e1..efa88609 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -4,6 +4,9 @@ ## Breaking Changes +- `tfmri.models` + + - `UNet1D`, `UNet2D` and `UNet3D` contain backwards incompatible changes. ## Major Features and Improvements diff --git a/tensorflow_mri/python/models/conv_endec.py b/tensorflow_mri/python/models/conv_endec.py index 5da07080..d578f6d8 100644 --- a/tensorflow_mri/python/models/conv_endec.py +++ b/tensorflow_mri/python/models/conv_endec.py @@ -118,14 +118,14 @@ def __init__(self, dropout_rate=0.3, dropout_type='standard', use_tight_frame=False, - use_resize_and_concatenate=True, + use_resize_and_concatenate=False, **kwargs): """Creates a UNet model.""" super().__init__(**kwargs) + self.rank = rank self._filters = filters self._kernel_size = kernel_size self._pool_size = pool_size - self._rank = rank self._block_depth = block_depth self._use_deconv = use_deconv self._activation = activation @@ -157,7 +157,7 @@ def __init__(self, if use_tight_frame and pool_size != 2: raise ValueError('pool_size must be 2 if use_tight_frame is True.') - block_layer = model_util.get_nd_model('ConvBlock', self._rank) + block_layer = model_util.get_nd_model('ConvBlock', self.rank) block_config = dict( filters=None, # To be filled for each scale. kernel_size=self._kernel_size, @@ -189,28 +189,36 @@ def __init__(self, strides=self._pool_size, padding='same', dtype=self.dtype) - pool_layer = layer_util.get_nd_layer(pool_name, self._rank) + pool_layer = layer_util.get_nd_layer(pool_name, self.rank) # Configure upsampling layer. + upsamp_config = dict( + filters=None, # To be filled for each scale. + kernel_size=self._kernel_size, + pool_size=self._pool_size, + padding='same', + activation=self._activation, + use_bias=self._use_bias, + kernel_initializer=self._kernel_initializer, + bias_initializer=self._bias_initializer, + kernel_regularizer=self._kernel_regularizer, + bias_regularizer=self._bias_regularizer, + dtype=self.dtype) if self._use_deconv: - upsamp_name = 'ConvTranspose' - upsamp_config = dict( - filters=None, # To be filled for each scale. - kernel_size=self._kernel_size, - strides=self._pool_size, - padding='same', - activation=None, - use_bias=self._use_bias, - kernel_initializer=self._kernel_initializer, - bias_initializer=self._bias_initializer, - kernel_regularizer=self._kernel_regularizer, - bias_regularizer=self._bias_regularizer) + # Use transposed convolution for upsampling. + def UpSampling(**config): + config['strides'] = config.pop('pool_size') + return layer_util.get_nd_layer('ConvTranspose', rank)(**config) + upsamp_layer = UpSampling else: - upsamp_name = 'UpSampling' - upsamp_config = dict( - size=self._pool_size, - dtype=self.dtype) - upsamp_layer = layer_util.get_nd_layer(upsamp_name, self._rank) + # Use upsampling + conv for upsampling. + def UpSampling(**config): + pool_size = config.pop('pool_size') + upsamp = layer_util.get_nd_layer('UpSampling', rank)( + size=pool_size, dtype=self.dtype) + conv = layer_util.get_nd_layer('Conv', rank)(**config) + return (upsamp, conv) + upsamp_layer = UpSampling # Configure concatenation layer. if self._use_resize_and_concatenate: @@ -223,47 +231,57 @@ def __init__(self, else: self._channel_axis = 1 - self._enc_blocks = [] - self._dec_blocks = [] - self._pools = [] - self._upsamps = [] - self._concats = [] + self._enc_blocks = [None] * self._scales + self._dec_blocks = [None] * (self._scales - 1) + self._pools = [None] * (self._scales - 1) + self._upsamps = [None] * (self._scales - 1) + self._concats = [None] * (self._scales - 1) if self._use_tight_frame: # For tight frame model, we also need to upsample each of the detail # components. - self._detail_upsamps = [] - - # Configure backbone and decoder. - for scale, filt in enumerate(self._filters): - block_config['filters'] = [filt] * self._block_depth - self._enc_blocks.append(block_layer(**block_config)) - - if scale < len(self._filters) - 1: - self._pools.append(pool_layer(**pool_config)) - if use_deconv: - upsamp_config['filters'] = filt - self._upsamps.append(upsamp_layer(**upsamp_config)) + self._detail_upsamps = [None] * (self._scales - 1) + + # Configure encoder. + for scale, nfilt in enumerate(self._filters): + block_config['filters'] = [nfilt] * self._block_depth + self._enc_blocks[scale] = block_layer(**block_config) + + if scale < len(self._filters) - 1: # Not the last scale. + self._pools[scale] = pool_layer(**pool_config) + + # Configure decoder. + for scale, nfilt in reversed(list(enumerate(self._filters))): + block_config['filters'] = [nfilt] * self._block_depth + + if scale < len(self._filters) - 1: # Not the last scale. + # Add upsampling layer. + # if use_deconv: + upsamp_config['filters'] = nfilt + self._upsamps[scale] = upsamp_layer(**upsamp_config) + # For tight-frame U-Net only. if self._use_tight_frame: # Add one upsampling layer for each detail component. There are 1 # detail components for 1D, 3 detail components for 2D, and 7 detail # components for 3D. - self._detail_upsamps.append([upsamp_layer(**upsamp_config) - for _ in range(2 ** self._rank - 1)]) - self._concats.append(concat_layer(axis=self._channel_axis)) - self._dec_blocks.append(block_layer(**block_config)) + self._detail_upsamps[scale] = [upsamp_layer(**upsamp_config) + for _ in range(2 ** self.rank - 1)] + # Add concatenation layer. + self._concats[scale] = concat_layer(axis=self._channel_axis) + # Add decoding block. + self._dec_blocks[scale] = block_layer(**block_config) # Configure output block. if self._out_channels is not None: block_config['filters'] = self._out_channels - if self._out_kernel_size is not None: - block_config['kernel_size'] = self._out_kernel_size - # If network is residual, the activation is performed after the residual - # addition. - if self._use_global_residual: - block_config['activation'] = None - else: - block_config['activation'] = self._out_activation - self._out_block = block_layer(**block_config) + if self._out_kernel_size is not None: + block_config['kernel_size'] = self._out_kernel_size + # If network is residual, the activation is performed after the residual + # addition. + if self._use_global_residual: + block_config['activation'] = None + else: + block_config['activation'] = self._out_activation + self._out_block = block_layer(**block_config) # Configure residual addition, if requested. if self._use_global_residual: @@ -294,16 +312,18 @@ def call(self, inputs, training=None): # pylint: disable=missing-param-doc,unuse # Decoder. for scale in range(self._scales - 2, -1, -1): - x = self._upsamps[scale](x) - if self._use_resize_and_concatenate: - concat_inputs = [cache[scale], x] + # If not using deconv, `self._upsamps[scale]` is a tuple containing two + # layers (upsampling + conv). + if self._use_deconv: + x = self._upsamps[scale](x) else: - # For backwards compatibility. - concat_inputs = [x, cache[scale]] + x = self._upsamps[scale][0](x) + x = self._upsamps[scale][1](x) + concat_inputs = [cache[scale], x] if self._use_tight_frame: # Upsample detail components too. - d = [up(d) for d, up in zip( - detail_cache[scale], self._detail_upsamps[scale])] + d = [up(d) for d, up in zip(detail_cache[scale], + self._detail_upsamps[scale])] # Add to concatenation. concat_inputs.extend(d) x = self._concats[scale](concat_inputs) @@ -361,16 +381,6 @@ def get_config(self): base_config = super().get_config() return {**base_config, **config} - @classmethod - def from_config(cls, config): - if 'base_filters' in config: - # Old config format. Convert to new format. - config['filters'] = [config.pop('base_filters') * (2 ** scale) - for scale in config.pop('scales')] - if 'use_resize_and_concatenate' not in config: - config['use_resize_and_concatenate'] = False - return super().from_config(config) - @api_util.export("models.UNet1D") @tf.keras.utils.register_keras_serializable(package='MRI') diff --git a/tensorflow_mri/python/models/conv_endec_test.py b/tensorflow_mri/python/models/conv_endec_test.py index 16be81cf..09981112 100644 --- a/tensorflow_mri/python/models/conv_endec_test.py +++ b/tensorflow_mri/python/models/conv_endec_test.py @@ -19,6 +19,7 @@ import tensorflow as tf from tensorflow_mri.python.activations import complex_activations +from tensorflow_mri.python.layers import convolutional from tensorflow_mri.python.models import conv_endec from tensorflow_mri.python.util import test_util @@ -127,14 +128,159 @@ def test_serialize_deserialize(self): use_dropout=True, dropout_rate=0.5, dropout_type='spatial', - use_tight_frame=True) + use_tight_frame=True, + use_instance_norm=False, + use_resize_and_concatenate=False) block = conv_endec.UNet2D(**config) - self.assertEqual(block.get_config(), config) + self.assertEqual(config, block.get_config()) block2 = conv_endec.UNet2D.from_config(block.get_config()) self.assertAllEqual(block.get_config(), block2.get_config()) + def test_architecture(self): + """Tests basic model architecture.""" + tf.keras.backend.clear_session() + + model = conv_endec.UNet2D(filters=[8, 16], kernel_size=3) + inputs = tf.keras.Input(shape=(32, 32, 1), batch_size=1) + model = tf.keras.Model(inputs, model.call(inputs)) + + expected = [ + # name, type, output_shape, params + ('input_1', 'InputLayer', [(1, 32, 32, 1)], 0), + ('conv_block2d', 'ConvBlock2D', (1, 32, 32, 8), 664), + ('max_pooling2d', 'MaxPooling2D', (1, 16, 16, 8), 0), + ('conv_block2d_1', 'ConvBlock2D', (1, 16, 16, 16), 3488), + ('up_sampling2d', 'UpSampling2D', (1, 32, 32, 16), 0), + ('conv2d_4', 'Conv2D', (1, 32, 32, 8), 1160), + ('concatenate', 'Concatenate', (1, 32, 32, 16), 0), + ('conv_block2d_2', 'ConvBlock2D', (1, 32, 32, 8), 1744)] + + self.assertAllEqual( + [elem[0] for elem in expected], + [layer.name for layer in get_layers(model)]) + + self.assertAllEqual( + [elem[1] for elem in expected], + [layer.__class__.__name__ for layer in get_layers(model)]) + + self.assertAllEqual( + [elem[2] for elem in expected], + [layer.output_shape for layer in get_layers(model)]) + + self.assertAllEqual( + [elem[3] for elem in expected], + [layer.count_params() for layer in get_layers(model)]) + + + def test_architecture_with_deconv(self): + """Tests model architecture with deconvolution.""" + tf.keras.backend.clear_session() + + model = conv_endec.UNet2D(filters=[8, 16], kernel_size=3, use_deconv=True) + inputs = tf.keras.Input(shape=(32, 32, 1), batch_size=1) + model = tf.keras.Model(inputs, model.call(inputs)) + + expected = [ + # name, type, output_shape + ('input_1', 'InputLayer', [(1, 32, 32, 1)], 0), + ('conv_block2d', 'ConvBlock2D', (1, 32, 32, 8), 664), + ('max_pooling2d', 'MaxPooling2D', (1, 16, 16, 8), 0), + ('conv_block2d_1', 'ConvBlock2D', (1, 16, 16, 16), 3488), + ('conv2d_transpose', 'Conv2DTranspose', (1, 32, 32, 8), 1160), + ('concatenate', 'Concatenate', (1, 32, 32, 16), 0), + ('conv_block2d_2', 'ConvBlock2D', (1, 32, 32, 8), 1744)] + + self.assertAllEqual( + [elem[0] for elem in expected], + [layer.name for layer in get_layers(model)]) + + self.assertAllEqual( + [elem[1] for elem in expected], + [layer.__class__.__name__ for layer in get_layers(model)]) + + self.assertAllEqual( + [elem[2] for elem in expected], + [layer.output_shape for layer in get_layers(model)]) + + self.assertAllEqual( + [elem[3] for elem in expected], + [layer.count_params() for layer in get_layers(model)]) + + + def test_architecture_with_out_block(self): + """Tests model architecture with output block.""" + tf.keras.backend.clear_session() + + tf.random.set_seed(32) + model = conv_endec.UNet2D(filters=[8, 16], kernel_size=3, out_channels=2) + inputs = tf.keras.Input(shape=(32, 32, 1), batch_size=1) + model = tf.keras.Model(inputs, model.call(inputs)) + + expected = [ + # name, type, output_shape, params + ('input_1', 'InputLayer', [(1, 32, 32, 1)], 0), + ('conv_block2d', 'ConvBlock2D', (1, 32, 32, 8), 664), + ('max_pooling2d', 'MaxPooling2D', (1, 16, 16, 8), 0), + ('conv_block2d_1', 'ConvBlock2D', (1, 16, 16, 16), 3488), + ('up_sampling2d', 'UpSampling2D', (1, 32, 32, 16), 0), + ('conv2d_4', 'Conv2D', (1, 32, 32, 8), 1160), + ('concatenate', 'Concatenate', (1, 32, 32, 16), 0), + ('conv_block2d_2', 'ConvBlock2D', (1, 32, 32, 8), 1744), + ('conv_block2d_3', 'ConvBlock2D', (1, 32, 32, 2), 146)] + + self.assertAllEqual( + [elem[0] for elem in expected], + [layer.name for layer in get_layers(model)]) + + self.assertAllEqual( + [elem[1] for elem in expected], + [layer.__class__.__name__ for layer in get_layers(model)]) + + self.assertAllEqual( + [elem[2] for elem in expected], + [layer.output_shape for layer in get_layers(model)]) + + self.assertAllEqual( + [elem[3] for elem in expected], + [layer.count_params() for layer in get_layers(model)]) + + out_block = model.layers[-1] + self.assertLen(out_block.layers, 1) + self.assertIsInstance(out_block.layers[0], convolutional.Conv2D) + self.assertEqual(tf.keras.activations.linear, + out_block.layers[0].activation) + + input_data = tf.random.stateless_normal((1, 32, 32, 1), [12, 34]) + output_data = model.predict(input_data) + + # New model with activation. + tf.random.set_seed(32) + model = conv_endec.UNet2D( + filters=[8, 16], kernel_size=3, out_channels=2, + out_activation='sigmoid') + inputs = tf.keras.Input(shape=(32, 32, 1), batch_size=1) + model = tf.keras.Model(inputs, model.call(inputs)) + + self.assertAllClose(tf.keras.activations.sigmoid(output_data), + model.predict(input_data)) + + +def get_layers(model, recursive=False): + """Gets all layers in a model (expanding nested models).""" + layers = [] + for layer in model.layers: + if isinstance(layer, tf.keras.Model): + if recursive: + layers.extend(get_layers(layer, recursive=True)) + else: + layers.append(layer) + else: + layers.append(layer) + return layers + + if __name__ == '__main__': tf.test.main() From efe3dc60303628218dbf22c0b6c795e2b6e106ce Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 31 Aug 2022 16:12:13 +0000 Subject: [PATCH 068/101] New recurrent block --- RELEASE.md | 7 + tensorflow_mri/python/models/__init__.py | 2 +- tensorflow_mri/python/models/conv_blocks.py | 323 +++++++++++------- .../python/models/conv_blocks_test.py | 164 ++++++++- ...ph_like_model.py => graph_like_network.py} | 6 +- 5 files changed, 376 insertions(+), 126 deletions(-) rename tensorflow_mri/python/models/{graph_like_model.py => graph_like_network.py} (87%) diff --git a/RELEASE.md b/RELEASE.md index efa88609..136d1416 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -6,6 +6,8 @@ - `tfmri.models` + - `ConvBlock1D`, `ConvBlock2D` and `ConvBlock3D`contain backwards + incompatible changes. - `UNet1D`, `UNet2D` and `UNet3D` contain backwards incompatible changes. @@ -37,6 +39,11 @@ - Added new wrapper layer `Normalized`. +- `tfmri.models`: + + - Added new models `ConvBlockLSTM1D`, `ConvBlockLSTM2D` and `ConvBlockLSTM3D`. + - Added new models `UNetLSTM1D`, `UNetLSTM2D` and `UNetLSTM3D`. + - `tfmri.sampling`: - Added operator `spiral_waveform` to public API. diff --git a/tensorflow_mri/python/models/__init__.py b/tensorflow_mri/python/models/__init__.py index 68d6a4a4..9df91f5a 100644 --- a/tensorflow_mri/python/models/__init__.py +++ b/tensorflow_mri/python/models/__init__.py @@ -16,5 +16,5 @@ from tensorflow_mri.python.models import conv_blocks from tensorflow_mri.python.models import conv_endec -from tensorflow_mri.python.models import graph_like_model +from tensorflow_mri.python.models import graph_like_network from tensorflow_mri.python.models import variational_network diff --git a/tensorflow_mri/python/models/conv_blocks.py b/tensorflow_mri/python/models/conv_blocks.py index 020dc6d1..c3a4a572 100644 --- a/tensorflow_mri/python/models/conv_blocks.py +++ b/tensorflow_mri/python/models/conv_blocks.py @@ -35,22 +35,23 @@ import tensorflow as tf import tensorflow_addons as tfa +from tensorflow_mri.python.models import graph_like_network from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util from tensorflow_mri.python.util import doc_util from tensorflow_mri.python.util import layer_util -CONV_BLOCK_DOC_TEMPLATE = string.Template( +class ConvBlock(graph_like_network.GraphLikeNetwork): """${rank}D convolutional block. - A basic Conv + BN + Activation block. The number of convolutional layers is - determined by `filters`. BN and activation are optional. + A basic Conv + BN + Activation + Dropout block. The number of convolutional + layers is determined by the length of `filters`. BN and activation are + optional. Args: - filters: A list of `int` numbers or an `int` number of filters. Given an - `int` input, a single convolution is applied; otherwise a series of - convolutions are applied. + filters: A `int` or a list of `int`. Given an `int` input, a single + convolution is applied; otherwise a series of convolutions are applied. kernel_size: An integer or tuple/list of `rank` integers, specifying the size of the convolution window. Can be a single integer to specify the same value for all spatial dimensions. @@ -59,7 +60,7 @@ to specify the same value for all spatial dimensions. activation: A callable or a Keras activation identifier. The activation to use in all layers. Defaults to `'relu'`. - out_activation: A callable or a Keras activation identifier. The activation + output_activation: A callable or a Keras activation identifier. The activation to use in the last layer. Defaults to `'same'`, in which case we use the same activation as in previous layers as defined by `activation`. use_bias: A `boolean`, whether the block's layers use bias vectors. Defaults @@ -77,13 +78,15 @@ use_batch_norm: If `True`, use batch normalization. Defaults to `False`. use_sync_bn: If `True`, use synchronised batch normalization. Defaults to `False`. + use_instance_norm: If `True`, use instance normalization. Defaults to + `False`. bn_momentum: A `float`. Momentum for the moving average in batch normalization. bn_epsilon: A `float`. Small float added to variance to avoid dividing by zero during batch normalization. - use_residual: A `boolean`. If `True`, the input is added to the outputs to + use_residual: A boolean. If `True`, the input is added to the outputs to create a residual learning block. Defaults to `False`. - use_dropout: A `boolean`. If `True`, a dropout layer is inserted after + use_dropout: A boolean. If `True`, a dropout layer is inserted after each activation. Defaults to `False`. dropout_rate: A `float`. The dropout rate. Only relevant if `use_dropout` is `True`. Defaults to 0.3. @@ -92,18 +95,14 @@ maps, whereas spatial dropout drops entire feature maps. Only relevant if `use_dropout` is `True`. Defaults to `'standard'`. **kwargs: Additional keyword arguments to be passed to base class. - """) - - -class ConvBlock(tf.keras.Model): - """Convolutional block (private base class).""" + """ def __init__(self, rank, filters, kernel_size, strides=1, activation='relu', - out_activation='same', + output_activation='same', use_bias=True, kernel_initializer='VarianceScaling', bias_initializer='Zeros', @@ -120,138 +119,193 @@ def __init__(self, dropout_type='standard', **kwargs): """Create a basic convolution block.""" + conv_fn = kwargs.pop('_conv_fn', layer_util.get_nd_layer('Conv', rank)) + conv_kwargs = kwargs.pop('_conv_kwargs', {}) super().__init__(**kwargs) - self._rank = rank - self._filters = [filters] if isinstance(filters, int) else filters - self._kernel_size = kernel_size - self._strides = strides - self._activation = activation - self._out_activation = out_activation - self._use_bias = use_bias - self._kernel_initializer = kernel_initializer - self._bias_initializer = bias_initializer - self._kernel_regularizer = kernel_regularizer - self._bias_regularizer = bias_regularizer - self._use_batch_norm = use_batch_norm - self._use_sync_bn = use_sync_bn - self._use_instance_norm = use_instance_norm - self._bn_momentum = bn_momentum - self._bn_epsilon = bn_epsilon - self._use_residual = use_residual - self._use_dropout = use_dropout - self._dropout_rate = dropout_rate - self._dropout_type = check_util.validate_enum( + self.rank = rank + self.filters = [filters] if isinstance(filters, int) else filters + self.kernel_size = kernel_size + self.strides = strides + self.activation = activation + self.output_activation = output_activation + self.use_bias = use_bias + self.kernel_initializer = kernel_initializer + self.bias_initializer = bias_initializer + self.kernel_regularizer = kernel_regularizer + self.bias_regularizer = bias_regularizer + self.use_batch_norm = use_batch_norm + self.use_sync_bn = use_sync_bn + self.use_instance_norm = use_instance_norm + self.bn_momentum = bn_momentum + self.bn_epsilon = bn_epsilon + self.use_residual = use_residual + self.use_dropout = use_dropout + self.dropout_rate = dropout_rate + self.dropout_type = check_util.validate_enum( dropout_type, {'standard', 'spatial'}, 'dropout_type') - self._num_layers = len(self._filters) if use_batch_norm and use_instance_norm: raise ValueError('Cannot use both batch and instance normalization.') - conv = layer_util.get_nd_layer('Conv', self._rank) - - if self._use_batch_norm: - if self._use_sync_bn: + if self.use_batch_norm: + if self.use_sync_bn: bn = tf.keras.layers.experimental.SyncBatchNormalization else: bn = tf.keras.layers.BatchNormalization - if self._use_dropout: - if self._dropout_type == 'standard': + if self.use_dropout: + if self.dropout_type == 'standard': dropout = tf.keras.layers.Dropout - elif self._dropout_type == 'spatial': - dropout = layer_util.get_nd_layer('SpatialDropout', self._rank) + elif self.dropout_type == 'spatial': + dropout = layer_util.get_nd_layer('SpatialDropout', self.rank) if tf.keras.backend.image_data_format() == 'channels_last': - self._channel_axis = -1 + self.channel_axis = -1 else: - self._channel_axis = 1 - - self._convs = [] - self._norms = [] - self._dropouts = [] - for num_filters in self._filters: - self._convs.append( - conv(filters=num_filters, - kernel_size=self._kernel_size, - strides=self._strides, - padding='same', - data_format=None, - activation=None, - use_bias=self._use_bias, - kernel_initializer=self._kernel_initializer, - bias_initializer=self._bias_initializer, - kernel_regularizer=self._kernel_regularizer, - bias_regularizer=self._bias_regularizer, - dtype=self.dtype)) - if self._use_batch_norm: - self._norms.append( - bn(axis=self._channel_axis, - momentum=self._bn_momentum, - epsilon=self._bn_epsilon)) - if self._use_instance_norm: - self._norms.append(tfa.layers.InstanceNormalization( - axis=self._channel_axis)) - if self._use_dropout: - self._dropouts.append(dropout(rate=self._dropout_rate)) - - self._activation_fn = tf.keras.activations.get(self._activation) - if self._out_activation == 'same': - self._out_activation_fn = self._activation_fn - else: - self._out_activation_fn = tf.keras.activations.get(self._out_activation) + self.channel_axis = 1 - def call(self, inputs, training=None): # pylint: disable=unused-argument, missing-param-doc - """Runs forward pass on the input tensor.""" - x = inputs + conv_kwargs.update(dict( + filters=None, # To be filled during loop below. + kernel_size=self.kernel_size, + strides=self.strides, + padding='same', + data_format=None, + activation=None, + use_bias=self.use_bias, + kernel_initializer=self.kernel_initializer, + bias_initializer=self.bias_initializer, + kernel_regularizer=self.kernel_regularizer, + bias_regularizer=self.bias_regularizer, + dtype=self.dtype)) - for i, (conv, norm, dropout) in enumerate( - itertools.zip_longest(self._convs, self._norms, self._dropouts)): + self._levels = len(self.filters) + self._layers = [] + for level in range(self._levels): # Convolution. - x = conv(x) - # Batch normalization. - if self._use_batch_norm or self._use_instance_norm: - x = norm(x, training=training) + conv_kwargs['filters'] = self.filters[level] + self._layers.append(conv_fn(**conv_kwargs)) + # Normalization. + if self.use_batch_norm: + self._layers.append( + bn(axis=self.channel_axis, + momentum=self.bn_momentum, + epsilon=self.bn_epsilon)) + if self.use_instance_norm: + self._layers.append(tfa.layers.InstanceNormalization( + axis=self.channel_axis)) # Activation. - if i == self._num_layers - 1: # Last layer. - x = self._out_activation_fn(x) + if level == self._levels - 1 and self.output_activation != 'same': + # Last level, and `output_activation` is not the same as `activation`. + self._layers.append( + tf.keras.layers.Activation(self.output_activation)) else: - x = self._activation_fn(x) + self._layers.append( + tf.keras.layers.Activation(self.activation)) # Dropout. - if self._use_dropout: - x = dropout(x, training=training) + if self.use_dropout: + self._layers.append(dropout(rate=self.dropout_rate)) + + # Residual. + if self.use_residual: + self._add = tf.keras.layers.Add() + + def call(self, inputs): # pylint: disable=unused-argument, missing-param-doc + """Runs forward pass on the input tensor.""" + x = inputs + + for layer in self._layers: + x = layer(x) + + if self.use_residual: + x = self._add([x, inputs]) - # Residual connection. - if self._use_residual: - x += inputs return x def get_config(self): """Gets layer configuration.""" config = { - 'filters': self._filters, - 'kernel_size': self._kernel_size, - 'strides': self._strides, - 'activation': self._activation, - 'out_activation': self._out_activation, - 'use_bias': self._use_bias, - 'kernel_initializer': self._kernel_initializer, - 'bias_initializer': self._bias_initializer, - 'kernel_regularizer': self._kernel_regularizer, - 'bias_regularizer': self._bias_regularizer, - 'use_batch_norm': self._use_batch_norm, - 'use_sync_bn': self._use_sync_bn, - 'use_instance_norm': self._use_instance_norm, - 'bn_momentum': self._bn_momentum, - 'bn_epsilon': self._bn_epsilon, - 'use_residual': self._use_residual, - 'use_dropout': self._use_dropout, - 'dropout_rate': self._dropout_rate, - 'dropout_type': self._dropout_type + 'filters': self.filters, + 'kernel_size': self.kernel_size, + 'strides': self.strides, + 'activation': self.activation, + 'output_activation': self.output_activation, + 'use_bias': self.use_bias, + 'kernel_initializer': self.kernel_initializer, + 'bias_initializer': self.bias_initializer, + 'kernel_regularizer': self.kernel_regularizer, + 'bias_regularizer': self.bias_regularizer, + 'use_batch_norm': self.use_batch_norm, + 'use_sync_bn': self.use_sync_bn, + 'use_instance_norm': self.use_instance_norm, + 'bn_momentum': self.bn_momentum, + 'bn_epsilon': self.bn_epsilon, + 'use_residual': self.use_residual, + 'use_dropout': self.use_dropout, + 'dropout_rate': self.dropout_rate, + 'dropout_type': self.dropout_type } base_config = super().get_config() return {**base_config, **config} +class ConvBlockLSTM(ConvBlock): + """${rank}D convolutional LSTM block. + + + Args: + stateful: A boolean. If `True`, the last state for each sample at index `i` + in a batch will be used as initial state for the sample of index `i` in + the following batch. Defaults to `False`. + """ + def __init__(self, + rank, + filters, + kernel_size, + strides=1, + activation='relu', + output_activation='same', + use_bias=True, + kernel_initializer='VarianceScaling', + bias_initializer='Zeros', + kernel_regularizer=None, + bias_regularizer=None, + use_batch_norm=False, + use_sync_bn=False, + use_instance_norm=False, + bn_momentum=0.99, + bn_epsilon=0.001, + use_residual=False, + use_dropout=False, + dropout_rate=0.3, + dropout_type='standard', + stateful=False, + **kwargs): + super().__init__(rank=rank, + filters=filters, + kernel_size=kernel_size, + strides=strides, + activation=activation, + output_activation=output_activation, + use_bias=use_bias, + kernel_initializer=kernel_initializer, + bias_initializer=bias_initializer, + kernel_regularizer=kernel_regularizer, + bias_regularizer=bias_regularizer, + use_batch_norm=use_batch_norm, + use_sync_bn=use_sync_bn, + use_instance_norm=use_instance_norm, + bn_momentum=bn_momentum, + bn_epsilon=bn_epsilon, + use_residual=use_residual, + use_dropout=use_dropout, + dropout_rate=dropout_rate, + dropout_type=dropout_type, + _conv_fn=layer_util.get_nd_layer('ConvLSTM', rank), + _conv_kwargs=dict(stateful=stateful, + return_sequences=True), + **kwargs) + + @api_util.export("models.ConvBlock1D") @tf.keras.utils.register_keras_serializable(package='MRI') class ConvBlock1D(ConvBlock): @@ -273,11 +327,42 @@ def __init__(self, *args, **kwargs): super().__init__(3, *args, **kwargs) -ConvBlock1D.__doc__ = CONV_BLOCK_DOC_TEMPLATE.substitute(rank=1) -ConvBlock2D.__doc__ = CONV_BLOCK_DOC_TEMPLATE.substitute(rank=2) -ConvBlock3D.__doc__ = CONV_BLOCK_DOC_TEMPLATE.substitute(rank=3) +@api_util.export("models.ConvBlockLSTM1D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class ConvBlockLSTM1D(ConvBlockLSTM): + def __init__(self, *args, **kwargs): + super().__init__(1, *args, **kwargs) + + +@api_util.export("models.ConvBlockLSTM2D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class ConvBlockLSTM2D(ConvBlockLSTM): + def __init__(self, *args, **kwargs): + super().__init__(2, *args, **kwargs) + + +@api_util.export("models.ConvBlockLSTM3D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class ConvBlockLSTM3D(ConvBlockLSTM): + def __init__(self, *args, **kwargs): + super().__init__(3, *args, **kwargs) + + +ConvBlock1D.__doc__ = string.Template(ConvBlock.__doc__).substitute(rank=1) +ConvBlock2D.__doc__ = string.Template(ConvBlock.__doc__).substitute(rank=2) +ConvBlock3D.__doc__ = string.Template(ConvBlock.__doc__).substitute(rank=3) ConvBlock1D.__signature__ = doc_util.get_nd_layer_signature(ConvBlock) ConvBlock2D.__signature__ = doc_util.get_nd_layer_signature(ConvBlock) ConvBlock3D.__signature__ = doc_util.get_nd_layer_signature(ConvBlock) + + +ConvBlockLSTM1D.__doc__ = string.Template(ConvBlockLSTM.__doc__).substitute(rank=1) +ConvBlockLSTM2D.__doc__ = string.Template(ConvBlockLSTM.__doc__).substitute(rank=2) +ConvBlockLSTM3D.__doc__ = string.Template(ConvBlockLSTM.__doc__).substitute(rank=3) + + +ConvBlockLSTM1D.__signature__ = doc_util.get_nd_layer_signature(ConvBlockLSTM) +ConvBlockLSTM2D.__signature__ = doc_util.get_nd_layer_signature(ConvBlockLSTM) +ConvBlockLSTM3D.__signature__ = doc_util.get_nd_layer_signature(ConvBlockLSTM) diff --git a/tensorflow_mri/python/models/conv_blocks_test.py b/tensorflow_mri/python/models/conv_blocks_test.py index d4abf345..1e12aa1b 100644 --- a/tensorflow_mri/python/models/conv_blocks_test.py +++ b/tensorflow_mri/python/models/conv_blocks_test.py @@ -18,6 +18,7 @@ import tensorflow as tf from tensorflow_mri.python.activations import complex_activations +from tensorflow_mri.python.layers import convolutional from tensorflow_mri.python.models import conv_blocks from tensorflow_mri.python.util import model_util from tensorflow_mri.python.util import test_util @@ -41,7 +42,6 @@ def test_conv_block_creation(self, rank, filters, kernel_size): # pylint: disabl self.assertAllEqual(features.shape, [1] + [128] * rank + [filters]) - def test_complex_valued(self): inputs = tf.dtypes.complex( tf.random.stateless_normal(shape=(2, 32, 32, 4), seed=[12, 34]), @@ -57,7 +57,6 @@ def test_complex_valued(self): self.assertAllClose((2, 32, 32, 6), result.shape) self.assertDTypeEqual(result, tf.complex64) - def test_serialize_deserialize(self): """Test de/serialization.""" config = dict( @@ -65,7 +64,7 @@ def test_serialize_deserialize(self): kernel_size=3, strides=1, activation='tanh', - out_activation='linear', + output_activation='linear', use_bias=False, kernel_initializer='ones', bias_initializer='ones', @@ -73,6 +72,7 @@ def test_serialize_deserialize(self): bias_regularizer='l1', use_batch_norm=True, use_sync_bn=True, + use_instance_norm=False, bn_momentum=0.98, bn_epsilon=0.002, use_residual=True, @@ -86,6 +86,164 @@ def test_serialize_deserialize(self): block2 = conv_blocks.ConvBlock2D.from_config(block.get_config()) self.assertAllEqual(block2.get_config(), block.get_config()) + def test_arch(self): + tf.keras.backend.clear_session() + inputs = tf.keras.Input(shape=(32, 32, 4)) + model = conv_blocks.ConvBlock2D(filters=16, kernel_size=3).functional(inputs) + + expected = [ + # name, type, output_shape, params + ('input_1', tf.keras.layers.InputLayer, [(None, 32, 32, 4)], 0), + ('conv2d', convolutional.Conv2D, (None, 32, 32, 16), 592), + ('activation', tf.keras.layers.Activation, (None, 32, 32, 16), 0) + ] + self._check_layers(expected, model.layers) + + def test_multilayer(self): + tf.keras.backend.clear_session() + inputs = tf.keras.Input(shape=(32, 32, 4)) + model = conv_blocks.ConvBlock2D(filters=[8, 16], kernel_size=3).functional(inputs) + + expected = [ + # name, type, output_shape, params + ('input_1', tf.keras.layers.InputLayer, [(None, 32, 32, 4)], 0), + ('conv2d', convolutional.Conv2D, (None, 32, 32, 8), 296), + ('activation', tf.keras.layers.Activation, (None, 32, 32, 8), 0), + ('conv2d_1', convolutional.Conv2D, (None, 32, 32, 16), 1168), + ('activation_1', tf.keras.layers.Activation, (None, 32, 32, 16), 0) + ] + self._check_layers(expected, model.layers) + + def test_arch_activation(self): + tf.keras.backend.clear_session() + inputs = tf.keras.Input(shape=(32, 32, 4)) + model = conv_blocks.ConvBlock2D( + filters=16, kernel_size=3, activation='sigmoid').functional(inputs) + + expected = [ + # name, type, output_shape, params + ('input_1', tf.keras.layers.InputLayer, [(None, 32, 32, 4)], 0), + ('conv2d', convolutional.Conv2D, (None, 32, 32, 16), 592), + ('activation', tf.keras.layers.Activation, (None, 32, 32, 16), 0) + ] + self._check_layers(expected, model.layers) + + self.assertEqual(tf.keras.activations.sigmoid, model.layers[-1].activation) + + def test_arch_output_activation(self): + tf.keras.backend.clear_session() + inputs = tf.keras.Input(shape=(32, 32, 4)) + model = conv_blocks.ConvBlock2D( + filters=[8, 16], + kernel_size=5, + activation='relu', + output_activation='tanh').functional(inputs) + + expected = [ + # name, type, output_shape, params + ('input_1', tf.keras.layers.InputLayer, [(None, 32, 32, 4)], 0), + ('conv2d', convolutional.Conv2D, (None, 32, 32, 8), 808), + ('activation', tf.keras.layers.Activation, (None, 32, 32, 8), 0), + ('conv2d_1', convolutional.Conv2D, (None, 32, 32, 16), 3216), + ('activation_1', tf.keras.layers.Activation, (None, 32, 32, 16), 0) + ] + self._check_layers(expected, model.layers) + + self.assertEqual(tf.keras.activations.relu, model.layers[2].activation) + self.assertEqual(tf.keras.activations.tanh, model.layers[4].activation) + + def test_arch_batch_norm(self): + tf.keras.backend.clear_session() + inputs = tf.keras.Input(shape=(32, 32, 4)) + model = conv_blocks.ConvBlock2D( + filters=16, kernel_size=3, use_batch_norm=True).functional(inputs) + + expected = [ + # name, type, output_shape, params + ('input_1', tf.keras.layers.InputLayer, [(None, 32, 32, 4)], 0), + ('conv2d', convolutional.Conv2D, (None, 32, 32, 16), 592), + ('batch_normalization', tf.keras.layers.BatchNormalization, (None, 32, 32, 16), 64), + ('activation', tf.keras.layers.Activation, (None, 32, 32, 16), 0) + ] + self._check_layers(expected, model.layers) + + def test_arch_dropout(self): + tf.keras.backend.clear_session() + inputs = tf.keras.Input(shape=(32, 32, 4)) + model = conv_blocks.ConvBlock2D( + filters=16, kernel_size=3, use_dropout=True).functional(inputs) + + expected = [ + # name, type, output_shape, params + ('input_1', tf.keras.layers.InputLayer, [(None, 32, 32, 4)], 0), + ('conv2d', convolutional.Conv2D, (None, 32, 32, 16), 592), + ('activation', tf.keras.layers.Activation, (None, 32, 32, 16), 0), + ('dropout', tf.keras.layers.Dropout, (None, 32, 32, 16), 0) + ] + self._check_layers(expected, model.layers) + + def _check_layers(self, expected, actual): + actual = [ + (layer.name, type(layer), layer.output_shape, layer.count_params()) + for layer in actual] + self.assertEqual(expected, actual) + + def test_arch_lstm(self): + tf.keras.backend.clear_session() + inputs = tf.keras.Input(shape=(None, 32, 32, 4)) + model = conv_blocks.ConvBlockLSTM2D( + filters=16, kernel_size=3).functional(inputs) + + expected = [ + # name, type, output_shape, params + ('input_1', tf.keras.layers.InputLayer, [(None, None, 32, 32, 4)], 0), + ('conv_lstm2d', tf.keras.layers.ConvLSTM2D, (None, None, 32, 32, 16), 11584), + ('activation', tf.keras.layers.Activation, (None, None, 32, 32, 16), 0), + ] + self._check_layers(expected, model.layers) + + self.assertFalse(model.layers[1].stateful) + + def test_arch_lstm_stateful(self): + tf.keras.backend.clear_session() + inputs = tf.keras.Input(shape=(6, 32, 32, 4), batch_size=2) + model = conv_blocks.ConvBlockLSTM2D( + filters=16, kernel_size=3, stateful=True).functional(inputs) + + expected = [ + # name, type, output_shape, params + ('input_1', tf.keras.layers.InputLayer, [(2, 6, 32, 32, 4)], 0), + ('conv_lstm2d', tf.keras.layers.ConvLSTM2D, (2, 6, 32, 32, 16), 11584), + ('activation', tf.keras.layers.Activation, (2, 6, 32, 32, 16), 0), + ] + self._check_layers(expected, model.layers) + + self.assertTrue(model.layers[1].stateful) + + def test_reset_states(self): + tf.keras.backend.clear_session() + model = conv_blocks.ConvBlockLSTM2D( + filters=16, kernel_size=3, stateful=True) + + input_data = tf.random.stateless_normal((2, 6, 32, 32, 4), [12, 34]) + + # Test subclassed model directly. + _ = model(input_data) + model.reset_states() + + self.assertAllEqual(tf.zeros_like(model.layers[0].states), + model.layers[0].states) + self.assertTrue(model.layers[0].stateful) + + # Test functional model. + model = model.functional(tf.keras.Input(shape=(6, 32, 32, 4), batch_size=2)) + _ = model(input_data) + model.reset_states() + + self.assertAllEqual(tf.zeros_like(model.layers[1].states), + model.layers[1].states) + self.assertTrue(model.layers[1].stateful) + if __name__ == '__main__': tf.test.main() diff --git a/tensorflow_mri/python/models/graph_like_model.py b/tensorflow_mri/python/models/graph_like_network.py similarity index 87% rename from tensorflow_mri/python/models/graph_like_model.py rename to tensorflow_mri/python/models/graph_like_network.py index 3206ba45..e03744cf 100644 --- a/tensorflow_mri/python/models/graph_like_model.py +++ b/tensorflow_mri/python/models/graph_like_network.py @@ -16,12 +16,12 @@ import tensorflow as tf -class GraphLikeModel(tf.keras.Model): +class GraphLikeNetwork(tf.keras.Model): """A model with graph-like structure. Adds a method `functional` that returns a functional model with the same - structure as the current model. Functional models have some advantages over - subclassing as described in + architecture as the current model. Functional models have some advantages + over subclassing as described in https://www.tensorflow.org/guide/keras/functional#when_to_use_the_functional_api. """ def functional(self, inputs): From d40631efc5d673b683257cb49c820b32dd5bdcc5 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 31 Aug 2022 18:54:31 +0000 Subject: [PATCH 069/101] Working on UNetLSTM --- tensorflow_mri/python/models/conv_blocks.py | 115 ++-- .../python/models/conv_blocks_test.py | 12 +- tensorflow_mri/python/models/conv_endec.py | 499 ++++++++++++------ .../python/models/conv_endec_test.py | 79 ++- tensorflow_mri/python/util/model_util.py | 8 +- 5 files changed, 468 insertions(+), 245 deletions(-) diff --git a/tensorflow_mri/python/models/conv_blocks.py b/tensorflow_mri/python/models/conv_blocks.py index c3a4a572..77809543 100644 --- a/tensorflow_mri/python/models/conv_blocks.py +++ b/tensorflow_mri/python/models/conv_blocks.py @@ -42,20 +42,13 @@ from tensorflow_mri.python.util import layer_util -class ConvBlock(graph_like_network.GraphLikeNetwork): - """${rank}D convolutional block. - - A basic Conv + BN + Activation + Dropout block. The number of convolutional - layers is determined by the length of `filters`. BN and activation are - optional. - - Args: - filters: A `int` or a list of `int`. Given an `int` input, a single +ARGS = string.Template(""" + filters: A `int` or a `list` of `int`. Given an `int` input, a single convolution is applied; otherwise a series of convolutions are applied. - kernel_size: An integer or tuple/list of `rank` integers, specifying the + kernel_size: An `int` or `list` of ${rank} `int`s, specifying the size of the convolution window. Can be a single integer to specify the same value for all spatial dimensions. - strides: An integer or tuple/list of `rank` integers, specifying the strides + strides: An `int` or a `list` of ${rank} `int`s, specifying the strides of the convolution along each spatial dimension. Can be a single integer to specify the same value for all spatial dimensions. activation: A callable or a Keras activation identifier. The activation to @@ -67,9 +60,9 @@ class ConvBlock(graph_like_network.GraphLikeNetwork): to `True`. kernel_initializer: A `tf.keras.initializers.Initializer` or a Keras initializer identifier. Initializer for convolutional kernels. Defaults to - `'VarianceScaling'`. + `'variance_scaling'`. bias_initializer: A `tf.keras.initializers.Initializer` or a Keras - initializer identifier. Initializer for bias terms. Defaults to `'Zeros'`. + initializer identifier. Initializer for bias terms. Defaults to `'zeros'`. kernel_regularizer: A `tf.keras.initializers.Regularizer` or a Keras regularizer identifier. Regularizer for convolutional kernels. Defaults to `None`. @@ -94,6 +87,18 @@ class ConvBlock(graph_like_network.GraphLikeNetwork): `'spatial'`. Standard dropout drops individual elements from the feature maps, whereas spatial dropout drops entire feature maps. Only relevant if `use_dropout` is `True`. Defaults to `'standard'`. +""") + + +class ConvBlock(graph_like_network.GraphLikeNetwork): + """${rank}D convolutional block. + + A basic Conv + BN + Activation + Dropout block. The number of convolutional + layers is determined by the length of `filters`. BN and activation are + optional. + + Args: + ${args} **kwargs: Additional keyword arguments to be passed to base class. """ def __init__(self, @@ -104,8 +109,8 @@ def __init__(self, activation='relu', output_activation='same', use_bias=True, - kernel_initializer='VarianceScaling', - bias_initializer='Zeros', + kernel_initializer='variance_scaling', + bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, use_batch_norm=False, @@ -126,13 +131,16 @@ def __init__(self, self.filters = [filters] if isinstance(filters, int) else filters self.kernel_size = kernel_size self.strides = strides - self.activation = activation - self.output_activation = output_activation + self.activation = tf.keras.activations.get(activation) + if output_activation == 'same': + self.output_activation = self.activation + else: + self.output_activation = tf.keras.activations.get(output_activation) self.use_bias = use_bias - self.kernel_initializer = kernel_initializer - self.bias_initializer = bias_initializer - self.kernel_regularizer = kernel_regularizer - self.bias_regularizer = bias_regularizer + self.kernel_initializer = tf.keras.initializers.get(kernel_initializer) + self.bias_initializer = tf.keras.initializers.get(bias_initializer) + self.kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) + self.bias_regularizer = tf.keras.regularizers.get(bias_regularizer) self.use_batch_norm = use_batch_norm self.use_sync_bn = use_sync_bn self.use_instance_norm = use_instance_norm @@ -194,7 +202,7 @@ def __init__(self, self._layers.append(tfa.layers.InstanceNormalization( axis=self.channel_axis)) # Activation. - if level == self._levels - 1 and self.output_activation != 'same': + if level == self._levels - 1: # Last level, and `output_activation` is not the same as `activation`. self._layers.append( tf.keras.layers.Activation(self.output_activation)) @@ -227,13 +235,18 @@ def get_config(self): 'filters': self.filters, 'kernel_size': self.kernel_size, 'strides': self.strides, - 'activation': self.activation, - 'output_activation': self.output_activation, + 'activation': tf.keras.activations.serialize(self.activation), + 'output_activation': tf.keras.activations.serialize( + self.output_activation), 'use_bias': self.use_bias, - 'kernel_initializer': self.kernel_initializer, - 'bias_initializer': self.bias_initializer, - 'kernel_regularizer': self.kernel_regularizer, - 'bias_regularizer': self.bias_regularizer, + 'kernel_initializer': tf.keras.initializers.serialize( + self.kernel_initializer), + 'bias_initializer': tf.keras.initializers.serialize( + self.bias_initializer), + 'kernel_regularizer': tf.keras.regularizers.serialize( + self.kernel_regularizer), + 'bias_regularizer': tf.keras.regularizers.serialize( + self.bias_regularizer), 'use_batch_norm': self.use_batch_norm, 'use_sync_bn': self.use_sync_bn, 'use_instance_norm': self.use_instance_norm, @@ -251,11 +264,14 @@ def get_config(self): class ConvBlockLSTM(ConvBlock): """${rank}D convolutional LSTM block. - Args: + ${args} stateful: A boolean. If `True`, the last state for each sample at index `i` in a batch will be used as initial state for the sample of index `i` in the following batch. Defaults to `False`. + recurrent_regularizer: A `tf.keras.initializers.Regularizer` or a Keras + regularizer identifier. The regularizer applied to the recurrent kernel. + Defaults to `None`. """ def __init__(self, rank, @@ -265,8 +281,8 @@ def __init__(self, activation='relu', output_activation='same', use_bias=True, - kernel_initializer='VarianceScaling', - bias_initializer='Zeros', + kernel_initializer='variance_scaling', + bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, use_batch_norm=False, @@ -279,7 +295,11 @@ def __init__(self, dropout_rate=0.3, dropout_type='standard', stateful=False, + recurrent_regularizer=None, **kwargs): + self.stateful = stateful + self.recurrent_regularizer = tf.keras.regularizers.get( + recurrent_regularizer) super().__init__(rank=rank, filters=filters, kernel_size=kernel_size, @@ -301,10 +321,21 @@ def __init__(self, dropout_rate=dropout_rate, dropout_type=dropout_type, _conv_fn=layer_util.get_nd_layer('ConvLSTM', rank), - _conv_kwargs=dict(stateful=stateful, - return_sequences=True), + _conv_kwargs=dict( + stateful=self.stateful, + recurrent_regularizer=self.recurrent_regularizer, + return_sequences=True), **kwargs) + def get_config(self): + base_config = super().get_config() + config = { + 'stateful': self.stateful, + 'recurrent_regularizer': tf.keras.regularizers.serialize( + self.recurrent_regularizer) + } + return {**base_config, **config} + @api_util.export("models.ConvBlock1D") @tf.keras.utils.register_keras_serializable(package='MRI') @@ -348,9 +379,12 @@ def __init__(self, *args, **kwargs): super().__init__(3, *args, **kwargs) -ConvBlock1D.__doc__ = string.Template(ConvBlock.__doc__).substitute(rank=1) -ConvBlock2D.__doc__ = string.Template(ConvBlock.__doc__).substitute(rank=2) -ConvBlock3D.__doc__ = string.Template(ConvBlock.__doc__).substitute(rank=3) +ConvBlock1D.__doc__ = string.Template(ConvBlock.__doc__).substitute( + rank=1, args=ARGS.substitute(rank=1)) +ConvBlock2D.__doc__ = string.Template(ConvBlock.__doc__).substitute( + rank=2, args=ARGS.substitute(rank=2)) +ConvBlock3D.__doc__ = string.Template(ConvBlock.__doc__).substitute( + rank=3, args=ARGS.substitute(rank=3)) ConvBlock1D.__signature__ = doc_util.get_nd_layer_signature(ConvBlock) @@ -358,9 +392,12 @@ def __init__(self, *args, **kwargs): ConvBlock3D.__signature__ = doc_util.get_nd_layer_signature(ConvBlock) -ConvBlockLSTM1D.__doc__ = string.Template(ConvBlockLSTM.__doc__).substitute(rank=1) -ConvBlockLSTM2D.__doc__ = string.Template(ConvBlockLSTM.__doc__).substitute(rank=2) -ConvBlockLSTM3D.__doc__ = string.Template(ConvBlockLSTM.__doc__).substitute(rank=3) +ConvBlockLSTM1D.__doc__ = string.Template(ConvBlockLSTM.__doc__).substitute( + rank=1, args=ARGS.substitute(rank=1)) +ConvBlockLSTM2D.__doc__ = string.Template(ConvBlockLSTM.__doc__).substitute( + rank=2, args=ARGS.substitute(rank=2)) +ConvBlockLSTM3D.__doc__ = string.Template(ConvBlockLSTM.__doc__).substitute( + rank=3, args=ARGS.substitute(rank=3)) ConvBlockLSTM1D.__signature__ = doc_util.get_nd_layer_signature(ConvBlockLSTM) diff --git a/tensorflow_mri/python/models/conv_blocks_test.py b/tensorflow_mri/python/models/conv_blocks_test.py index 1e12aa1b..2474da9b 100644 --- a/tensorflow_mri/python/models/conv_blocks_test.py +++ b/tensorflow_mri/python/models/conv_blocks_test.py @@ -182,12 +182,6 @@ def test_arch_dropout(self): ] self._check_layers(expected, model.layers) - def _check_layers(self, expected, actual): - actual = [ - (layer.name, type(layer), layer.output_shape, layer.count_params()) - for layer in actual] - self.assertEqual(expected, actual) - def test_arch_lstm(self): tf.keras.backend.clear_session() inputs = tf.keras.Input(shape=(None, 32, 32, 4)) @@ -244,6 +238,12 @@ def test_reset_states(self): model.layers[1].states) self.assertTrue(model.layers[1].stateful) + def _check_layers(self, expected, actual): + actual = [ + (layer.name, type(layer), layer.output_shape, layer.count_params()) + for layer in actual] + self.assertEqual(expected, actual) + if __name__ == '__main__': tf.test.main() diff --git a/tensorflow_mri/python/models/conv_endec.py b/tensorflow_mri/python/models/conv_endec.py index d578f6d8..16200344 100644 --- a/tensorflow_mri/python/models/conv_endec.py +++ b/tensorflow_mri/python/models/conv_endec.py @@ -26,13 +26,10 @@ from tensorflow_mri.python.util import layer_util -class UNet(tf.keras.Model): - """${rank}D U-Net model. - - Args: +ARGS = string.Template(""" filters: A `list` of `int`. The number of filters for convolutional layers at each scale. The number of scales is inferred as `len(filters)`. - kernel_size: An integer or tuple/list of ${rank} integers, specifying the + kernel_size: An `int` or a `list` of ${rank} `int`s, specifying the size of the convolution window. Can be a single integer to specify the same value for all spatial dimensions. pool_size: The pooling size for the pooling operations. Defaults to 2. @@ -45,9 +42,9 @@ class UNet(tf.keras.Model): `'relu'`. kernel_initializer: A `tf.keras.initializers.Initializer` or a Keras initializer identifier. Initializer for convolutional kernels. Defaults to - `'VarianceScaling'`. + `'variance_scaling'`. bias_initializer: A `tf.keras.initializers.Initializer` or a Keras - initializer identifier. Initializer for bias terms. Defaults to `'Zeros'`. + initializer identifier. Initializer for bias terms. Defaults to `'zeros'`. kernel_regularizer: A `tf.keras.initializers.Regularizer` or a Keras regularizer identifier. Regularizer for convolutional kernels. Defaults to `None`. @@ -60,10 +57,10 @@ class UNet(tf.keras.Model): normalization. bn_epsilon: A `float`. Small float added to variance to avoid dividing by zero during batch normalization. - out_channels: An `int`. The number of output channels. - out_kernel_size: An `int` or a list of ${rank} `int`. The size of the + output_filters: An `int`. The number of output channels. + output_kernel_size: An `int` or a `list` of ${rank} `int`s. The size of the convolutional kernel for the output layer. Defaults to `kernel_size`. - out_activation: A callable or a Keras activation identifier. The output + output_activation: A callable or a Keras activation identifier. The output activation. Defaults to `None`. use_global_residual: A `boolean`. If `True`, adds a global residual connection to create a residual learning network. Defaults to `False`. @@ -81,16 +78,28 @@ class UNet(tf.keras.Model): maps are resized (by cropping) to match the shape of the incoming skip connection prior to concatenation. This enables more flexible input shapes. Defaults to `True`. +""") + + +class UNet(tf.keras.Model): + """${rank}D U-Net model. + + Args: + ${args} **kwargs: Additional keyword arguments to be passed to base class. References: - .. [1] Ronneberger, O., Fischer, P., & Brox, T. (2015, October). U-net: - Convolutional networks for biomedical image segmentation. In International - Conference on Medical image computing and computer-assisted intervention - (pp. 234-241). Springer, Cham. - .. [2] Han, Y., & Ye, J. C. (2018). Framing U-Net via deep convolutional - framelets: Application to sparse-view CT. IEEE transactions on medical - imaging, 37(6), 1418-1429. + 1. Ronneberger, O., Fischer, P., & Brox, T. (2015, October). U-net: + Convolutional networks for biomedical image segmentation. In + International Conference on Medical image computing and computer-assisted + intervention (pp. 234-241). Springer, Cham. + 2. Han, Y., & Ye, J. C. (2018). Framing U-Net via deep convolutional + framelets: Application to sparse-view CT. IEEE transactions on medical + imaging, 37(6), 1418-1429. + 3. Hauptmann, A., Arridge, S., Lucka, F., Muthurangu, V., & Steeden, J. A. + (2019). Real-time cardiovascular MR with spatio-temporal artifact + suppression using deep learning-proof of concept in congenital heart + disease. Magnetic resonance in medicine, 81(2), 1143-1156. """ def __init__(self, rank, @@ -101,8 +110,8 @@ def __init__(self, use_deconv=False, activation='relu', use_bias=True, - kernel_initializer='VarianceScaling', - bias_initializer='Zeros', + kernel_initializer='variance_scaling', + bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, use_batch_norm=False, @@ -110,9 +119,9 @@ def __init__(self, use_instance_norm=False, bn_momentum=0.99, bn_epsilon=0.001, - out_channels=None, - out_kernel_size=None, - out_activation=None, + output_filters=None, + output_kernel_size=None, + output_activation=None, use_global_residual=False, use_dropout=False, dropout_rate=0.3, @@ -120,188 +129,197 @@ def __init__(self, use_tight_frame=False, use_resize_and_concatenate=False, **kwargs): - """Creates a UNet model.""" + block_fn = kwargs.pop( + '_block_fn', model_util.get_nd_model('ConvBlock', rank)) + block_kwargs = kwargs.pop('_block_kwargs', {}) + is_time_distributed = kwargs.pop('_is_time_distributed', False) super().__init__(**kwargs) self.rank = rank - self._filters = filters - self._kernel_size = kernel_size - self._pool_size = pool_size - self._block_depth = block_depth - self._use_deconv = use_deconv - self._activation = activation - self._use_bias = use_bias - self._kernel_initializer = kernel_initializer - self._bias_initializer = bias_initializer - self._kernel_regularizer = kernel_regularizer - self._bias_regularizer = bias_regularizer - self._use_batch_norm = use_batch_norm - self._use_sync_bn = use_sync_bn - self._use_instance_norm = use_instance_norm - self._bn_momentum = bn_momentum - self._bn_epsilon = bn_epsilon - self._out_channels = out_channels - self._out_kernel_size = out_kernel_size - self._out_activation = out_activation - self._use_global_residual = use_global_residual - self._use_dropout = use_dropout - self._dropout_rate = dropout_rate - self._dropout_type = check_util.validate_enum( + self.filters = filters + self.kernel_size = kernel_size + self.pool_size = pool_size + self.block_depth = block_depth + self.use_deconv = use_deconv + self.activation = activation + self.use_bias = use_bias + self.kernel_initializer = kernel_initializer + self.bias_initializer = bias_initializer + self.kernel_regularizer = kernel_regularizer + self.bias_regularizer = bias_regularizer + self.use_batch_norm = use_batch_norm + self.use_sync_bn = use_sync_bn + self.use_instance_norm = use_instance_norm + self.bn_momentum = bn_momentum + self.bn_epsilon = bn_epsilon + self.output_filters = output_filters + self.output_kernel_size = output_kernel_size + self.output_activation = output_activation + self.use_global_residual = use_global_residual + self.use_dropout = use_dropout + self.dropout_rate = dropout_rate + self.dropout_type = check_util.validate_enum( dropout_type, {'standard', 'spatial'}, 'dropout_type') - self._use_tight_frame = use_tight_frame - self._use_resize_and_concatenate = use_resize_and_concatenate - self._dwt_kwargs = {} - self._dwt_kwargs['format_dict'] = False - self._scales = len(filters) + self.use_tight_frame = use_tight_frame + self.use_resize_and_concatenate = use_resize_and_concatenate + + self.scales = len(self.filters) # Check inputs are consistent. if use_tight_frame and pool_size != 2: raise ValueError('pool_size must be 2 if use_tight_frame is True.') - block_layer = model_util.get_nd_model('ConvBlock', self.rank) - block_config = dict( + block_kwargs.update(dict( filters=None, # To be filled for each scale. - kernel_size=self._kernel_size, + kernel_size=self.kernel_size, strides=1, - activation=self._activation, - use_bias=self._use_bias, - kernel_initializer=self._kernel_initializer, - bias_initializer=self._bias_initializer, - kernel_regularizer=self._kernel_regularizer, - bias_regularizer=self._bias_regularizer, - use_batch_norm=self._use_batch_norm, - use_sync_bn=self._use_sync_bn, - use_instance_norm=self._use_instance_norm, - bn_momentum=self._bn_momentum, - bn_epsilon=self._bn_epsilon, - use_dropout=self._use_dropout, - dropout_rate=self._dropout_rate, - dropout_type=self._dropout_type, - dtype=self.dtype) + activation=self.activation, + use_bias=self.use_bias, + kernel_initializer=self.kernel_initializer, + bias_initializer=self.bias_initializer, + kernel_regularizer=self.kernel_regularizer, + bias_regularizer=self.bias_regularizer, + use_batch_norm=self.use_batch_norm, + use_sync_bn=self.use_sync_bn, + use_instance_norm=self.use_instance_norm, + bn_momentum=self.bn_momentum, + bn_epsilon=self.bn_epsilon, + use_dropout=self.use_dropout, + dropout_rate=self.dropout_rate, + dropout_type=self.dropout_type, + dtype=self.dtype)) # Configure pooling layer. - if self._use_tight_frame: + if self.use_tight_frame: pool_name = 'DWT' - pool_config = self._dwt_kwargs + pool_config = dict(format_dict=False) else: pool_name = 'MaxPool' pool_config = dict( - pool_size=self._pool_size, - strides=self._pool_size, + pool_size=self.pool_size, + strides=self.pool_size, padding='same', dtype=self.dtype) - pool_layer = layer_util.get_nd_layer(pool_name, self.rank) + pool_fn = layer_util.get_nd_layer(pool_name, self.rank) + if is_time_distributed: + pool_fn = wrap_time_distributed(pool_fn) # Configure upsampling layer. upsamp_config = dict( filters=None, # To be filled for each scale. - kernel_size=self._kernel_size, - pool_size=self._pool_size, + kernel_size=self.kernel_size, + pool_size=self.pool_size, padding='same', - activation=self._activation, - use_bias=self._use_bias, - kernel_initializer=self._kernel_initializer, - bias_initializer=self._bias_initializer, - kernel_regularizer=self._kernel_regularizer, - bias_regularizer=self._bias_regularizer, + activation=self.activation, + use_bias=self.use_bias, + kernel_initializer=self.kernel_initializer, + bias_initializer=self.bias_initializer, + kernel_regularizer=self.kernel_regularizer, + bias_regularizer=self.bias_regularizer, dtype=self.dtype) - if self._use_deconv: + if self.use_deconv: # Use transposed convolution for upsampling. - def UpSampling(**config): + def upsamp_fn(**config): config['strides'] = config.pop('pool_size') - return layer_util.get_nd_layer('ConvTranspose', rank)(**config) - upsamp_layer = UpSampling + convt_fn = layer_util.get_nd_layer('ConvTranspose', self.rank) + if is_time_distributed: + convt_fn = wrap_time_distributed(convt_fn) + return convt_fn(**config) else: # Use upsampling + conv for upsampling. - def UpSampling(**config): + def upsamp_fn(**config): pool_size = config.pop('pool_size') - upsamp = layer_util.get_nd_layer('UpSampling', rank)( - size=pool_size, dtype=self.dtype) - conv = layer_util.get_nd_layer('Conv', rank)(**config) - return (upsamp, conv) - upsamp_layer = UpSampling + upsamp_fn_ = layer_util.get_nd_layer('UpSampling', rank) + conv_fn = layer_util.get_nd_layer('Conv', rank) + + if is_time_distributed: + upsamp_fn_ = wrap_time_distributed(upsamp_fn_) + conv_fn = wrap_time_distributed(conv_fn) + + upsamp_layer = upsamp_fn_(size=pool_size, dtype=self.dtype) + conv_layer = conv_fn(**config) + return (upsamp_layer, conv_layer) # Configure concatenation layer. - if self._use_resize_and_concatenate: - concat_layer = concatenate.ResizeAndConcatenate + if self.use_resize_and_concatenate: + concat_fn = concatenate.ResizeAndConcatenate else: - concat_layer = tf.keras.layers.Concatenate + concat_fn = tf.keras.layers.Concatenate if tf.keras.backend.image_data_format() == 'channels_last': - self._channel_axis = -1 + self.channel_axis = -1 else: - self._channel_axis = 1 - - self._enc_blocks = [None] * self._scales - self._dec_blocks = [None] * (self._scales - 1) - self._pools = [None] * (self._scales - 1) - self._upsamps = [None] * (self._scales - 1) - self._concats = [None] * (self._scales - 1) - if self._use_tight_frame: + self.channel_axis = 1 + + self._enc_blocks = [None] * self.scales + self._dec_blocks = [None] * (self.scales - 1) + self._pools = [None] * (self.scales - 1) + self._upsamps = [None] * (self.scales - 1) + self._concats = [None] * (self.scales - 1) + if self.use_tight_frame: # For tight frame model, we also need to upsample each of the detail # components. - self._detail_upsamps = [None] * (self._scales - 1) + self._detail_upsamps = [None] * (self.scales - 1) # Configure encoder. - for scale, nfilt in enumerate(self._filters): - block_config['filters'] = [nfilt] * self._block_depth - self._enc_blocks[scale] = block_layer(**block_config) + for scale in range(self.scales): + block_kwargs['filters'] = [filters[scale]] * self.block_depth + self._enc_blocks[scale] = block_fn(**block_kwargs) - if scale < len(self._filters) - 1: # Not the last scale. - self._pools[scale] = pool_layer(**pool_config) + if scale < len(self.filters) - 1: # Not the last scale. + self._pools[scale] = pool_fn(**pool_config) # Configure decoder. - for scale, nfilt in reversed(list(enumerate(self._filters))): - block_config['filters'] = [nfilt] * self._block_depth + for scale in range(self.scales - 2, -1, -1): + block_kwargs['filters'] = [filters[scale]] * self.block_depth - if scale < len(self._filters) - 1: # Not the last scale. + if scale < len(self.filters) - 1: # Not the last scale. # Add upsampling layer. - # if use_deconv: - upsamp_config['filters'] = nfilt - self._upsamps[scale] = upsamp_layer(**upsamp_config) + upsamp_config['filters'] = filters[scale] + self._upsamps[scale] = upsamp_fn(**upsamp_config) # For tight-frame U-Net only. - if self._use_tight_frame: + if self.use_tight_frame: # Add one upsampling layer for each detail component. There are 1 # detail components for 1D, 3 detail components for 2D, and 7 detail # components for 3D. - self._detail_upsamps[scale] = [upsamp_layer(**upsamp_config) + self._detail_upsamps[scale] = [upsamp_fn(**upsamp_config) for _ in range(2 ** self.rank - 1)] # Add concatenation layer. - self._concats[scale] = concat_layer(axis=self._channel_axis) + self._concats[scale] = concat_fn(axis=self.channel_axis) # Add decoding block. - self._dec_blocks[scale] = block_layer(**block_config) + self._dec_blocks[scale] = block_fn(**block_kwargs) # Configure output block. - if self._out_channels is not None: - block_config['filters'] = self._out_channels - if self._out_kernel_size is not None: - block_config['kernel_size'] = self._out_kernel_size + if self.output_filters is not None: + block_kwargs['filters'] = self.output_filters + if self.output_kernel_size is not None: + block_kwargs['kernel_size'] = self.output_kernel_size # If network is residual, the activation is performed after the residual # addition. - if self._use_global_residual: - block_config['activation'] = None + if self.use_global_residual: + block_kwargs['activation'] = None else: - block_config['activation'] = self._out_activation - self._out_block = block_layer(**block_config) + block_kwargs['activation'] = self.output_activation + self._out_block = block_fn(**block_kwargs) # Configure residual addition, if requested. - if self._use_global_residual: + if self.use_global_residual: self._add = tf.keras.layers.Add() - self._out_activation_fn = tf.keras.activations.get(self._out_activation) + self._out_activation = tf.keras.layers.Activation(self.output_activation) - def call(self, inputs, training=None): # pylint: disable=missing-param-doc,unused-argument + def call(self, inputs): # pylint: disable=missing-param-doc """Runs forward pass on the input tensors.""" x = inputs # For skip connections to decoder. - cache = [None] * (self._scales - 1) - if self._use_tight_frame: - detail_cache = [None] * (self._scales - 1) + cache = [None] * (self.scales - 1) + if self.use_tight_frame: + detail_cache = [None] * (self.scales - 1) # Backbone. - for scale in range(self._scales - 1): + for scale in range(self.scales - 1): cache[scale] = self._enc_blocks[scale](x) x = self._pools[scale](cache[scale]) - if self._use_tight_frame: + if self.use_tight_frame: # Store details for later concatenation, and continue processing # approximation coefficients. detail_cache[scale] = x[1:] # details @@ -311,16 +329,16 @@ def call(self, inputs, training=None): # pylint: disable=missing-param-doc,unuse x = self._enc_blocks[-1](x) # Decoder. - for scale in range(self._scales - 2, -1, -1): - # If not using deconv, `self._upsamps[scale]` is a tuple containing two + for scale in range(self.scales - 2, -1, -1): + # If not using deconv, `self.upsamps[scale]` is a tuple containing two # layers (upsampling + conv). - if self._use_deconv: + if self.use_deconv: x = self._upsamps[scale](x) else: x = self._upsamps[scale][0](x) x = self._upsamps[scale][1](x) concat_inputs = [cache[scale], x] - if self._use_tight_frame: + if self.use_tight_frame: # Upsample detail components too. d = [up(d) for d, up in zip(detail_cache[scale], self._detail_upsamps[scale])] @@ -330,58 +348,150 @@ def call(self, inputs, training=None): # pylint: disable=missing-param-doc,unuse x = self._dec_blocks[scale](x) # Head. - if self._out_channels is not None: + if self.output_filters is not None: x = self._out_block(x) # Global residual connection. - if self._use_global_residual: + if self.use_global_residual: x = self._add([x, inputs]) - if self._out_activation is not None: - x = self._out_activation_fn(x) + if self.output_activation is not None: + x = self._out_activation(x) return x def compute_output_shape(self, input_shape): input_shape = tf.TensorShape(input_shape) - if self._out_channels is not None: - out_channels = self._out_channels + if self.output_filters is not None: + output_filters = self.output_filters else: - out_channels = self._filters[0] - return input_shape[:-1].concatenate([out_channels]) + output_filters = self.filters[0] + return input_shape[:-1].concatenate([output_filters]) def get_config(self): """Returns model configuration for serialization.""" config = { - 'filters': self._filters, - 'kernel_size': self._kernel_size, - 'pool_size': self._pool_size, - 'block_depth': self._block_depth, - 'use_deconv': self._use_deconv, - 'activation': self._activation, - 'use_bias': self._use_bias, - 'kernel_initializer': self._kernel_initializer, - 'bias_initializer': self._bias_initializer, - 'kernel_regularizer': self._kernel_regularizer, - 'bias_regularizer': self._bias_regularizer, - 'use_batch_norm': self._use_batch_norm, - 'use_sync_bn': self._use_sync_bn, - 'use_instance_norm': self._use_instance_norm, - 'bn_momentum': self._bn_momentum, - 'bn_epsilon': self._bn_epsilon, - 'out_channels': self._out_channels, - 'out_kernel_size': self._out_kernel_size, - 'out_activation': self._out_activation, - 'use_global_residual': self._use_global_residual, - 'use_dropout': self._use_dropout, - 'dropout_rate': self._dropout_rate, - 'dropout_type': self._dropout_type, - 'use_tight_frame': self._use_tight_frame, - 'use_resize_and_concatenate': self._use_resize_and_concatenate + 'filters': self.filters, + 'kernel_size': self.kernel_size, + 'pool_size': self.pool_size, + 'block_depth': self.block_depth, + 'use_deconv': self.use_deconv, + 'activation': self.activation, + 'use_bias': self.use_bias, + 'kernel_initializer': self.kernel_initializer, + 'bias_initializer': self.bias_initializer, + 'kernel_regularizer': self.kernel_regularizer, + 'bias_regularizer': self.bias_regularizer, + 'use_batch_norm': self.use_batch_norm, + 'use_sync_bn': self.use_sync_bn, + 'use_instance_norm': self.use_instance_norm, + 'bn_momentum': self.bn_momentum, + 'bn_epsilon': self.bn_epsilon, + 'output_filters': self.output_filters, + 'output_kernel_size': self.output_kernel_size, + 'output_activation': self.output_activation, + 'use_global_residual': self.use_global_residual, + 'use_dropout': self.use_dropout, + 'dropout_rate': self.dropout_rate, + 'dropout_type': self.dropout_type, + 'use_tight_frame': self.use_tight_frame, + 'use_resize_and_concatenate': self.use_resize_and_concatenate } base_config = super().get_config() return {**base_config, **config} +class UNetLSTM(UNet): + """${rank}D LSTM U-Net model. + + Args: + ${args} + stateful: A boolean. If `True`, the last state for each sample at index `i` + in a batch will be used as initial state for the sample of index `i` in + the following batch. Defaults to `False`. + recurrent_regularizer: A `tf.keras.initializers.Regularizer` or a Keras + regularizer identifier. The regularizer applied to the recurrent kernel. + Defaults to `None`. + """ + def __init__(self, + rank, + filters, + kernel_size, + pool_size=2, + block_depth=2, + use_deconv=False, + activation='relu', + use_bias=True, + kernel_initializer='variance_scaling', + bias_initializer='zeros', + kernel_regularizer=None, + bias_regularizer=None, + use_batch_norm=False, + use_sync_bn=False, + use_instance_norm=False, + bn_momentum=0.99, + bn_epsilon=0.001, + output_filters=None, + output_kernel_size=None, + output_activation=None, + use_global_residual=False, + use_dropout=False, + dropout_rate=0.3, + dropout_type='standard', + use_tight_frame=False, + use_resize_and_concatenate=False, + stateful=False, + recurrent_regularizer=None, + **kwargs): + self.stateful = stateful + self.recurrent_regularizer = tf.keras.regularizers.get(recurrent_regularizer) + super().__init__(rank=rank, + filters=filters, + kernel_size=kernel_size, + pool_size=pool_size, + block_depth=block_depth, + use_deconv=use_deconv, + activation=activation, + use_bias=use_bias, + kernel_initializer=kernel_initializer, + bias_initializer=bias_initializer, + kernel_regularizer=kernel_regularizer, + bias_regularizer=bias_regularizer, + use_batch_norm=use_batch_norm, + use_sync_bn=use_sync_bn, + use_instance_norm=use_instance_norm, + bn_momentum=bn_momentum, + bn_epsilon=bn_epsilon, + output_filters=output_filters, + output_kernel_size=output_kernel_size, + output_activation=output_activation, + use_global_residual=use_global_residual, + use_dropout=use_dropout, + dropout_rate=dropout_rate, + dropout_type=dropout_type, + use_tight_frame=use_tight_frame, + use_resize_and_concatenate=use_resize_and_concatenate, + _block_fn=model_util.get_nd_model('ConvBlockLSTM', rank), + _block_kwargs=dict( + stateful=self.stateful, + recurrent_regularizer=self.recurrent_regularizer), + _is_time_distributed=True, + **kwargs) + + def get_config(self): + base_config = super().get_config() + config = { + 'stateful': self.stateful, + 'recurrent_regularizer': tf.keras.regularizers.serialize( + self.recurrent_regularizer) + } + return {**base_config, **config} + + +def wrap_time_distributed(fn): + return lambda *args, **kwargs: ( + tf.keras.layers.TimeDistributed(fn(*args, **kwargs))) + + @api_util.export("models.UNet1D") @tf.keras.utils.register_keras_serializable(package='MRI') class UNet1D(UNet): @@ -403,11 +513,48 @@ def __init__(self, *args, **kwargs): super().__init__(3, *args, **kwargs) -UNet1D.__doc__ = string.Template(UNet.__doc__).substitute(rank=1) -UNet2D.__doc__ = string.Template(UNet.__doc__).substitute(rank=2) -UNet3D.__doc__ = string.Template(UNet.__doc__).substitute(rank=3) +@api_util.export("models.UNetLSTM1D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class UNetLSTM1D(UNetLSTM): + def __init__(self, *args, **kwargs): + super().__init__(1, *args, **kwargs) + + +@api_util.export("models.UNetLSTM2D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class UNetLSTM2D(UNetLSTM): + def __init__(self, *args, **kwargs): + super().__init__(2, *args, **kwargs) + + +@api_util.export("models.UNetLSTM3D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class UNetLSTM3D(UNetLSTM): + def __init__(self, *args, **kwargs): + super().__init__(3, *args, **kwargs) + + +UNet1D.__doc__ = string.Template(UNet.__doc__).substitute( + rank=1, args=ARGS.substitute(rank=1)) +UNet2D.__doc__ = string.Template(UNet.__doc__).substitute( + rank=2, args=ARGS.substitute(rank=2)) +UNet3D.__doc__ = string.Template(UNet.__doc__).substitute( + rank=3, args=ARGS.substitute(rank=3)) UNet1D.__signature__ = doc_util.get_nd_layer_signature(UNet) UNet2D.__signature__ = doc_util.get_nd_layer_signature(UNet) UNet3D.__signature__ = doc_util.get_nd_layer_signature(UNet) + + +UNetLSTM1D.__doc__ = string.Template(UNetLSTM.__doc__).substitute( + rank=1, args=ARGS.substitute(rank=1)) +UNetLSTM2D.__doc__ = string.Template(UNetLSTM.__doc__).substitute( + rank=2, args=ARGS.substitute(rank=2)) +UNetLSTM3D.__doc__ = string.Template(UNetLSTM.__doc__).substitute( + rank=3, args=ARGS.substitute(rank=3)) + + +UNetLSTM1D.__signature__ = doc_util.get_nd_layer_signature(UNetLSTM) +UNetLSTM2D.__signature__ = doc_util.get_nd_layer_signature(UNetLSTM) +UNetLSTM3D.__signature__ = doc_util.get_nd_layer_signature(UNetLSTM) diff --git a/tensorflow_mri/python/models/conv_endec_test.py b/tensorflow_mri/python/models/conv_endec_test.py index 09981112..9d0ab8aa 100644 --- a/tensorflow_mri/python/models/conv_endec_test.py +++ b/tensorflow_mri/python/models/conv_endec_test.py @@ -20,6 +20,9 @@ from tensorflow_mri.python.activations import complex_activations from tensorflow_mri.python.layers import convolutional +from tensorflow_mri.python.layers import pooling +from tensorflow_mri.python.layers import reshaping +from tensorflow_mri.python.models import conv_blocks from tensorflow_mri.python.models import conv_endec from tensorflow_mri.python.util import test_util @@ -37,7 +40,7 @@ def test_unet_creation(self, # pylint: disable=missing-param-doc rank, filters, kernel_size, - out_channels, + output_filters, use_deconv, use_global_residual): """Test object creation.""" @@ -53,14 +56,14 @@ def test_unet_creation(self, # pylint: disable=missing-param-doc filters=filters, kernel_size=kernel_size, use_deconv=use_deconv, - out_channels=out_channels, + output_filters=output_filters, use_global_residual=use_global_residual) features = network(inputs) - if out_channels is None: - out_channels = filters[0] + if output_filters is None: + output_filters = filters[0] - self.assertAllEqual(features.shape, [1] + [128] * rank + [out_channels]) + self.assertAllEqual(features.shape, [1] + [128] * rank + [output_filters]) @test_util.run_all_execution_modes @@ -121,9 +124,9 @@ def test_serialize_deserialize(self): use_sync_bn=True, bn_momentum=0.98, bn_epsilon=0.002, - out_channels=1, - out_kernel_size=1, - out_activation='relu', + output_filters=1, + output_kernel_size=1, + output_activation='relu', use_global_residual=True, use_dropout=True, dropout_rate=0.5, @@ -138,9 +141,8 @@ def test_serialize_deserialize(self): block2 = conv_endec.UNet2D.from_config(block.get_config()) self.assertAllEqual(block.get_config(), block2.get_config()) - - def test_architecture(self): - """Tests basic model architecture.""" + def test_arch(self): + """Tests basic model arch.""" tf.keras.backend.clear_session() model = conv_endec.UNet2D(filters=[8, 16], kernel_size=3) @@ -174,9 +176,8 @@ def test_architecture(self): [elem[3] for elem in expected], [layer.count_params() for layer in get_layers(model)]) - - def test_architecture_with_deconv(self): - """Tests model architecture with deconvolution.""" + def test_arch_with_deconv(self): + """Tests model arch with deconvolution.""" tf.keras.backend.clear_session() model = conv_endec.UNet2D(filters=[8, 16], kernel_size=3, use_deconv=True) @@ -209,13 +210,12 @@ def test_architecture_with_deconv(self): [elem[3] for elem in expected], [layer.count_params() for layer in get_layers(model)]) - - def test_architecture_with_out_block(self): - """Tests model architecture with output block.""" + def test_arch_with_out_block(self): + """Tests model arch with output block.""" tf.keras.backend.clear_session() tf.random.set_seed(32) - model = conv_endec.UNet2D(filters=[8, 16], kernel_size=3, out_channels=2) + model = conv_endec.UNet2D(filters=[8, 16], kernel_size=3, output_filters=2) inputs = tf.keras.Input(shape=(32, 32, 1), batch_size=1) model = tf.keras.Model(inputs, model.call(inputs)) @@ -248,25 +248,58 @@ def test_architecture_with_out_block(self): [layer.count_params() for layer in get_layers(model)]) out_block = model.layers[-1] - self.assertLen(out_block.layers, 1) + self.assertLen(out_block.layers, 2) self.assertIsInstance(out_block.layers[0], convolutional.Conv2D) + self.assertIsInstance(out_block.layers[1], tf.keras.layers.Activation) self.assertEqual(tf.keras.activations.linear, - out_block.layers[0].activation) + out_block.layers[1].activation) input_data = tf.random.stateless_normal((1, 32, 32, 1), [12, 34]) output_data = model.predict(input_data) - # New model with activation. + # New model with output activation. tf.random.set_seed(32) model = conv_endec.UNet2D( - filters=[8, 16], kernel_size=3, out_channels=2, - out_activation='sigmoid') + filters=[8, 16], kernel_size=3, output_filters=2, + output_activation='sigmoid') inputs = tf.keras.Input(shape=(32, 32, 1), batch_size=1) model = tf.keras.Model(inputs, model.call(inputs)) self.assertAllClose(tf.keras.activations.sigmoid(output_data), model.predict(input_data)) + def test_arch_lstm(self): + """Tests LSTM model arch.""" + tf.keras.backend.clear_session() + + model = conv_endec.UNetLSTM2D(filters=[8, 16], kernel_size=3) + inputs = tf.keras.Input(shape=(4, 32, 32, 1), batch_size=1) + model = tf.keras.Model(inputs, model.call(inputs)) + + expected = [ + # name, type, output_shape, params + ('input_1', tf.keras.layers.InputLayer, [(1, 4, 32, 32, 1)], 0), + ('conv_block_lstm2d', conv_blocks.ConvBlockLSTM2D, (1, 4, 32, 32, 8), 7264), + ('time_distributed', tf.keras.layers.TimeDistributed, (1, 4, 16, 16, 8), 0), + ('conv_block_lstm2d_1', conv_blocks.ConvBlockLSTM2D, (1, 4, 16, 16, 16), 32384), + ('time_distributed_1', tf.keras.layers.TimeDistributed, (1, 4, 32, 32, 16), 0), + ('time_distributed_2', tf.keras.layers.TimeDistributed, (1, 4, 32, 32, 8), 1160), + ('concatenate', tf.keras.layers.Concatenate, (1, 4, 32, 32, 16), 0), + ('conv_block_lstm2d_2', conv_blocks.ConvBlockLSTM2D, (1, 4, 32, 32, 8), 11584)] + + self._check_layers(expected, model.layers) + + # Check that TimeDistributed wrappers wrap the right layers. + self.assertIsInstance(model.layers[2].layer, pooling.MaxPooling2D) + self.assertIsInstance(model.layers[4].layer, reshaping.UpSampling2D) + self.assertIsInstance(model.layers[5].layer, convolutional.Conv2D) + + def _check_layers(self, expected, actual): + actual = [ + (layer.name, type(layer), layer.output_shape, layer.count_params()) + for layer in actual] + self.assertEqual(expected, actual) + def get_layers(model, recursive=False): """Gets all layers in a model (expanding nested models).""" diff --git a/tensorflow_mri/python/util/model_util.py b/tensorflow_mri/python/util/model_util.py index fa71889b..2114dfc2 100644 --- a/tensorflow_mri/python/util/model_util.py +++ b/tensorflow_mri/python/util/model_util.py @@ -44,7 +44,13 @@ def get_nd_model(name, rank): ('ConvBlock', 1): conv_blocks.ConvBlock1D, ('ConvBlock', 2): conv_blocks.ConvBlock2D, ('ConvBlock', 3): conv_blocks.ConvBlock3D, + ('ConvBlockLSTM', 1): conv_blocks.ConvBlockLSTM1D, + ('ConvBlockLSTM', 2): conv_blocks.ConvBlockLSTM2D, + ('ConvBlockLSTM', 3): conv_blocks.ConvBlockLSTM3D, ('UNet', 1): conv_endec.UNet1D, ('UNet', 2): conv_endec.UNet2D, - ('UNet', 3): conv_endec.UNet3D + ('UNet', 3): conv_endec.UNet3D, + ('UNetLSTM', 1): conv_endec.UNetLSTM1D, + ('UNetLSTM', 2): conv_endec.UNetLSTM2D, + ('UNetLSTM', 3): conv_endec.UNetLSTM3D } From b525d57d8754cbec596d9d3bb0c5801a160baf2d Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 31 Aug 2022 20:21:17 +0000 Subject: [PATCH 070/101] Added ConvLSTM block and U-Net --- .../python/initializers/__init__.py | 104 ++++++++++++++++++ tensorflow_mri/python/layers/convolutional.py | 33 +++--- tensorflow_mri/python/models/conv_blocks.py | 11 +- .../python/models/conv_blocks_test.py | 8 +- tensorflow_mri/python/models/conv_endec.py | 28 +++-- .../python/models/conv_endec_test.py | 10 +- 6 files changed, 146 insertions(+), 48 deletions(-) diff --git a/tensorflow_mri/python/initializers/__init__.py b/tensorflow_mri/python/initializers/__init__.py index 33ca9575..4c61151f 100644 --- a/tensorflow_mri/python/initializers/__init__.py +++ b/tensorflow_mri/python/initializers/__init__.py @@ -14,7 +14,12 @@ # ============================================================================== """Keras initializers.""" +import inspect + +import keras + from tensorflow_mri.python.initializers import initializers +from tensorflow_mri.python.util import api_util TFMRI_INITIALIZERS = { @@ -33,3 +38,102 @@ 'lecun_normal': initializers.LecunNormal, 'lecun_uniform': initializers.LecunUniform, } + + +@api_util.export("initializers.serialize") +def serialize(initializer): + """Serialize a Keras initializer. + + ```{note} + This function is a drop-in replacement for + [`tf.keras.initializers.serialize`](https://www.tensorflow.org/api_docs/python/tf/keras/initializers/serialize). + ``` + + Args: + initializer: A Keras initializer. + + Returns: + A serialized Keras initializer. + """ + return keras.initializers.serialize(initializer) + + +@api_util.export("initializers.deserialize") +def deserialize(config, custom_objects=None): + """Deserialize a Keras initializers. + + ```{note} + This function is a drop-in replacement for + [`tf.keras.initializers.deserialize`](https://www.tensorflow.org/api_docs/python/tf/keras/initializers/deserialize). + The only difference is that it has built-in knowledge of TFMRI initializers. + Where a TFMRI initializer exists that replaces the corresponding Keras + initializer, this function returns the TFMRI initializer. + ``` + + Args: + config: A Keras initializer configuration. + custom_objects: Optional dictionary mapping names (strings) to custom + classes or functions to be considered during deserialization. + + Returns: + A Keras initializer. + """ + custom_objects = {**TFMRI_INITIALIZERS, **(custom_objects or {})} + return keras.initializers.deserialize(config, custom_objects) + + +@api_util.export("initializers.get") +def get(identifier): + """Retrieve a Keras initializer by the identifier. + + ```{note} + This function is a drop-in replacement for + [`tf.keras.initializers.get`](https://www.tensorflow.org/api_docs/python/tf/keras/initializers/get). + The only difference is that it has built-in knowledge of TFMRI initializers. + Where a TFMRI initializer exists that replaces the corresponding Keras + initializer, this function returns the TFMRI initializer. + ``` + + The `identifier` may be the string name of a initializers function or class ( + case-sensitively). + + >>> identifier = 'Ones' + >>> tfmri.initializers.deserialize(identifier) + <...keras.initializers.initializers_v2.Ones...> + + You can also specify `config` of the initializer to this function by passing + dict containing `class_name` and `config` as an identifier. Also note that the + `class_name` must map to a `Initializer` class. + + >>> cfg = {'class_name': 'Ones', 'config': {}} + >>> tfmri.initializers.deserialize(cfg) + <...keras.initializers.initializers_v2.Ones...> + + In the case that the `identifier` is a class, this method will return a new + instance of the class by its constructor. + + Args: + identifier: String or dict that contains the initializer name or + configurations. + + Returns: + Initializer instance base on the input identifier. + + Raises: + ValueError: If the input identifier is not a supported type or in a bad + format. + """ + if identifier is None: + return None + if isinstance(identifier, dict): + return deserialize(identifier) + elif isinstance(identifier, str): + identifier = str(identifier) + return deserialize(identifier) + elif callable(identifier): + if inspect.isclass(identifier): + identifier = identifier() + return identifier + else: + raise ValueError('Could not interpret initializer identifier: ' + + str(identifier)) diff --git a/tensorflow_mri/python/layers/convolutional.py b/tensorflow_mri/python/layers/convolutional.py index 14228afe..6c833e00 100644 --- a/tensorflow_mri/python/layers/convolutional.py +++ b/tensorflow_mri/python/layers/convolutional.py @@ -18,19 +18,18 @@ import tensorflow as tf -from tensorflow_mri.python.initializers import TFMRI_INITIALIZERS +from tensorflow_mri.python import initializers from tensorflow_mri.python.util import api_util EXTENSION_NOTE = string.Template(""" - .. note:: - This layer can be used as a drop-in replacement for - `tf.keras.layers.${name}`_. However, this one also supports complex-valued - convolutions. Simply pass `dtype='complex64'` or `dtype='complex128'` to - the layer constructor. - - .. _tf.keras.layers.${name}: https://www.tensorflow.org/api_docs/python/tf/keras/layers/${name} + ```{tip} + This layer can be used as a drop-in replacement for + [`tf.keras.layers.${name}`](https://www.tensorflow.org/api_docs/python/tf/keras/layers/${name}). + However, this one also supports complex-valued convolutions. Simply pass + `dtype='complex64'` or `dtype='complex128'` to the layer constructor. + ``` """) @@ -64,18 +63,12 @@ def complex_conv(base): f'`tf.keras.layers.ConvND`, but got {base}.') def __init__(self, *args, **kwargs): # pylint: disable=invalid-name - # If the requested initializer is one of those provided by TFMRI, prefer - # the TFMRI version. - kernel_initializer = kwargs.get('kernel_initializer', 'glorot_uniform') - if (isinstance(kernel_initializer, str) and - kernel_initializer in TFMRI_INITIALIZERS): - kwargs['kernel_initializer'] = TFMRI_INITIALIZERS[kernel_initializer]() - - bias_initializer = kwargs.get('bias_initializer', 'zeros') - if (isinstance(bias_initializer, str) and - bias_initializer in TFMRI_INITIALIZERS): - kwargs['bias_initializer'] = TFMRI_INITIALIZERS[bias_initializer]() - + # Make sure we parse the initializers here to use the TFMRI initializers + # which support complex numbers. + kwargs['kernel_initializer'] = initializers.get( + kwargs.get('kernel_initializer', 'glorot_uniform')) + kwargs['bias_initializer'] = initializers.get( + kwargs.get('bias_initializer', 'zeros')) return base.__init__(self, *args, **kwargs) def convolution_op(self, inputs, kernel): diff --git a/tensorflow_mri/python/models/conv_blocks.py b/tensorflow_mri/python/models/conv_blocks.py index 77809543..bc56803a 100644 --- a/tensorflow_mri/python/models/conv_blocks.py +++ b/tensorflow_mri/python/models/conv_blocks.py @@ -35,6 +35,7 @@ import tensorflow as tf import tensorflow_addons as tfa +from tensorflow_mri.python import initializers from tensorflow_mri.python.models import graph_like_network from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util @@ -137,8 +138,8 @@ def __init__(self, else: self.output_activation = tf.keras.activations.get(output_activation) self.use_bias = use_bias - self.kernel_initializer = tf.keras.initializers.get(kernel_initializer) - self.bias_initializer = tf.keras.initializers.get(bias_initializer) + self.kernel_initializer = initializers.get(kernel_initializer) + self.bias_initializer = initializers.get(bias_initializer) self.kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) self.bias_regularizer = tf.keras.regularizers.get(bias_regularizer) self.use_batch_norm = use_batch_norm @@ -239,10 +240,8 @@ def get_config(self): 'output_activation': tf.keras.activations.serialize( self.output_activation), 'use_bias': self.use_bias, - 'kernel_initializer': tf.keras.initializers.serialize( - self.kernel_initializer), - 'bias_initializer': tf.keras.initializers.serialize( - self.bias_initializer), + 'kernel_initializer': initializers.serialize(self.kernel_initializer), + 'bias_initializer': initializers.serialize(self.bias_initializer), 'kernel_regularizer': tf.keras.regularizers.serialize( self.kernel_regularizer), 'bias_regularizer': tf.keras.regularizers.serialize( diff --git a/tensorflow_mri/python/models/conv_blocks_test.py b/tensorflow_mri/python/models/conv_blocks_test.py index 2474da9b..77ae6564 100644 --- a/tensorflow_mri/python/models/conv_blocks_test.py +++ b/tensorflow_mri/python/models/conv_blocks_test.py @@ -66,10 +66,10 @@ def test_serialize_deserialize(self): activation='tanh', output_activation='linear', use_bias=False, - kernel_initializer='ones', - bias_initializer='ones', - kernel_regularizer='l2', - bias_regularizer='l1', + kernel_initializer={'class_name': 'Ones', 'config': {}}, + bias_initializer={'class_name': 'Ones', 'config': {}}, + kernel_regularizer=None, + bias_regularizer=None, use_batch_norm=True, use_sync_bn=True, use_instance_norm=False, diff --git a/tensorflow_mri/python/models/conv_endec.py b/tensorflow_mri/python/models/conv_endec.py index 16200344..bb873492 100644 --- a/tensorflow_mri/python/models/conv_endec.py +++ b/tensorflow_mri/python/models/conv_endec.py @@ -18,6 +18,7 @@ import tensorflow as tf +from tensorflow_mri.python import initializers from tensorflow_mri.python.layers import concatenate from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util @@ -140,12 +141,12 @@ def __init__(self, self.pool_size = pool_size self.block_depth = block_depth self.use_deconv = use_deconv - self.activation = activation + self.activation = tf.keras.activations.get(activation) self.use_bias = use_bias - self.kernel_initializer = kernel_initializer - self.bias_initializer = bias_initializer - self.kernel_regularizer = kernel_regularizer - self.bias_regularizer = bias_regularizer + self.kernel_initializer = initializers.get(kernel_initializer) + self.bias_initializer = initializers.get(bias_initializer) + self.kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) + self.bias_regularizer = tf.keras.regularizers.get(bias_regularizer) self.use_batch_norm = use_batch_norm self.use_sync_bn = use_sync_bn self.use_instance_norm = use_instance_norm @@ -153,7 +154,7 @@ def __init__(self, self.bn_epsilon = bn_epsilon self.output_filters = output_filters self.output_kernel_size = output_kernel_size - self.output_activation = output_activation + self.output_activation = tf.keras.activations.get(output_activation) self.use_global_residual = use_global_residual self.use_dropout = use_dropout self.dropout_rate = dropout_rate @@ -375,12 +376,14 @@ def get_config(self): 'pool_size': self.pool_size, 'block_depth': self.block_depth, 'use_deconv': self.use_deconv, - 'activation': self.activation, + 'activation': tf.keras.activations.serialize(self.activation), 'use_bias': self.use_bias, - 'kernel_initializer': self.kernel_initializer, - 'bias_initializer': self.bias_initializer, - 'kernel_regularizer': self.kernel_regularizer, - 'bias_regularizer': self.bias_regularizer, + 'kernel_initializer': initializers.serialize(self.kernel_initializer), + 'bias_initializer': initializers.serialize(self.bias_initializer), + 'kernel_regularizer': tf.keras.regularizers.serialize( + self.kernel_regularizer), + 'bias_regularizer': tf.keras.regularizers.serialize( + self.bias_regularizer), 'use_batch_norm': self.use_batch_norm, 'use_sync_bn': self.use_sync_bn, 'use_instance_norm': self.use_instance_norm, @@ -388,7 +391,8 @@ def get_config(self): 'bn_epsilon': self.bn_epsilon, 'output_filters': self.output_filters, 'output_kernel_size': self.output_kernel_size, - 'output_activation': self.output_activation, + 'output_activation': tf.keras.activations.serialize( + self.output_activation), 'use_global_residual': self.use_global_residual, 'use_dropout': self.use_dropout, 'dropout_rate': self.dropout_rate, diff --git a/tensorflow_mri/python/models/conv_endec_test.py b/tensorflow_mri/python/models/conv_endec_test.py index 9d0ab8aa..0826a5ea 100644 --- a/tensorflow_mri/python/models/conv_endec_test.py +++ b/tensorflow_mri/python/models/conv_endec_test.py @@ -89,7 +89,6 @@ def test_use_bias(self, use_bias): if hasattr(layer, 'use_bias'): self.assertEqual(use_bias, layer.use_bias) - def test_complex_valued(self): inputs = tf.dtypes.complex( tf.random.stateless_normal(shape=(2, 32, 32, 4), seed=[12, 34]), @@ -105,7 +104,6 @@ def test_complex_valued(self): self.assertAllClose((2, 32, 32, 4), result.shape) self.assertDTypeEqual(result, tf.complex64) - def test_serialize_deserialize(self): """Test de/serialization.""" config = dict( @@ -116,10 +114,10 @@ def test_serialize_deserialize(self): use_deconv=True, activation='tanh', use_bias=False, - kernel_initializer='ones', - bias_initializer='ones', - kernel_regularizer='l2', - bias_regularizer='l1', + kernel_initializer={'class_name': 'Ones', 'config': {}}, + bias_initializer={'class_name': 'Ones', 'config': {}}, + kernel_regularizer={'class_name': 'L2', 'config': {'l2': 1.0}}, + bias_regularizer=None, use_batch_norm=True, use_sync_bn=True, bn_momentum=0.98, From 8fbf7ed5fac28a11a91592f4c3d59b989a89b65b Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 31 Aug 2022 21:15:57 +0000 Subject: [PATCH 071/101] Added serialization for custom activations --- tensorflow_mri/_api/initializers/__init__.py | 3 + tensorflow_mri/_api/models/__init__.py | 6 + tensorflow_mri/python/activations/__init__.py | 127 ++++++++++++++++++ .../activations/complex_activations_test.py | 26 ++++ .../python/initializers/__init__.py | 27 ++-- tensorflow_mri/python/layers/convolutional.py | 6 +- tensorflow_mri/python/models/conv_blocks.py | 10 +- tensorflow_mri/python/models/conv_endec.py | 9 +- .../python/models/conv_endec_test.py | 2 +- 9 files changed, 189 insertions(+), 27 deletions(-) diff --git a/tensorflow_mri/_api/initializers/__init__.py b/tensorflow_mri/_api/initializers/__init__.py index a1513d99..8eb5ad07 100644 --- a/tensorflow_mri/_api/initializers/__init__.py +++ b/tensorflow_mri/_api/initializers/__init__.py @@ -9,3 +9,6 @@ from tensorflow_mri.python.initializers.initializers import HeUniform as HeUniform from tensorflow_mri.python.initializers.initializers import LecunNormal as LecunNormal from tensorflow_mri.python.initializers.initializers import LecunUniform as LecunUniform +from tensorflow_mri.python.initializers import serialize as serialize +from tensorflow_mri.python.initializers import deserialize as deserialize +from tensorflow_mri.python.initializers import get as get diff --git a/tensorflow_mri/_api/models/__init__.py b/tensorflow_mri/_api/models/__init__.py index ec86562f..0d166ff0 100644 --- a/tensorflow_mri/_api/models/__init__.py +++ b/tensorflow_mri/_api/models/__init__.py @@ -5,8 +5,14 @@ from tensorflow_mri.python.models.conv_blocks import ConvBlock1D as ConvBlock1D from tensorflow_mri.python.models.conv_blocks import ConvBlock2D as ConvBlock2D from tensorflow_mri.python.models.conv_blocks import ConvBlock3D as ConvBlock3D +from tensorflow_mri.python.models.conv_blocks import ConvBlockLSTM1D as ConvBlockLSTM1D +from tensorflow_mri.python.models.conv_blocks import ConvBlockLSTM2D as ConvBlockLSTM2D +from tensorflow_mri.python.models.conv_blocks import ConvBlockLSTM3D as ConvBlockLSTM3D from tensorflow_mri.python.models.conv_endec import UNet1D as UNet1D from tensorflow_mri.python.models.conv_endec import UNet2D as UNet2D from tensorflow_mri.python.models.conv_endec import UNet3D as UNet3D +from tensorflow_mri.python.models.conv_endec import UNetLSTM1D as UNetLSTM1D +from tensorflow_mri.python.models.conv_endec import UNetLSTM2D as UNetLSTM2D +from tensorflow_mri.python.models.conv_endec import UNetLSTM3D as UNetLSTM3D from tensorflow_mri.python.models.variational_network import VarNet2D as VarNet2D from tensorflow_mri.python.models.variational_network import VarNet3D as VarNet3D diff --git a/tensorflow_mri/python/activations/__init__.py b/tensorflow_mri/python/activations/__init__.py index a76cebf6..2421d271 100644 --- a/tensorflow_mri/python/activations/__init__.py +++ b/tensorflow_mri/python/activations/__init__.py @@ -14,4 +14,131 @@ # ============================================================================== """Keras activations.""" +import keras + from tensorflow_mri.python.activations import complex_activations +from tensorflow_mri.python.util import api_util + + +TFMRI_ACTIVATIONS = { + 'complex_relu': complex_activations.complex_relu, + 'mod_relu': complex_activations.mod_relu +} + + +@api_util.export("activations.serialize") +def serialize(activation): + """Returns the string identifier of an activation function. + + ```{note} + This function is a drop-in replacement for `tf.keras.activations.serialize`. + ``` + + Example: + >>> tfmri.activations.serialize(tf.keras.activations.tanh) + 'tanh' + >>> tfmri.activations.serialize(tf.keras.activations.sigmoid) + 'sigmoid' + >>> tfmri.activations.serialize(tfmri.activations.complex_relu) + 'complex_relu' + >>> tfmri.activations.serialize('abcd') + Traceback (most recent call last): + ... + ValueError: ('Cannot serialize', 'abcd') + + Args: + activation: A function object. + + Returns: + A `str` denoting the name attribute of the input function. + + Raises: + ValueError: The input function is not a valid one. + """ + return keras.activations.serialize(activation) + + +@api_util.export("activations.deserialize") +def deserialize(name, custom_objects=None): + """Returns activation function given a string identifier. + + ```{note} + This function is a drop-in replacement for + `tf.keras.activations.deserialize`. The only difference is that this function + has built-in knowledge of TFMRI activations. + ``` + + Example: + >>> tfmri.activations.deserialize('linear') + + >>> tfmri.activations.deserialize('sigmoid') + + >>> tfmri.activations.deserialize('complex_relu') + + >>> tfmri.activations.deserialize('abcd') + Traceback (most recent call last): + ... + ValueError: Unknown activation function:abcd + + Args: + name: The name of the activation function. + custom_objects: Optional `{function_name: function_obj}` + dictionary listing user-provided activation functions. + + Returns: + The corresponding activation function. + + Raises: + ValueError: If the input string does not denote any defined activation + function. + """ + custom_objects = {**TFMRI_ACTIVATIONS, **(custom_objects or {})} + return keras.activations.deserialize(name, custom_objects) + + +@api_util.export("activations.get") +def get(identifier): + """Retrieve a Keras activation by its identifier. + + ```{note} + This function is a drop-in replacement for + `tf.keras.activations.get`. The only difference is that this function + has built-in knowledge of TFMRI activations. + ``` + + Args: + identifier: A function or a string. + + Returns: + A function corresponding to the input string or input function. + + Example: + + >>> tfmri.activations.get('softmax') + + >>> tfmri.activations.get(tf.keras.activations.softmax) + + >>> tfmri.activations.get(None) + + >>> tfmri.activations.get(abs) + + >>> tfmri.activations.get('complex_relu') + + >>> tfmri.activations.get('abcd') + Traceback (most recent call last): + ... + ValueError: Unknown activation function:abcd + + Raises: + ValueError: Input is an unknown function or string, i.e., the input does + not denote any defined function. + """ + if identifier is None: + return keras.activations.linear + if isinstance(identifier, (str, dict)): + return deserialize(identifier) + elif callable(identifier): + return identifier + else: + raise ValueError( + f'Could not interpret activation function identifier: {identifier}') diff --git a/tensorflow_mri/python/activations/complex_activations_test.py b/tensorflow_mri/python/activations/complex_activations_test.py index 9c30aead..bc7d6c6a 100644 --- a/tensorflow_mri/python/activations/complex_activations_test.py +++ b/tensorflow_mri/python/activations/complex_activations_test.py @@ -16,6 +16,7 @@ import tensorflow as tf +from tensorflow_mri.python import activations from tensorflow_mri.python.activations import complex_activations from tensorflow_mri.python.util import test_util @@ -35,6 +36,31 @@ def test_mod_relu(self): result = complex_activations.mod_relu(inputs, threshold=3.0) self.assertAllClose(expected, result) + def test_serialization(self): + fn = activations.get('complex_relu') + self.assertEqual(complex_activations.complex_relu, fn) + + fn = activations.get('mod_relu') + self.assertEqual(complex_activations.mod_relu, fn) + + fn = activations.deserialize('complex_relu') + self.assertEqual(complex_activations.complex_relu, fn) + + fn = activations.deserialize('mod_relu') + self.assertEqual(complex_activations.mod_relu, fn) + + fn = activations.serialize(complex_activations.complex_relu) + self.assertEqual('complex_relu', fn) + + fn = activations.serialize(complex_activations.mod_relu) + self.assertEqual('mod_relu', fn) + + fn = activations.get(complex_activations.complex_relu) + self.assertEqual(complex_activations.complex_relu, fn) + + fn = activations.get(complex_activations.mod_relu) + self.assertEqual(complex_activations.mod_relu, fn) + if __name__ == '__main__': tf.test.main() diff --git a/tensorflow_mri/python/initializers/__init__.py b/tensorflow_mri/python/initializers/__init__.py index 4c61151f..057794ec 100644 --- a/tensorflow_mri/python/initializers/__init__.py +++ b/tensorflow_mri/python/initializers/__init__.py @@ -45,8 +45,7 @@ def serialize(initializer): """Serialize a Keras initializer. ```{note} - This function is a drop-in replacement for - [`tf.keras.initializers.serialize`](https://www.tensorflow.org/api_docs/python/tf/keras/initializers/serialize). + This function is a drop-in replacement for `tf.keras.initializers.serialize`. ``` Args: @@ -60,14 +59,14 @@ def serialize(initializer): @api_util.export("initializers.deserialize") def deserialize(config, custom_objects=None): - """Deserialize a Keras initializers. + """Deserialize a Keras initializer. ```{note} This function is a drop-in replacement for - [`tf.keras.initializers.deserialize`](https://www.tensorflow.org/api_docs/python/tf/keras/initializers/deserialize). - The only difference is that it has built-in knowledge of TFMRI initializers. - Where a TFMRI initializer exists that replaces the corresponding Keras - initializer, this function returns the TFMRI initializer. + `tf.keras.initializers.deserialize`. The only difference is that this function + has built-in knowledge of TFMRI initializers. Where a TFMRI initializer exists + that replaces the corresponding Keras initializer, this function prefers the + TFMRI initializer. ``` Args: @@ -88,10 +87,10 @@ def get(identifier): ```{note} This function is a drop-in replacement for - [`tf.keras.initializers.get`](https://www.tensorflow.org/api_docs/python/tf/keras/initializers/get). - The only difference is that it has built-in knowledge of TFMRI initializers. - Where a TFMRI initializer exists that replaces the corresponding Keras - initializer, this function returns the TFMRI initializer. + `tf.keras.initializers.get`. The only difference is that this function + has built-in knowledge of TFMRI initializers. Where a TFMRI initializer exists + that replaces the corresponding Keras initializer, this function prefers the + TFMRI initializer. ``` The `identifier` may be the string name of a initializers function or class ( @@ -113,11 +112,11 @@ def get(identifier): instance of the class by its constructor. Args: - identifier: String or dict that contains the initializer name or - configurations. + identifier: A `str` or `dict` containing the initializer name or + configuration. Returns: - Initializer instance base on the input identifier. + An initializer instance based on the input identifier. Raises: ValueError: If the input identifier is not a supported type or in a bad diff --git a/tensorflow_mri/python/layers/convolutional.py b/tensorflow_mri/python/layers/convolutional.py index 6c833e00..2121ca0b 100644 --- a/tensorflow_mri/python/layers/convolutional.py +++ b/tensorflow_mri/python/layers/convolutional.py @@ -26,9 +26,9 @@ ```{tip} This layer can be used as a drop-in replacement for - [`tf.keras.layers.${name}`](https://www.tensorflow.org/api_docs/python/tf/keras/layers/${name}). - However, this one also supports complex-valued convolutions. Simply pass - `dtype='complex64'` or `dtype='complex128'` to the layer constructor. + `tf.keras.layers.${name}`, but unlike the core Keras layer, this one also + supports complex-valued convolutions. Simply pass `dtype='complex64'` or + `dtype='complex128'` to the layer constructor. ``` """) diff --git a/tensorflow_mri/python/models/conv_blocks.py b/tensorflow_mri/python/models/conv_blocks.py index bc56803a..d5c1a32c 100644 --- a/tensorflow_mri/python/models/conv_blocks.py +++ b/tensorflow_mri/python/models/conv_blocks.py @@ -29,12 +29,12 @@ # ============================================================================== """Convolutional neural network blocks.""" -import itertools import string import tensorflow as tf import tensorflow_addons as tfa +from tensorflow_mri.python import activations from tensorflow_mri.python import initializers from tensorflow_mri.python.models import graph_like_network from tensorflow_mri.python.util import api_util @@ -132,11 +132,11 @@ def __init__(self, self.filters = [filters] if isinstance(filters, int) else filters self.kernel_size = kernel_size self.strides = strides - self.activation = tf.keras.activations.get(activation) + self.activation = activations.get(activation) if output_activation == 'same': self.output_activation = self.activation else: - self.output_activation = tf.keras.activations.get(output_activation) + self.output_activation = activations.get(output_activation) self.use_bias = use_bias self.kernel_initializer = initializers.get(kernel_initializer) self.bias_initializer = initializers.get(bias_initializer) @@ -236,8 +236,8 @@ def get_config(self): 'filters': self.filters, 'kernel_size': self.kernel_size, 'strides': self.strides, - 'activation': tf.keras.activations.serialize(self.activation), - 'output_activation': tf.keras.activations.serialize( + 'activation': activations.serialize(self.activation), + 'output_activation': activations.serialize( self.output_activation), 'use_bias': self.use_bias, 'kernel_initializer': initializers.serialize(self.kernel_initializer), diff --git a/tensorflow_mri/python/models/conv_endec.py b/tensorflow_mri/python/models/conv_endec.py index bb873492..b5c8c6cb 100644 --- a/tensorflow_mri/python/models/conv_endec.py +++ b/tensorflow_mri/python/models/conv_endec.py @@ -18,6 +18,7 @@ import tensorflow as tf +from tensorflow_mri.python import activations from tensorflow_mri.python import initializers from tensorflow_mri.python.layers import concatenate from tensorflow_mri.python.util import api_util @@ -141,7 +142,7 @@ def __init__(self, self.pool_size = pool_size self.block_depth = block_depth self.use_deconv = use_deconv - self.activation = tf.keras.activations.get(activation) + self.activation = activations.get(activation) self.use_bias = use_bias self.kernel_initializer = initializers.get(kernel_initializer) self.bias_initializer = initializers.get(bias_initializer) @@ -154,7 +155,7 @@ def __init__(self, self.bn_epsilon = bn_epsilon self.output_filters = output_filters self.output_kernel_size = output_kernel_size - self.output_activation = tf.keras.activations.get(output_activation) + self.output_activation = activations.get(output_activation) self.use_global_residual = use_global_residual self.use_dropout = use_dropout self.dropout_rate = dropout_rate @@ -376,7 +377,7 @@ def get_config(self): 'pool_size': self.pool_size, 'block_depth': self.block_depth, 'use_deconv': self.use_deconv, - 'activation': tf.keras.activations.serialize(self.activation), + 'activation': activations.serialize(self.activation), 'use_bias': self.use_bias, 'kernel_initializer': initializers.serialize(self.kernel_initializer), 'bias_initializer': initializers.serialize(self.bias_initializer), @@ -391,7 +392,7 @@ def get_config(self): 'bn_epsilon': self.bn_epsilon, 'output_filters': self.output_filters, 'output_kernel_size': self.output_kernel_size, - 'output_activation': tf.keras.activations.serialize( + 'output_activation': activations.serialize( self.output_activation), 'use_global_residual': self.use_global_residual, 'use_dropout': self.use_dropout, diff --git a/tensorflow_mri/python/models/conv_endec_test.py b/tensorflow_mri/python/models/conv_endec_test.py index 0826a5ea..905eee56 100644 --- a/tensorflow_mri/python/models/conv_endec_test.py +++ b/tensorflow_mri/python/models/conv_endec_test.py @@ -97,7 +97,7 @@ def test_complex_valued(self): block = conv_endec.UNet2D( filters=[4, 8], kernel_size=3, - activation=complex_activations.complex_relu, + activation='complex_relu', dtype=tf.complex64) result = block(inputs) From 960ae7ffe5817e8d34d44bd111953977e249df3d Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 1 Sep 2022 12:08:51 +0000 Subject: [PATCH 072/101] Changed autodoc config, remove rank arg from PSNR metric --- tensorflow_mri/python/metrics/iqa_metrics.py | 2 -- tools/docs/conf.py | 5 ++--- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/tensorflow_mri/python/metrics/iqa_metrics.py b/tensorflow_mri/python/metrics/iqa_metrics.py index a4cf1488..1ed1e72e 100755 --- a/tensorflow_mri/python/metrics/iqa_metrics.py +++ b/tensorflow_mri/python/metrics/iqa_metrics.py @@ -127,7 +127,6 @@ def __init__(self, max_val=None, batch_dims=None, image_dims=None, - rank=None, multichannel=True, complex_part=None, name='psnr', @@ -138,7 +137,6 @@ def __init__(self, max_val=max_val, batch_dims=batch_dims, image_dims=image_dims, - rank=rank, multichannel=multichannel, complex_part=complex_part) diff --git a/tools/docs/conf.py b/tools/docs/conf.py index bc55b2d4..5b6b5532 100644 --- a/tools/docs/conf.py +++ b/tools/docs/conf.py @@ -81,9 +81,8 @@ # Do not add full qualification to objects' signatures. add_module_names = False -# For classes, list the documentation of both the class and the `__init__` -# method. -autoclass_content = 'both' +# For classes, list the class documentation but not `__init__`. +autoclass_content = 'class' # -- Options for HTML output ------------------------------------------------- From 434819bf21266684c45db91969b079e06b6d0251 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 1 Sep 2022 12:30:18 +0000 Subject: [PATCH 073/101] Removed all VarNet stuff --- .../python/layers/coil_compression.py | 95 -------- .../python/layers/coil_sensitivities.py | 143 ----------- .../python/layers/data_consistency.py | 83 ------- .../python/layers/data_consistency_test.py | 132 ---------- .../python/layers/kspace_scaling.py | 97 -------- .../python/layers/kspace_scaling_test.py | 61 ----- .../python/layers/linear_operator_layer.py | 112 --------- tensorflow_mri/python/layers/recon_adjoint.py | 135 ---------- .../python/layers/recon_adjoint_test.py | 68 ------ .../python/models/variational_network.py | 230 ------------------ .../python/models/variational_network_test.py | 0 11 files changed, 1156 deletions(-) delete mode 100644 tensorflow_mri/python/layers/coil_compression.py delete mode 100644 tensorflow_mri/python/layers/coil_sensitivities.py delete mode 100644 tensorflow_mri/python/layers/data_consistency.py delete mode 100644 tensorflow_mri/python/layers/data_consistency_test.py delete mode 100644 tensorflow_mri/python/layers/kspace_scaling.py delete mode 100644 tensorflow_mri/python/layers/kspace_scaling_test.py delete mode 100644 tensorflow_mri/python/layers/linear_operator_layer.py delete mode 100644 tensorflow_mri/python/layers/recon_adjoint.py delete mode 100644 tensorflow_mri/python/layers/recon_adjoint_test.py delete mode 100644 tensorflow_mri/python/models/variational_network.py delete mode 100644 tensorflow_mri/python/models/variational_network_test.py diff --git a/tensorflow_mri/python/layers/coil_compression.py b/tensorflow_mri/python/layers/coil_compression.py deleted file mode 100644 index 19a18695..00000000 --- a/tensorflow_mri/python/layers/coil_compression.py +++ /dev/null @@ -1,95 +0,0 @@ -# Copyright 2022 The TensorFlow MRI 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. -# ============================================================================== -"""Coil compression layers.""" - -import numpy as np -import tensorflow as tf - -from tensorflow_mri.python.coils import coil_compression -from tensorflow_mri.python.layers import linear_operator_layer -from tensorflow_mri.python.linalg import linear_operator_mri -from tensorflow_mri.python.util import api_util - - -class CoilCompression(linear_operator_layer.LinearOperatorLayer): - """Coil compression layer. - - This layer extracts a calibration region and compresses the coils. - """ - def __init__(self, - rank, - calib_window, - coil_compression_method='svd', - coil_compression_kwargs=None, - operator=linear_operator_mri.LinearOperatorMRI, - kspace_index=None, - **kwargs): - """Initializes the layer.""" - super().__init__(operator=operator, input_indices=kspace_index, **kwargs) - self.rank = rank - self.calib_window = calib_window - self.coil_compression_method = coil_compression_method - self.coil_compression_kwargs = coil_compression_kwargs or {} - - def call(self, inputs): - """Applies the layer. - - Args: - inputs: A `tuple` or `dict` containing the *k*-space data as defined by - `kspace_index`. If `operator` is a class not an instance, then `inputs` - must also contain any other arguments to be passed to the constructor of - `operator`. - - Returns: - The scaled k-space data. - """ - kspace, operator = self.parse_inputs(inputs) - return coil_compression.compress_coils_with_calibration_data( - kspace, - operator, - calib_window=self.calib_window, - method=self.coil_compression_method, - **self.coil_compression_kwargs) - - def get_config(self): - """Returns the config of the layer. - - Returns: - A `dict` describing the layer configuration. - """ - config = { - 'calib_window': self.calib_window, - 'coil_compression_method': self.coil_compression_method, - 'coil_compression_kwargs': self.coil_compression_kwargs - } - base_config = super().get_config() - kspace_index = base_config.pop('input_indices') - config['kspace_index'] = ( - kspace_index[0] if kspace_index is not None else None) - return {**config, **base_config} - - -@api_util.export("layers.CoilCompression2D") -@tf.keras.utils.register_keras_serializable(package='MRI') -class CoilCompression2D(CoilCompression): - def __init__(self, *args, **kwargs): - super().__init__(2, *args, **kwargs) - - -@api_util.export("layers.CoilCompression3D") -@tf.keras.utils.register_keras_serializable(package='MRI') -class CoilCompression3D(CoilCompression): - def __init__(self, *args, **kwargs): - super().__init__(3, *args, **kwargs) diff --git a/tensorflow_mri/python/layers/coil_sensitivities.py b/tensorflow_mri/python/layers/coil_sensitivities.py deleted file mode 100644 index fadfb4f8..00000000 --- a/tensorflow_mri/python/layers/coil_sensitivities.py +++ /dev/null @@ -1,143 +0,0 @@ -# Copyright 2022 The TensorFlow MRI 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. -# ============================================================================== -"""Coil sensitivities layers.""" - -import numpy as np -import tensorflow as tf - -from tensorflow_mri.python.activations import complex_activations -from tensorflow_mri.python.coils import coil_sensitivities -from tensorflow_mri.python.layers import linear_operator_layer -from tensorflow_mri.python.linalg import linear_operator_mri -from tensorflow_mri.python.ops import math_ops -from tensorflow_mri.python.util import api_util -from tensorflow_mri.python.util import model_util - - -class CoilSensitivityEstimation(linear_operator_layer.LinearOperatorLayer): - """Coil sensitivity estimation layer. - - This layer extracts a calibration region and estimates the coil sensitivity - maps. - """ - def __init__(self, - rank, - calib_window, - calib_method='walsh', - calib_kwargs=None, - sens_network='auto', - reinterpret_complex=False, - normalize=True, - operator=linear_operator_mri.LinearOperatorMRI, - kspace_index=None, - **kwargs): - """Initializes the layer.""" - super().__init__(operator=operator, input_indices=kspace_index, **kwargs) - self.rank = rank - self.calib_window = calib_window - self.calib_method = calib_method - self.calib_kwargs = calib_kwargs or {} - self.sens_network = sens_network - self.reinterpret_complex = reinterpret_complex - self.normalize = normalize - - if self.sens_network == 'auto': - sens_network_class = model_util.get_nd_model('UNet', rank) - sens_network_kwargs = dict( - filters=[32, 64, 128], - kernel_size=3, - activation=('relu' if self.reinterpret_complex - else complex_activations.complex_relu), - out_channels=2 if self.reinterpret_complex else 1, - use_deconv=True, - dtype=(tf.as_dtype(self.dtype).real_dtype.name - if self.reinterpret_complex else self.dtype) - ) - self._sens_network_layer = tf.keras.layers.TimeDistributed( - sens_network_class(**sens_network_kwargs)) - else: - self._sens_network_layer = tf.keras.layers.TimeDistributed(sens_network) - - def call(self, inputs): - """Applies the layer. - - Args: - inputs: A `tuple` or `dict` containing the *k*-space data as defined by - `kspace_index`. If `operator` is a class not an instance, then `inputs` - must also contain any other arguments to be passed to the constructor of - `operator`. - - Returns: - The scaled k-space data. - """ - kspace, operator = self.parse_inputs(inputs) - sensitivities = ( - coil_sensitivities.estimate_sensitivities_with_calibration_data( - kspace, - operator, - calib_window=self.calib_window, - method=self.calib_method, - **self.calib_kwargs - ) - ) - - if self.sens_network is not None: - sensitivities = tf.expand_dims(sensitivities, axis=-1) - if self.reinterpret_complex: - sensitivities = math_ops.view_as_real(sensitivities, stacked=False) - sensitivities = self._sens_network_layer(sensitivities) - if self.reinterpret_complex: - sensitivities = math_ops.view_as_complex(sensitivities, stacked=False) - sensitivities = tf.squeeze(sensitivities, axis=-1) - - if self.normalize: - coil_axis = -(self.rank + 1) - sensitivities = math_ops.normalize_no_nan(sensitivities, axis=coil_axis) - - return sensitivities - - def get_config(self): - """Returns the config of the layer. - - Returns: - A `dict` describing the layer configuration. - """ - config = { - 'calib_window': self.calib_window, - 'calib_method': self.calib_method, - 'calib_kwargs': self.calib_kwargs, - 'sens_network': self.sens_network, - 'reinterpret_complex': self.reinterpret_complex, - 'normalize': self.normalize - } - base_config = super().get_config() - kspace_index = base_config.pop('input_indices') - config['kspace_index'] = ( - kspace_index[0] if kspace_index is not None else None) - return {**config, **base_config} - - -@api_util.export("layers.CoilSensitivityEstimation2D") -@tf.keras.utils.register_keras_serializable(package='MRI') -class CoilSensitivityEstimation2D(CoilSensitivityEstimation): - def __init__(self, *args, **kwargs): - super().__init__(2, *args, **kwargs) - - -@api_util.export("layers.CoilSensitivityEstimation3D") -@tf.keras.utils.register_keras_serializable(package='MRI') -class CoilSensitivityEstimation3D(CoilSensitivityEstimation): - def __init__(self, *args, **kwargs): - super().__init__(3, *args, **kwargs) diff --git a/tensorflow_mri/python/layers/data_consistency.py b/tensorflow_mri/python/layers/data_consistency.py deleted file mode 100644 index 291213f0..00000000 --- a/tensorflow_mri/python/layers/data_consistency.py +++ /dev/null @@ -1,83 +0,0 @@ -# Copyright 2022 University College London. 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. -# ============================================================================== -"""Data consistency layers.""" - -import tensorflow as tf - -from tensorflow_mri.python.layers import linear_operator_layer -from tensorflow_mri.python.linalg import linear_operator_mri -from tensorflow_mri.python.ops import math_ops -from tensorflow_mri.python.util import api_util -from tensorflow_mri.python.util import keras_util - - -class LeastSquaresGradientDescent(linear_operator_layer.LinearOperatorLayer): - """Least squares gradient descent layer. - """ - def __init__(self, - scale_initializer=1.0, - ignore_channels=True, - reinterpret_complex=False, - operator=linear_operator_mri.LinearOperatorMRI, - image_index='image', - kspace_index='kspace', - **kwargs): - kwargs['dtype'] = kwargs.get('dtype') or keras_util.complexx() - super().__init__(operator=operator, - input_indices=(image_index, kspace_index), - **kwargs) - if isinstance(scale_initializer, (float, int)): - self.scale_initializer = tf.keras.initializers.Constant(scale_initializer) - else: - self.scale_initializer = tf.keras.initializers.get(scale_initializer) - self.ignore_channels = ignore_channels - self.reinterpret_complex = reinterpret_complex - - def build(self, input_shape): - super().build(input_shape) - self.scale = self.add_weight( - name='scale', - shape=(), - dtype=tf.as_dtype(self.dtype).real_dtype, - initializer=self.scale_initializer, - trainable=self.trainable, - constraint=tf.keras.constraints.NonNeg()) - - def call(self, inputs): - (image, kspace), operator = self.parse_inputs(inputs) - if self.reinterpret_complex: - image = math_ops.view_as_complex(image, stacked=False) - if self.ignore_channels: - image = tf.squeeze(image, axis=-1) - image -= tf.cast(self.scale, image.dtype) * operator.transform( - operator.transform(image) - kspace, adjoint=True) - if self.ignore_channels: - image = tf.expand_dims(image, axis=-1) - if self.reinterpret_complex: - image = math_ops.view_as_real(image, stacked=False) - return image - - def get_config(self): - config = { - 'scale_initializer': tf.keras.initializers.serialize( - self.scale_initializer), - 'ignore_channels': self.ignore_channels, - 'reinterpret_complex': self.reinterpret_complex - } - base_config = super().get_config() - image_index, kspace_index = base_config.pop('input_indices') - config['image_index'] = image_index - config['kspace_index'] = kspace_index - return {**config, **base_config} diff --git a/tensorflow_mri/python/layers/data_consistency_test.py b/tensorflow_mri/python/layers/data_consistency_test.py deleted file mode 100644 index d0e3135f..00000000 --- a/tensorflow_mri/python/layers/data_consistency_test.py +++ /dev/null @@ -1,132 +0,0 @@ -# Copyright 2022 University College London. 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. -# ============================================================================== -"""Tests for data consistency layers.""" - -import tempfile - -from absl.testing import parameterized -import tensorflow as tf - -from tensorflow_mri.python.layers import data_consistency -from tensorflow_mri.python.linalg import linear_operator -from tensorflow_mri.python.util import test_util - - -class LeastSquaresGradientDescentTest(test_util.TestCase): - @parameterized.product(operator_type=['class', 'instance'], - input_type=['dict', 'tuple']) - def test_general(self, operator_type, input_type): - scale = tf.constant(2.0, dtype=tf.float32) - dtype = tf.complex64 - if operator_type == 'class': - # Operator is a class. - class LinearOperatorScalarMultiplyComplex64(LinearOperatorScalarMultiply): - # Same as `LinearOperatorScalarMultiply` but dtype is tf.complex64. - def __init__(self, *args, **kwargs): - if 'dtype' in kwargs: - raise ValueError('dtype is not allowed in this class.') - kwargs['dtype'] = tf.complex64 - super().__init__(*args, **kwargs) - - operator = LinearOperatorScalarMultiplyComplex64 - args = (tf.expand_dims(scale, axis=0),) - kwargs = {'scale': tf.expand_dims(scale, axis=0)} - else: - # Operator is an instance. - operator = LinearOperatorScalarMultiply(scale, dtype=dtype) - args, kwargs = (), {} - - # Initialize layer. - layer = data_consistency.LeastSquaresGradientDescent( - operator, scale_initializer=0.5, dtype=dtype) - - # All variables have a batch dimension. - x = tf.constant([[3, 3]], dtype=dtype) - b = tf.constant([[1, 1]], dtype=dtype) - expected_output = tf.constant([[-2.0 + 0.0j, -2.0 + 0.0j]], dtype=dtype) - - # Create input data. - if input_type == 'dict': - input_data = {'x': x, 'b': b} - input_data.update(kwargs) - else: - input_data = (x, b) - input_data += args - - # Test layer. - output = layer(input_data) - self.assertAllClose(expected_output, output) - - # Test serialization. - layer_config = layer.get_config() - layer = data_consistency.LeastSquaresGradientDescent.from_config( - layer_config) - - # Test layer with tuple inputs. - output = layer(input_data) - self.assertAllClose(expected_output, output) - - # Test layer in a model. - inputs = tf.nest.map_structure( - lambda x: tf.keras.Input(shape=x.shape[1:], dtype=x.dtype), - input_data) - model = tf.keras.Model(inputs=inputs, outputs=layer(inputs)) - output = model(input_data) - self.assertAllClose(expected_output, output) - - # Test training. - model.compile(optimizer='sgd', loss='mse') - model.fit(input_data, expected_output * 2) - expected_weights = [0.9] - expected_output = tf.constant([[-6.0 + 0.0j, -6.0 + 0.0j]], - dtype=tf.complex64) - self.assertAllClose(expected_weights, model.get_weights()) - self.assertAllClose(expected_output, model(input_data)) - - # Test model saving. - with tempfile.TemporaryDirectory() as tmpdir: - model.save(tmpdir + '/model') - model = tf.keras.models.load_model(tmpdir + '/model') - output = model(input_data) - self.assertAllClose(expected_output, output) - - -@linear_operator.make_composite_tensor -class LinearOperatorScalarMultiply(linear_operator.LinearOperator): - def __init__(self, scale, dtype=None, **kwargs): - parameters = {'scale': scale} - self.scale = tf.convert_to_tensor(scale) - super().__init__(dtype=dtype or self.scale.dtype, - parameters=parameters, - **kwargs) - - def _transform(self, x, adjoint=False): - if adjoint: - return x * tf.math.conj(tf.cast(self.scale, x.dtype)) - else: - return x * tf.cast(self.scale, x.dtype) - - def _domain_shape(self): - return tf.TensorShape([2]) - - def _range_shape(self): - return self._domain_shape() - - def _batch_shape(self): - return self.scale.shape[:-1] - - @property - def _composite_tensor_fields(self): - return ('scale',) diff --git a/tensorflow_mri/python/layers/kspace_scaling.py b/tensorflow_mri/python/layers/kspace_scaling.py deleted file mode 100644 index a8816ddd..00000000 --- a/tensorflow_mri/python/layers/kspace_scaling.py +++ /dev/null @@ -1,97 +0,0 @@ -# Copyright 2022 The TensorFlow MRI 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. -# ============================================================================== -"""*k*-space scaling layer.""" - -import tensorflow as tf - -from tensorflow_mri.python.layers import linear_operator_layer -from tensorflow_mri.python.linalg import linear_operator_mri -from tensorflow_mri.python.ops import signal_ops -from tensorflow_mri.python.recon import recon_adjoint -from tensorflow_mri.python.util import api_util -from tensorflow_mri.python.util import keras_util - - -class KSpaceScaling(linear_operator_layer.LinearOperatorLayer): - """K-space scaling layer. - - This layer scales the *k*-space data so that the adjoint reconstruction has - magnitude values in the approximate `[0, 1]` range. - """ - def __init__(self, - rank, - calib_window, - operator=linear_operator_mri.LinearOperatorMRI, - kspace_index=None, - **kwargs): - """Initializes the layer.""" - kwargs['dtype'] = kwargs.get('dtype') or keras_util.complexx() - super().__init__(operator=operator, - input_indices=kspace_index, - **kwargs) - self.rank = rank - self.calib_window = calib_window - - def call(self, inputs): - """Applies the layer. - - Args: - inputs: A `tuple` or `dict` containing the *k*-space data as defined by - `kspace_index`. If `operator` is a class not an instance, then `inputs` - must also contain any other arguments to be passed to the constructor of - `operator`. - - Returns: - The scaled k-space data. - """ - kspace, operator = self.parse_inputs(inputs) - filtered_kspace = signal_ops.filter_kspace( - kspace, - operator.trajectory, - filter_fn=self.calib_window, - filter_rank=operator.rank, - separable=True) - image = recon_adjoint.recon_adjoint(filtered_kspace, operator) - return kspace / tf.cast(tf.math.reduce_max(tf.math.abs(image)), - kspace.dtype) - - def get_config(self): - """Returns the config of the layer. - - Returns: - A `dict` describing the layer configuration. - """ - config = { - 'calib_window': self.calib_window - } - base_config = super().get_config() - kspace_index = base_config.pop('input_indices') - config['kspace_index'] = ( - kspace_index[0] if kspace_index is not None else None) - return {**config, **base_config} - - -@api_util.export("layers.KSpaceScaling2D") -@tf.keras.utils.register_keras_serializable(package='MRI') -class KSpaceScaling2D(KSpaceScaling): - def __init__(self, *args, **kwargs): - super().__init__(2, *args, **kwargs) - - -@api_util.export("layers.KSpaceScaling3D") -@tf.keras.utils.register_keras_serializable(package='MRI') -class KSpaceScaling3D(KSpaceScaling): - def __init__(self, *args, **kwargs): - super().__init__(3, *args, **kwargs) diff --git a/tensorflow_mri/python/layers/kspace_scaling_test.py b/tensorflow_mri/python/layers/kspace_scaling_test.py deleted file mode 100644 index 08f53e4b..00000000 --- a/tensorflow_mri/python/layers/kspace_scaling_test.py +++ /dev/null @@ -1,61 +0,0 @@ -# Copyright 2022 The TensorFlow MRI 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. -# ============================================================================== -"""Tests for module `kspace_scaling`.""" - -import tensorflow as tf - -from tensorflow_mri.python.layers import kspace_scaling -from tensorflow_mri.python.recon import recon_adjoint -from tensorflow_mri.python.util import test_util - - -class KSpaceScalingTest(test_util.TestCase): - """Tests for module `kspace_scaling`.""" - def test_kspace_scaling(self): - """Tests the k-space scaling layer.""" - layer = kspace_scaling.KSpaceScaling() - self.assertEqual(layer.dtype, "complex64") - - image_shape = tf.convert_to_tensor([4, 4]) - - kspace = tf.dtypes.complex( - tf.random.stateless_normal(shape=image_shape, seed=[11, 22]), - tf.random.stateless_normal(shape=image_shape, seed=[12, 34])) - - # This mask simulates the default filtering operation. - mask = tf.constant([[False, False, False, False], - [False, False, False, False], - [False, False, True, False], - [False, False, False, False]], dtype=tf.bool) - - filtered_kspace = tf.where(mask, kspace, tf.zeros_like(kspace)) - image = recon_adjoint.recon_adjoint_mri(filtered_kspace, image_shape) - expected = kspace / tf.cast(tf.math.reduce_max(tf.math.abs(image)), - kspace.dtype) - - # Test with tuple inputs. - inputs = (kspace, image_shape) - result = layer(inputs) - self.assertAllClose(expected, result) - - # Test with dict inputs. - inputs = {'kspace': kspace, 'image_shape': image_shape} - result = layer(inputs) - self.assertAllClose(expected, result) - - # Test (de)serialization. - layer = kspace_scaling.KSpaceScaling.from_config(layer.get_config()) - result = layer(inputs) - self.assertAllClose(expected, result) diff --git a/tensorflow_mri/python/layers/linear_operator_layer.py b/tensorflow_mri/python/layers/linear_operator_layer.py deleted file mode 100644 index 1a25f97d..00000000 --- a/tensorflow_mri/python/layers/linear_operator_layer.py +++ /dev/null @@ -1,112 +0,0 @@ -# Copyright 2022 The TensorFlow MRI 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. -# ============================================================================== -"""Linear operator layer.""" - -import tensorflow as tf - -from tensorflow_mri.python.linalg import linear_operator -from tensorflow_mri.python.linalg import linear_operator_mri - - -LINEAR_OPERATORS = { - 'MRI': linear_operator_mri.LinearOperatorMRI, - 'LinearOperatorMRI': linear_operator_mri.LinearOperatorMRI -} - - -class LinearOperatorLayer(tf.keras.layers.Layer): - """A layer that uses a linear operator (abstract base class).""" - def __init__(self, operator, input_indices=None, **kwargs): - super().__init__(**kwargs) - - if isinstance(operator, linear_operator.LinearOperator): - self._operator = operator - elif isinstance(operator, str): - if operator not in LINEAR_OPERATORS: - raise ValueError( - f"Unknown operator: {operator}. " - f"Valid strings are: {list(LINEAR_OPERATORS.keys())}") - self._operator = operator - elif callable(operator): - self._operator = operator - else: - raise TypeError( - f"`operator` must be a `tfmri.linalg.LinearOperator`, a `str`, or a " - f"callable object. Received: {operator}") - - if isinstance(input_indices, (int, str)): - input_indices = (input_indices,) - self._input_indices = input_indices - - def parse_inputs(self, inputs): - """Parses inputs to the layer. - - This function should typically be called at the beginning of the `call` - method. It returns the inputs and an instance of the linear operator to be - used. - """ - if isinstance(self._operator, linear_operator.LinearOperator): - # Operator already instantiated. Simply return. - return inputs, self._operator - - # Need to instantiate the operator. - if not isinstance(inputs, dict): - raise ValueError( - f"Layer {self.name} expected a mapping. " - f"Received: {inputs}") - - # If operator is a string, get corresponding class. - if isinstance(self._operator, str): - operator = LINEAR_OPERATORS[self._operator] - else: - operator = self._operator - - # Get main inputs (defined by input_indices). - if self._input_indices is None: - input_indices = (tuple(inputs.keys())[0],) - else: - input_indices = self._input_indices - main = tuple(inputs[i] for i in input_indices) - if len(main) == 1: - main = main[0] # Unpack single inputs. - - # Get remaining inputs and instantiate the operator. - kwargs = {k: v for k, v in inputs.items() if k not in input_indices} - operator = operator(**kwargs) - - return main, operator - - def get_config(self): - base_config = super().get_config() - config = { - 'operator': self._operator, - 'input_indices': self._input_indices - } - return {**config, **base_config} - - -class LinearTransform(LinearOperatorLayer): - """A layer that applies a linear transform to its inputs.""" - def __init__(self, - adjoint=False, - operator=linear_operator_mri.LinearOperatorMRI, - input_indices=None, - **kwargs): - super().__init__(operator=operator, input_indices=input_indices, **kwargs) - self.adjoint = adjoint - - def call(self, inputs): - main, operator = self.parse_inputs(inputs) - return operator.transform(main, adjoint=self.adjoint) diff --git a/tensorflow_mri/python/layers/recon_adjoint.py b/tensorflow_mri/python/layers/recon_adjoint.py deleted file mode 100644 index bd58a70b..00000000 --- a/tensorflow_mri/python/layers/recon_adjoint.py +++ /dev/null @@ -1,135 +0,0 @@ -# Copyright 2022 The TensorFlow MRI 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. -# ============================================================================== -"""Adjoint reconstruction layer.""" - -import string - -import tensorflow as tf - -from tensorflow_mri.python.layers import linear_operator_layer -from tensorflow_mri.python.ops import math_ops -from tensorflow_mri.python.recon import recon_adjoint -from tensorflow_mri.python.util import api_util -from tensorflow_mri.python.util import doc_util -from tensorflow_mri.python.util import keras_util - - -class ReconAdjoint(linear_operator_layer.LinearOperatorLayer): - r"""${rank}-D adjoint reconstruction layer. - - This layer reconstructs a signal using the adjoint of the specified system - operator. - - This layer can use the same operator instance in each invocation or - instantiate a new operator in each invocation, depending on whether the - operator remains constant or depends on the inputs to the layer. - - - If you wish to use the same operator instance during each call, initialize - the layer by setting `operator` to be an instance of a linear operator. - Then the call `inputs` are simply the input to the operator's `transform` - method (usually, the *k*-space data). - - - If you wish to instantiate a new operator during each call (e.g., because - the operator itself depends on the layer's inputs), initialize the layer by - setting `operator` to be a function that returns an instance of a linear - operator (or a string if you wish to use one of the built-in operators). - In this case the call `inputs` must be a `dict` containing both the inputs - to the operator's `transform` method (specified by `input_indices`) and the - any other inputs needed by the `operator` function to instantiate the - linear operator. - - Args: - expand_channel_dim: A `boolean`. Whether to expand the channel dimension. - If `True`, the output has shape `[*batch_shape, ${dim_names}, 1]`. - If `False`, the output has shape `[*batch_shape, ${dim_names}]`. - Defaults to `True`. - reinterpret_complex: A `boolean`. Whether to reinterpret a complex-valued - output image as a dual-channel real image. Defaults to `False`. - operator: A `tfmri.linalg.LinearOperator`, or a callable that returns a - `tfmri.linalg.LinearOperator`, or a `str` containing the name of one - of the built-in linear operators. The system operator. - - - If `operator` is a `tfmri.linalg.LinearOperator`, the operator will be - used as is during each invocation of the layer's `call` method. - - If `operator` is a generic callable, it will be called during each - invocation of the layer's `call` method to construct a new - `tfmri.linalg.LinearOperator`. The callable will be passed all of the - arguments in `inputs` except `kspace_index`. - - If `operator` is a `str`, it must be the name of one of the built-in - linear operators. See the `tfmri.linalg` module for a list of built-in - operators. The operator will be constructed during each invocation of - `call` using the arguments in `inputs` except `kspace_index`. - - Defaults to `'MRI'`, which creates a new `tfmri.linalg.LinearOperatorMRI` - during each invocation of `call`. - kspace_index: A `str`. The key of `inputs` containing the *k*-space data. - Defaults to `None`, which takes the first element of `inputs`. - """ - def __init__(self, - rank, - expand_channel_dim=True, - reinterpret_complex=False, - operator='MRI', - kspace_index=None, - **kwargs): - kwargs['dtype'] = kwargs.get('dtype') or keras_util.complexx() - super().__init__(operator=operator, input_indices=kspace_index, **kwargs) - self.rank = rank - self.expand_channel_dim = expand_channel_dim - self.reinterpret_complex = reinterpret_complex - - def call(self, inputs): - kspace, operator = self.parse_inputs(inputs) - image = recon_adjoint.recon_adjoint(kspace, operator) - if self.expand_channel_dim: - image = tf.expand_dims(image, axis=-1) - if self.reinterpret_complex: - image = math_ops.view_as_real(image, stacked=False) - return image - - def get_config(self): - config = { - 'expand_channel_dim': self.expand_channel_dim, - 'reinterpret_complex': self.reinterpret_complex - } - base_config = super().get_config() - input_indices = base_config.pop('input_indices') - config['kspace_index'] = ( - input_indices[0] if input_indices is not None else None) - return {**config, **base_config} - - -@api_util.export("layers.ReconAdjoint2D") -@tf.keras.utils.register_keras_serializable(package='MRI') -class ReconAdjoint2D(ReconAdjoint): - def __init__(self, *args, **kwargs): - super().__init__(2, *args, **kwargs) - - -@api_util.export("layers.ReconAdjoint3D") -@tf.keras.utils.register_keras_serializable(package='MRI') -class ReconAdjoint3D(ReconAdjoint): - def __init__(self, *args, **kwargs): - super().__init__(3, *args, **kwargs) - - -ReconAdjoint2D.__doc__ = string.Template(ReconAdjoint.__doc__).substitute( - rank=2, dim_names='height, width') -ReconAdjoint3D.__doc__ = string.Template(ReconAdjoint.__doc__).substitute( - rank=3, dim_names='depth, height, width') - - -ReconAdjoint2D.__signature__ = doc_util.get_nd_layer_signature(ReconAdjoint) -ReconAdjoint3D.__signature__ = doc_util.get_nd_layer_signature(ReconAdjoint) diff --git a/tensorflow_mri/python/layers/recon_adjoint_test.py b/tensorflow_mri/python/layers/recon_adjoint_test.py deleted file mode 100644 index 773556db..00000000 --- a/tensorflow_mri/python/layers/recon_adjoint_test.py +++ /dev/null @@ -1,68 +0,0 @@ -# Copyright 2022 The TensorFlow MRI 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. -# ============================================================================== -"""Tests for module `recon_adjoint`.""" - -import os -import tempfile - -from absl.testing import parameterized -import tensorflow as tf - -from tensorflow_mri.python.layers import recon_adjoint as recon_adjoint_layer -from tensorflow_mri.python.recon import recon_adjoint -from tensorflow_mri.python.util import test_util - - -class ReconAdjointTest(test_util.TestCase): - @parameterized.product(expand_channel_dim=[True, False]) - def test_recon_adjoint(self, expand_channel_dim): - # Create layer. - layer = recon_adjoint_layer.ReconAdjoint2D( - expand_channel_dim=expand_channel_dim) - - # Generate k-space data. - image_shape = tf.constant([4, 4]) - kspace = tf.dtypes.complex( - tf.random.stateless_normal(shape=image_shape, seed=[11, 22]), - tf.random.stateless_normal(shape=image_shape, seed=[12, 34])) - - # Reconstruct image. - expected = recon_adjoint.recon_adjoint_mri(kspace, image_shape) - if expand_channel_dim: - expected = tf.expand_dims(expected, axis=-1) - - # Test with dict inputs. - input_data = {'kspace': kspace, 'image_shape': image_shape} - result = layer(input_data) - self.assertAllClose(expected, result) - - # Test (de)serialization. - layer = recon_adjoint_layer.ReconAdjoint2D.from_config(layer.get_config()) - result = layer(input_data) - self.assertAllClose(expected, result) - - # Test in model. - inputs = {k: tf.keras.Input(shape=v.shape, dtype=v.dtype) - for k, v in input_data.items()} - model = tf.keras.Model(inputs, layer(inputs)) - result = model(input_data) - self.assertAllClose(expected, result) - - # Test saving/loading. - saved_model = os.path.join(tempfile.mkdtemp(), 'saved_model') - model.save(saved_model) - model = tf.keras.models.load_model(saved_model) - result = model(input_data) - self.assertAllClose(expected, result) diff --git a/tensorflow_mri/python/models/variational_network.py b/tensorflow_mri/python/models/variational_network.py deleted file mode 100644 index 6b6be994..00000000 --- a/tensorflow_mri/python/models/variational_network.py +++ /dev/null @@ -1,230 +0,0 @@ -# Copyright 2022 The TensorFlow MRI 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. -# ============================================================================== - -import string - -import tensorflow as tf - -from tensorflow_mri.python.activations import complex_activations -from tensorflow_mri.python.layers import data_consistency, normalization -from tensorflow_mri.python.models import graph_like_model -from tensorflow_mri.python.ops import math_ops -from tensorflow_mri.python.util import api_util -from tensorflow_mri.python.util import keras_util -from tensorflow_mri.python.util import layer_util -from tensorflow_mri.python.util import model_util - - -class VarNet(tf.keras.Model): - """${rank}-D variational network. - - This model can be used to reconstruct MR images from *k*-space measurements. - The architecture consists of an interleaved cascade of gradient descent (GD) - steps and neural networks (NNs). The GD steps incorporate the MRI encoding - operator and they minimize the error between the current *k*-space estimate - and the *k*-space measurements (data consistency). The NNs act as a - regularization term. - - This model is flexible. It supports Cartesian and non-Cartesian data and - single and multicoil inputs. The corresponding encoding operator is - auto-constructed internally based on the available inputs. See - `tfmri.linalg.LinearOperatorMRI` for more details on how this operator - is constructed. - - Notes: - Test note. - - References: - 1. Sriram A, Zbontar J, Murrell T, Defazio A, Zitnick CL, Yakubova N, - Knoll F, Johnson P. End-to-end variational networks for accelerated MRI - reconstruction. InInternational Conference on Medical Image Computing - and Computer-Assisted Intervention 2020 Oct 4 (pp. 64-73). Springer, - Cham. - 2. Hammernik K, Klatzer T, Kobler E, Recht MP, Sodickson DK, Pock T, - Knoll F. Learning a variational network for reconstruction of - accelerated MRI data. Magnetic resonance in medicine. - 2018 Jun;79(6):3055-71. - 3. Schlemper J, Salehi SS, Kundu P, Lazarus C, Dyvorne H, Rueckert D, - Sofka M. Nonuniform variational network: deep learning for accelerated - nonuniform MR image reconstruction. InInternational Conference on - Medical Image Computing and Computer-Assisted Intervention 2019 Oct 13 - (pp. 57-64). Springer, Cham. - """ - def __init__(self, - rank, - num_iterations=12, - calib_window=None, - reg_network='auto', - sens_network='auto', - compress_coils=True, - coil_compression_kwargs=None, - scale_kspace=True, - estimate_sensitivities=True, - reinterpret_complex=False, - return_rss=False, - return_multicoil=False, - return_zfill=False, - return_sensitivities=False, - kspace_index=None, - **kwargs): - kwargs['dtype'] = kwargs.get('dtype') or keras_util.complexx() - super().__init__(**kwargs) - self.rank = rank - self.num_iterations = num_iterations - self.calib_window = calib_window - self.reg_network = reg_network - self.sens_network = sens_network - self.compress_coils = compress_coils - self.coil_compression_kwargs = coil_compression_kwargs or {} - self.scale_kspace = scale_kspace - self.estimate_sensitivities = estimate_sensitivities - self.reinterpret_complex = reinterpret_complex - self.return_rss = return_rss - self.return_zfill = return_zfill - self.return_multicoil = return_multicoil - self.return_sensitivities = return_sensitivities - self.kspace_index = kspace_index - - lsgd_layer_class = data_consistency.LeastSquaresGradientDescent - lsgd_layers_kwargs = dict( - reinterpret_complex=self.reinterpret_complex - ) - - if self.reg_network == 'auto': - reg_network_class = lambda *args, name=None, **kwargs: normalization.Normalized( - model_util.get_nd_model('UNet', rank)(*args, **kwargs), - axis=list(range(-(self.rank + 1), 0)), name=name) - reg_network_kwargs = dict( - filters=[32, 64, 128], - kernel_size=3, - activation=(tf.keras.layers.LeakyReLU(alpha=0.2) - if self.reinterpret_complex - else complex_activations.complex_relu), - out_channels=2 if self.reinterpret_complex else 1, - kernel_initializer='he_uniform', - use_deconv=True, - use_instance_norm=True, - dtype=(tf.as_dtype(self.dtype).real_dtype.name - if self.reinterpret_complex else self.dtype) - ) - - if self.sens_network == 'auto': - sens_network = reg_network_class(**reg_network_kwargs) - - if self.compress_coils: - coil_compression_kwargs = _get_default_coil_compression_kwargs() - coil_compression_kwargs.update(self.coil_compression_kwargs) - self._coil_compression_layer = layer_util.get_nd_layer( - 'CoilCompression', self.rank)( - calib_window=self.calib_window, - coil_compression_kwargs=coil_compression_kwargs, - kspace_index=self.kspace_index) - - if self.scale_kspace: - self._kspace_scaling_layer = layer_util.get_nd_layer( - 'KSpaceScaling', self.rank)( - calib_window=self.calib_window, - kspace_index=self.kspace_index) - - if self.estimate_sensitivities: - self._coil_sensitivities_layer = layer_util.get_nd_layer( - 'CoilSensitivityEstimation', self.rank)( - calib_window=self.calib_window, - sens_network=sens_network, - reinterpret_complex=self.reinterpret_complex, - kspace_index=self.kspace_index) - - self._recon_adjoint_layer = layer_util.get_nd_layer( - 'ReconAdjoint', self.rank)( - reinterpret_complex=self.reinterpret_complex, - kspace_index=self.kspace_index) - - self._lsgd_layers = [ - lsgd_layer_class(**lsgd_layers_kwargs, name=f'lsgd_{i}') - for i in range(self.num_iterations)] - self._reg_layers = [ - reg_network_class(**reg_network_kwargs, name=f'reg_{i}') - for i in range(self.num_iterations)] - - # self._forward_layer = linear_operator_layer.LinearTransform(adjoint=False) - # self._adjoint_layer = linear_operator_layer.LinearTransform(adjoint=True) - - def call(self, inputs): - x = {k: v for k, v in inputs.items()} - - if self.compress_coils: - x['kspace'] = self._coil_compression_layer(x) - - if self.scale_kspace: - x['kspace'] = self._kspace_scaling_layer(x) - - if self.estimate_sensitivities: - x['sensitivities'] = self._coil_sensitivities_layer(x) - - zfill = self._recon_adjoint_layer(x) - - image = zfill - for lsgd, reg in zip(self._lsgd_layers, self._reg_layers): - image = reg(image) - image = lsgd({'image': image, **x}) - - if self.reinterpret_complex: - zfill = math_ops.view_as_complex(image, stacked=False) - image = math_ops.view_as_complex(image, stacked=False) - - if self.return_multicoil or self.return_rss: - multicoil = (tf.expand_dims(image, -(self.rank + 2)) * - tf.expand_dims(x['sensitivities'], -1)) - - if self.return_rss: - rss = tf.math.abs( - coil_ops.combine_coils(multicoil, coil_axis=-(self.rank + 2))) - - outputs = {'image': image} - - if self.return_rss: - outputs['rss'] = rss - if self.return_zfill: - outputs['zfill'] = zfill - if self.return_multicoil: - outputs['multicoil'] = multicoil - if self.return_sensitivities: - outputs['sensitivities'] = x['sensitivities'] - - return outputs - - -@api_util.export("models.VarNet2D") -@tf.keras.utils.register_keras_serializable(package='MRI') -class VarNet2D(VarNet): - def __init__(self, *args, **kwargs): - super().__init__(2, *args, **kwargs) - - -@api_util.export("models.VarNet3D") -@tf.keras.utils.register_keras_serializable(package='MRI') -class VarNet3D(VarNet): - def __init__(self, *args, **kwargs): - super().__init__(3, *args, **kwargs) - - -VarNet2D.__doc__ = string.Template(VarNet.__doc__).substitute(rank=2) -VarNet3D.__doc__ = string.Template(VarNet.__doc__).substitute(rank=3) - - -def _get_default_coil_compression_kwargs(): - return { - 'out_coils': 12 - } diff --git a/tensorflow_mri/python/models/variational_network_test.py b/tensorflow_mri/python/models/variational_network_test.py deleted file mode 100644 index e69de29b..00000000 From df0f3707006390fc88940ee218dbe83597568d4e Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 1 Sep 2022 12:32:46 +0000 Subject: [PATCH 074/101] Remove invalid imports --- tensorflow_mri/python/layers/__init__.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/tensorflow_mri/python/layers/__init__.py b/tensorflow_mri/python/layers/__init__.py index 5db028c7..44f0efac 100644 --- a/tensorflow_mri/python/layers/__init__.py +++ b/tensorflow_mri/python/layers/__init__.py @@ -15,14 +15,10 @@ """Keras layers.""" from tensorflow_mri.python.layers import convolutional -from tensorflow_mri.python.layers import coil_sensitivities from tensorflow_mri.python.layers import conv_blocks from tensorflow_mri.python.layers import conv_endec -from tensorflow_mri.python.layers import data_consistency -from tensorflow_mri.python.layers import kspace_scaling from tensorflow_mri.python.layers import normalization from tensorflow_mri.python.layers import pooling from tensorflow_mri.python.layers import preproc_layers -from tensorflow_mri.python.layers import recon_adjoint from tensorflow_mri.python.layers import reshaping from tensorflow_mri.python.layers import signal_layers From 01d02ef2c53f99a807c473cfd580894817373f0a Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 1 Sep 2022 12:35:14 +0000 Subject: [PATCH 075/101] Cleaning up --- tensorflow_mri/python/util/layer_util.py | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/tensorflow_mri/python/util/layer_util.py b/tensorflow_mri/python/util/layer_util.py index 4629fee5..a4064fb0 100644 --- a/tensorflow_mri/python/util/layer_util.py +++ b/tensorflow_mri/python/util/layer_util.py @@ -16,13 +16,9 @@ import tensorflow as tf -from tensorflow_mri.python.layers import coil_compression -from tensorflow_mri.python.layers import coil_sensitivities from tensorflow_mri.python.layers import convolutional -from tensorflow_mri.python.layers import kspace_scaling from tensorflow_mri.python.layers import padding from tensorflow_mri.python.layers import pooling -from tensorflow_mri.python.layers import recon_adjoint from tensorflow_mri.python.layers import reshaping from tensorflow_mri.python.layers import signal_layers @@ -51,10 +47,6 @@ def get_nd_layer(name, rank): ('AveragePooling', 1): pooling.AveragePooling1D, ('AveragePooling', 2): pooling.AveragePooling2D, ('AveragePooling', 3): pooling.AveragePooling3D, - ('CoilCompression', 2): coil_compression.CoilCompression2D, - ('CoilCompression', 3): coil_compression.CoilCompression3D, - ('CoilSensitivityEstimation', 2): coil_sensitivities.CoilSensitivityEstimation2D, - ('CoilSensitivityEstimation', 3): coil_sensitivities.CoilSensitivityEstimation3D, ('Conv', 1): convolutional.Conv1D, ('Conv', 2): convolutional.Conv2D, ('Conv', 3): convolutional.Conv3D, @@ -84,15 +76,11 @@ def get_nd_layer(name, rank): ('IDWT', 1): signal_layers.IDWT1D, ('IDWT', 2): signal_layers.IDWT2D, ('IDWT', 3): signal_layers.IDWT3D, - ('KSpaceScaling', 2): kspace_scaling.KSpaceScaling2D, - ('KSpaceScaling', 3): kspace_scaling.KSpaceScaling3D, ('LocallyConnected', 1): tf.keras.layers.LocallyConnected1D, ('LocallyConnected', 2): tf.keras.layers.LocallyConnected2D, ('MaxPool', 1): pooling.MaxPooling1D, ('MaxPool', 2): pooling.MaxPooling2D, ('MaxPool', 3): pooling.MaxPooling3D, - ('ReconAdjoint', 2): recon_adjoint.ReconAdjoint2D, - ('ReconAdjoint', 3): recon_adjoint.ReconAdjoint3D, ('SeparableConv', 1): tf.keras.layers.SeparableConv1D, ('SeparableConv', 2): tf.keras.layers.SeparableConv2D, ('SpatialDropout', 1): tf.keras.layers.SpatialDropout1D, From d93b99dc53ed96afc0ca5ada0965998fe142df52 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 1 Sep 2022 12:36:28 +0000 Subject: [PATCH 076/101] Cleaning up --- tensorflow_mri/python/models/__init__.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tensorflow_mri/python/models/__init__.py b/tensorflow_mri/python/models/__init__.py index 9df91f5a..3134681d 100644 --- a/tensorflow_mri/python/models/__init__.py +++ b/tensorflow_mri/python/models/__init__.py @@ -17,4 +17,3 @@ from tensorflow_mri.python.models import conv_blocks from tensorflow_mri.python.models import conv_endec from tensorflow_mri.python.models import graph_like_network -from tensorflow_mri.python.models import variational_network From eab692c557acafc1356e3fa9966cc8738c76aa67 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 1 Sep 2022 12:37:12 +0000 Subject: [PATCH 077/101] Working on universal coil compression --- .../python/coils/coil_compression.py | 137 +++++++++--------- 1 file changed, 70 insertions(+), 67 deletions(-) diff --git a/tensorflow_mri/python/coils/coil_compression.py b/tensorflow_mri/python/coils/coil_compression.py index 6fb50710..47ce5468 100644 --- a/tensorflow_mri/python/coils/coil_compression.py +++ b/tensorflow_mri/python/coils/coil_compression.py @@ -28,25 +28,27 @@ def compress_coils(kspace, out_coils=None, method='svd', **kwargs): - """Coil compression gateway. + """Compresses a multicoil *k*-space/image array. This function estimates a coil compression matrix and uses it to compress `kspace`. If you would like to reuse a coil compression matrix or need to - calibrate the compression using different data, use - `tfmri.coils.get_coil_compressor`. + calibrate the compression using different data, use one of the compressor + classes instead. This function supports the following coil compression methods: - * **SVD**: Based on direct singular-value decomposition (SVD) of *k*-space + - **SVD**: Based on direct singular-value decomposition (SVD) of *k*-space data [1]_. This coil compression method supports Cartesian and non-Cartesian data. This method is resilient to noise, but does not achieve optimal compression if there are fully-sampled dimensions. - .. * **Geometric**: Performs local compression along fully-sampled dimensions - .. to improve compression. This method only supports Cartesian data. This - .. method can suffer from low SNR in sections of k-space. - .. * **ESPIRiT**: Performs local compression along fully-sampled dimensions - .. and is robust to noise. This method only supports Cartesian data. + Args: kspace: A `Tensor`. The multi-coil *k*-space data. Must have type @@ -68,15 +70,15 @@ def compress_coils(kspace, other inputs and `...` are the unmodified encoding dimensions. References: - .. [1] Huang, F., Vijayakumar, S., Li, Y., Hertel, S. and Duensing, G.R. - (2008). A software channel compression technique for faster reconstruction - with many channels. Magn Reson Imaging, 26(1): 133-141. - .. [2] Zhang, T., Pauly, J.M., Vasanawala, S.S. and Lustig, M. (2013), Coil - compression for accelerated imaging with Cartesian sampling. Magn - Reson Med, 69: 571-582. https://doi.org/10.1002/mrm.24267 - .. [3] Bahri, D., Uecker, M., & Lustig, M. (2013). ESPIRIT-based coil - compression for cartesian sampling. In Proceedings of the 21st - Annual Meeting of ISMRM, Salt Lake City, Utah, USA (Vol. 47). + 1. Huang, F., Vijayakumar, S., Li, Y., Hertel, S. and Duensing, G.R. + (2008). A software channel compression technique for faster reconstruction + with many channels. Magn Reson Imaging, 26(1): 133-141. + 2. Zhang, T., Pauly, J.M., Vasanawala, S.S. and Lustig, M. (2013), Coil + compression for accelerated imaging with Cartesian sampling. Magn + Reson Med, 69: 571-582. https://doi.org/10.1002/mrm.24267 + 3. Bahri, D., Uecker, M., & Lustig, M. (2013). ESPIRIT-based coil + compression for cartesian sampling. In Proceedings of the 21st + Annual Meeting of ISMRM, Salt Lake City, Utah, USA (Vol. 47). """ return make_coil_compressor(method, coil_axis=coil_axis, @@ -279,52 +281,53 @@ def make_coil_compressor(method, **kwargs): raise NotImplementedError(f"Method {method} not implemented.") -# def compress_coils_with_calibration_data( -# kspace, -# operator, -# calib_data=None, -# calib_window=None, -# method='svd', -# **kwargs): -# # For convenience. -# rank = operator.rank - -# if calib_data is None: -# # Calibration data was not provided. Get calibration data by low-pass -# # filtering the input k-space. -# calib_data = signal_ops.filter_kspace( -# kspace, -# trajectory=operator.trajectory, -# filter_fn=calib_window, -# filter_rank=rank, -# separable=True) - -# # Reshape to single batch dimension. -# coil_axis = -2 if operator.is_non_cartesian else -(rank + 1) -# batch_shape_static = calib_data.shape[:coil_axis] -# batch_shape = tf.shape(calib_data)[:coil_axis] -# calib_shape = tf.shape(calib_data)[coil_axis:] -# calib_data = tf.reshape(calib_data, tf.concat([[-1], calib_shape], 0)) -# kspace_shape = tf.shape(kspace)[coil_axis:] -# kspace = tf.reshape(kspace, tf.concat([[-1], kspace_shape], 0)) - -# # Apply compression for each element in batch. -# def compress_coils_fn(inputs): -# ksp, cal = inputs -# return get_coil_compressor(method, -# coil_axis=coil_axis, -# **kwargs).fit(cal).transform(ksp) -# output_shape = [kwargs.get('out_coils')] + kspace.shape[2:].as_list() -# fn_output_signature = tf.TensorSpec(shape=output_shape, dtype=kspace.dtype) -# kspace = tf.map_fn(compress_coils_fn, (kspace, calib_data), -# fn_output_signature=fn_output_signature) - -# # Restore batch shape. -# output_shape = tf.shape(kspace)[1:] -# output_shape_static = kspace.shape[1:] -# kspace = tf.reshape(kspace, -# tf.concat([batch_shape, output_shape], 0)) -# kspace = tf.ensure_shape( -# kspace, batch_shape_static.concatenate(output_shape_static)) - -# return kspace +@api_util.export("coils.compress_coils_universal") +def compress_coils_universal( + meas_data, + operator, + calib_data=None, + calib_fn=None, + method='svd', + **kwargs): + # For convenience. + rank = operator.rank + + if calib_data is None: + # Calibration data was not provided. Get calibration data by low-pass + # filtering the input k-space. + calib_data = signal_ops.filter_kspace( + kspace, + trajectory=operator.trajectory, + filter_fn=calib_window, + filter_rank=rank, + separable=True) + + # Reshape to single batch dimension. + coil_axis = -2 if operator.is_non_cartesian else -(rank + 1) + batch_shape_static = calib_data.shape[:coil_axis] + batch_shape = tf.shape(calib_data)[:coil_axis] + calib_shape = tf.shape(calib_data)[coil_axis:] + calib_data = tf.reshape(calib_data, tf.concat([[-1], calib_shape], 0)) + kspace_shape = tf.shape(kspace)[coil_axis:] + kspace = tf.reshape(kspace, tf.concat([[-1], kspace_shape], 0)) + + # Apply compression for each element in batch. + def compress_coils_fn(inputs): + ksp, cal = inputs + return get_coil_compressor(method, + coil_axis=coil_axis, + **kwargs).fit(cal).transform(ksp) + output_shape = [kwargs.get('out_coils')] + kspace.shape[2:].as_list() + fn_output_signature = tf.TensorSpec(shape=output_shape, dtype=kspace.dtype) + kspace = tf.map_fn(compress_coils_fn, (kspace, calib_data), + fn_output_signature=fn_output_signature) + + # Restore batch shape. + output_shape = tf.shape(kspace)[1:] + output_shape_static = kspace.shape[1:] + kspace = tf.reshape(kspace, + tf.concat([batch_shape, output_shape], 0)) + kspace = tf.ensure_shape( + kspace, batch_shape_static.concatenate(output_shape_static)) + + return kspace From ff1e1634035af1d1c96f1b5aed37749275b5bca5 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 1 Sep 2022 13:19:41 +0000 Subject: [PATCH 078/101] Cleaning up --- tensorflow_mri/_api/activations/__init__.py | 3 + tensorflow_mri/_api/layers/__init__.py | 10 - tensorflow_mri/_api/models/__init__.py | 2 - tensorflow_mri/_api/signal/__init__.py | 6 +- tensorflow_mri/python/layers/__init__.py | 2 - tensorflow_mri/python/layers/conv_blocks.py | 244 ---------------- .../python/layers/conv_blocks_test.py | 75 ----- tensorflow_mri/python/layers/conv_endec.py | 274 ------------------ .../python/layers/conv_endec_test.py | 96 ------ 9 files changed, 6 insertions(+), 706 deletions(-) delete mode 100644 tensorflow_mri/python/layers/conv_blocks.py delete mode 100644 tensorflow_mri/python/layers/conv_blocks_test.py delete mode 100644 tensorflow_mri/python/layers/conv_endec.py delete mode 100644 tensorflow_mri/python/layers/conv_endec_test.py diff --git a/tensorflow_mri/_api/activations/__init__.py b/tensorflow_mri/_api/activations/__init__.py index 12abb9e8..33edf311 100644 --- a/tensorflow_mri/_api/activations/__init__.py +++ b/tensorflow_mri/_api/activations/__init__.py @@ -4,3 +4,6 @@ from tensorflow_mri.python.activations.complex_activations import complex_relu as complex_relu from tensorflow_mri.python.activations.complex_activations import mod_relu as mod_relu +from tensorflow_mri.python.activations import serialize as serialize +from tensorflow_mri.python.activations import deserialize as deserialize +from tensorflow_mri.python.activations import get as get diff --git a/tensorflow_mri/_api/layers/__init__.py b/tensorflow_mri/_api/layers/__init__.py index 0831f246..58fb6ba3 100644 --- a/tensorflow_mri/_api/layers/__init__.py +++ b/tensorflow_mri/_api/layers/__init__.py @@ -9,12 +9,6 @@ from tensorflow_mri.python.layers.convolutional import Conv3D as Conv3D from tensorflow_mri.python.layers.convolutional import Conv3D as Convolution3D from tensorflow_mri.python.layers.normalization import Normalized as Normalized -from tensorflow_mri.python.layers.coil_sensitivities import CoilSensitivityEstimation2D as CoilSensitivityEstimation2D -from tensorflow_mri.python.layers.coil_sensitivities import CoilSensitivityEstimation3D as CoilSensitivityEstimation3D -from tensorflow_mri.python.layers.conv_blocks import ConvBlock as ConvBlock -from tensorflow_mri.python.layers.conv_endec import UNet as UNet -from tensorflow_mri.python.layers.kspace_scaling import KSpaceScaling2D as KSpaceScaling2D -from tensorflow_mri.python.layers.kspace_scaling import KSpaceScaling3D as KSpaceScaling3D from tensorflow_mri.python.layers.pooling import AveragePooling1D as AveragePooling1D from tensorflow_mri.python.layers.pooling import AveragePooling1D as AvgPool1D from tensorflow_mri.python.layers.pooling import AveragePooling2D as AveragePooling2D @@ -27,8 +21,6 @@ from tensorflow_mri.python.layers.pooling import MaxPooling2D as MaxPool2D from tensorflow_mri.python.layers.pooling import MaxPooling3D as MaxPooling3D from tensorflow_mri.python.layers.pooling import MaxPooling3D as MaxPool3D -from tensorflow_mri.python.layers.recon_adjoint import ReconAdjoint2D as ReconAdjoint2D -from tensorflow_mri.python.layers.recon_adjoint import ReconAdjoint3D as ReconAdjoint3D from tensorflow_mri.python.layers.reshaping import UpSampling1D as UpSampling1D from tensorflow_mri.python.layers.reshaping import UpSampling2D as UpSampling2D from tensorflow_mri.python.layers.reshaping import UpSampling3D as UpSampling3D @@ -38,5 +30,3 @@ from tensorflow_mri.python.layers.signal_layers import IDWT1D as IDWT1D from tensorflow_mri.python.layers.signal_layers import IDWT2D as IDWT2D from tensorflow_mri.python.layers.signal_layers import IDWT3D as IDWT3D -from tensorflow_mri.python.layers.coil_compression import CoilCompression2D as CoilCompression2D -from tensorflow_mri.python.layers.coil_compression import CoilCompression3D as CoilCompression3D diff --git a/tensorflow_mri/_api/models/__init__.py b/tensorflow_mri/_api/models/__init__.py index 0d166ff0..1bbf6fe8 100644 --- a/tensorflow_mri/_api/models/__init__.py +++ b/tensorflow_mri/_api/models/__init__.py @@ -14,5 +14,3 @@ from tensorflow_mri.python.models.conv_endec import UNetLSTM1D as UNetLSTM1D from tensorflow_mri.python.models.conv_endec import UNetLSTM2D as UNetLSTM2D from tensorflow_mri.python.models.conv_endec import UNetLSTM3D as UNetLSTM3D -from tensorflow_mri.python.models.variational_network import VarNet2D as VarNet2D -from tensorflow_mri.python.models.variational_network import VarNet3D as VarNet3D diff --git a/tensorflow_mri/_api/signal/__init__.py b/tensorflow_mri/_api/signal/__init__.py index b6f632a6..fb4161e1 100644 --- a/tensorflow_mri/_api/signal/__init__.py +++ b/tensorflow_mri/_api/signal/__init__.py @@ -9,9 +9,6 @@ from tensorflow_mri.python.ops.wavelet_ops import dwt_max_level as max_wavelet_level from tensorflow_mri.python.ops.wavelet_ops import coeffs_to_tensor as wavelet_coeffs_to_tensor from tensorflow_mri.python.ops.wavelet_ops import tensor_to_coeffs as tensor_to_wavelet_coeffs -from tensorflow_mri.python.ops.fft_ops import fftn as fft -from tensorflow_mri.python.ops.fft_ops import ifftn as ifft -from tensorflow_nufft.python.ops.nufft_ops import nufft as nufft from tensorflow_mri.python.ops.signal_ops import hann as hann from tensorflow_mri.python.ops.signal_ops import hamming as hamming from tensorflow_mri.python.ops.signal_ops import atanfilt as atanfilt @@ -19,3 +16,6 @@ from tensorflow_mri.python.ops.signal_ops import separable_window as separable_window from tensorflow_mri.python.ops.signal_ops import filter_kspace as filter_kspace from tensorflow_mri.python.ops.signal_ops import crop_kspace as crop_kspace +from tensorflow_mri.python.ops.fft_ops import fftn as fft +from tensorflow_mri.python.ops.fft_ops import ifftn as ifft +from tensorflow_nufft.python.ops.nufft_ops import nufft as nufft diff --git a/tensorflow_mri/python/layers/__init__.py b/tensorflow_mri/python/layers/__init__.py index 44f0efac..d9692f0f 100644 --- a/tensorflow_mri/python/layers/__init__.py +++ b/tensorflow_mri/python/layers/__init__.py @@ -15,8 +15,6 @@ """Keras layers.""" from tensorflow_mri.python.layers import convolutional -from tensorflow_mri.python.layers import conv_blocks -from tensorflow_mri.python.layers import conv_endec from tensorflow_mri.python.layers import normalization from tensorflow_mri.python.layers import pooling from tensorflow_mri.python.layers import preproc_layers diff --git a/tensorflow_mri/python/layers/conv_blocks.py b/tensorflow_mri/python/layers/conv_blocks.py deleted file mode 100644 index 3efa492d..00000000 --- a/tensorflow_mri/python/layers/conv_blocks.py +++ /dev/null @@ -1,244 +0,0 @@ -# Copyright 2021 University College London. 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. -# ============================================================================== - -# Copyright 2021 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. -# ============================================================================== -"""Convolutional neural network blocks.""" - -import itertools - -import tensorflow as tf - -from tensorflow_mri.python.util import api_util -from tensorflow_mri.python.util import deprecation -from tensorflow_mri.python.util import check_util -from tensorflow_mri.python.util import layer_util - - -@api_util.export("layers.ConvBlock") -@tf.keras.utils.register_keras_serializable(package='MRI') -@deprecation.deprecated( - date=deprecation.REMOVAL_DATE['0.20.0'], - instructions='Use `tfmri.models.ConvBlockND` instead.') -class ConvBlock(tf.keras.layers.Layer): - """A basic convolution block. - - A Conv + BN + Activation block. The number of convolutional layers is - determined by `filters`. BN and activation are optional. - - Args: - filters: A list of `int` numbers or an `int` number of filters. Given an - `int` input, a single convolution is applied; otherwise a series of - convolutions are applied. - kernel_size: An integer or tuple/list of `rank` integers, specifying the - size of the convolution window. Can be a single integer to specify the - same value for all spatial dimensions. - strides: An integer or tuple/list of `rank` integers, specifying the strides - of the convolution along each spatial dimension. Can be a single integer - to specify the same value for all spatial dimensions. - rank: An integer specifying the number of spatial dimensions. Defaults to 2. - activation: A callable or a Keras activation identifier. The activation to - use in all layers. Defaults to `'relu'`. - out_activation: A callable or a Keras activation identifier. The activation - to use in the last layer. Defaults to `'same'`, in which case we use the - same activation as in previous layers as defined by `activation`. - use_bias: A `boolean`, whether the block's layers use bias vectors. Defaults - to `True`. - kernel_initializer: A `tf.keras.initializers.Initializer` or a Keras - initializer identifier. Initializer for convolutional kernels. Defaults to - `'VarianceScaling'`. - bias_initializer: A `tf.keras.initializers.Initializer` or a Keras - initializer identifier. Initializer for bias terms. Defaults to `'Zeros'`. - kernel_regularizer: A `tf.keras.initializers.Regularizer` or a Keras - regularizer identifier. Regularizer for convolutional kernels. Defaults to - `None`. - bias_regularizer: A `tf.keras.initializers.Regularizer` or a Keras - regularizer identifier. Regularizer for bias terms. Defaults to `None`. - use_batch_norm: If `True`, use batch normalization. Defaults to `False`. - use_sync_bn: If `True`, use synchronised batch normalization. Defaults to - `False`. - bn_momentum: A `float`. Momentum for the moving average in batch - normalization. - bn_epsilon: A `float`. Small float added to variance to avoid dividing by - zero during batch normalization. - use_residual: A `boolean`. If `True`, the input is added to the outputs to - create a residual learning block. Defaults to `False`. - use_dropout: A `boolean`. If `True`, a dropout layer is inserted after - each activation. Defaults to `False`. - dropout_rate: A `float`. The dropout rate. Only relevant if `use_dropout` is - `True`. Defaults to 0.3. - dropout_type: A `str`. The dropout type. Must be one of `'standard'` or - `'spatial'`. Standard dropout drops individual elements from the feature - maps, whereas spatial dropout drops entire feature maps. Only relevant if - `use_dropout` is `True`. Defaults to `'standard'`. - **kwargs: Additional keyword arguments to be passed to base class. - """ - def __init__(self, - filters, - kernel_size, - strides=1, - rank=2, - activation='relu', - out_activation='same', - use_bias=True, - kernel_initializer='VarianceScaling', - bias_initializer='Zeros', - kernel_regularizer=None, - bias_regularizer=None, - use_batch_norm=False, - use_sync_bn=False, - bn_momentum=0.99, - bn_epsilon=0.001, - use_residual=False, - use_dropout=False, - dropout_rate=0.3, - dropout_type='standard', - **kwargs): - """Create a basic convolution block.""" - super().__init__(**kwargs) - - self._filters = [filters] if isinstance(filters, int) else filters - self._kernel_size = kernel_size - self._strides = strides - self._rank = rank - self._activation = activation - self._out_activation = out_activation - self._use_bias = use_bias - self._kernel_initializer = kernel_initializer - self._bias_initializer = bias_initializer - self._kernel_regularizer = kernel_regularizer - self._bias_regularizer = bias_regularizer - self._use_batch_norm = use_batch_norm - self._use_sync_bn = use_sync_bn - self._bn_momentum = bn_momentum - self._bn_epsilon = bn_epsilon - self._use_residual = use_residual - self._use_dropout = use_dropout - self._dropout_rate = dropout_rate - self._dropout_type = check_util.validate_enum( - dropout_type, {'standard', 'spatial'}, 'dropout_type') - self._num_layers = len(self._filters) - - conv = layer_util.get_nd_layer('Conv', self._rank) - - if self._use_batch_norm: - if self._use_sync_bn: - bn = tf.keras.layers.experimental.SyncBatchNormalization - else: - bn = tf.keras.layers.BatchNormalization - - if self._use_dropout: - if self._dropout_type == 'standard': - dropout = tf.keras.layers.Dropout - elif self._dropout_type == 'spatial': - dropout = layer_util.get_nd_layer('SpatialDropout', self._rank) - - if tf.keras.backend.image_data_format() == 'channels_last': - self._channel_axis = -1 - else: - self._channel_axis = 1 - - self._convs = [] - self._norms = [] - self._dropouts = [] - for num_filters in self._filters: - self._convs.append( - conv(filters=num_filters, - kernel_size=self._kernel_size, - strides=self._strides, - padding='same', - data_format=None, - activation=None, - use_bias=self._use_bias, - kernel_initializer=self._kernel_initializer, - bias_initializer=self._bias_initializer, - kernel_regularizer=self._kernel_regularizer, - bias_regularizer=self._bias_regularizer)) - if self._use_batch_norm: - self._norms.append( - bn(axis=self._channel_axis, - momentum=self._bn_momentum, - epsilon=self._bn_epsilon)) - if self._use_dropout: - self._dropouts.append(dropout(rate=self._dropout_rate)) - - self._activation_fn = tf.keras.activations.get(self._activation) - if self._out_activation == 'same': - self._out_activation_fn = self._activation_fn - else: - self._out_activation_fn = tf.keras.activations.get(self._out_activation) - - def call(self, inputs, training=None): # pylint: disable=unused-argument, missing-param-doc - """Runs forward pass on the input tensor.""" - x = inputs - - for i, (conv, norm, dropout) in enumerate( - itertools.zip_longest(self._convs, self._norms, self._dropouts)): - # Convolution. - x = conv(x) - # Batch normalization. - if self._use_batch_norm: - x = norm(x, training=training) - # Activation. - if i == self._num_layers - 1: # Last layer. - x = self._out_activation_fn(x) - else: - x = self._activation_fn(x) - # Dropout. - if self._use_dropout: - x = dropout(x, training=training) - - # Residual connection. - if self._use_residual: - x += inputs - return x - - def get_config(self): - """Gets layer configuration.""" - config = { - 'filters': self._filters, - 'kernel_size': self._kernel_size, - 'strides': self._strides, - 'rank': self._rank, - 'activation': self._activation, - 'out_activation': self._out_activation, - 'use_bias': self._use_bias, - 'kernel_initializer': self._kernel_initializer, - 'bias_initializer': self._bias_initializer, - 'kernel_regularizer': self._kernel_regularizer, - 'bias_regularizer': self._bias_regularizer, - 'use_batch_norm': self._use_batch_norm, - 'use_sync_bn': self._use_sync_bn, - 'bn_momentum': self._bn_momentum, - 'bn_epsilon': self._bn_epsilon, - 'use_residual': self._use_residual, - 'use_dropout': self._use_dropout, - 'dropout_rate': self._dropout_rate, - 'dropout_type': self._dropout_type - } - base_config = super().get_config() - return {**base_config, **config} diff --git a/tensorflow_mri/python/layers/conv_blocks_test.py b/tensorflow_mri/python/layers/conv_blocks_test.py deleted file mode 100644 index dd8a8039..00000000 --- a/tensorflow_mri/python/layers/conv_blocks_test.py +++ /dev/null @@ -1,75 +0,0 @@ -# Copyright 2021 University College London. 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. -# ============================================================================== -"""Tests for module `conv_blocks`.""" - -from absl.testing import parameterized -import tensorflow as tf - -from tensorflow_mri.python.layers import conv_blocks -from tensorflow_mri.python.util import test_util - - -class ConvBlockTest(test_util.TestCase): - """Tests for `ConvBlock`.""" - @parameterized.parameters((64, 3, 2), (32, 3, 3)) - @test_util.run_in_graph_and_eager_modes - def test_conv_block_creation(self, filters, kernel_size, rank): # pylint: disable=missing-param-doc - """Test object creation.""" - inputs = tf.keras.Input( - shape=(128,) * rank + (32,), batch_size=1) - - block = conv_blocks.ConvBlock( - filters=filters, kernel_size=kernel_size) - - features = block(inputs) - - self.assertAllEqual(features.shape, [1] + [128] * rank + [filters]) - - - def test_serialize_deserialize(self): - """Test de/serialization.""" - config = dict( - filters=[32], - kernel_size=3, - strides=1, - rank=2, - activation='tanh', - out_activation='linear', - use_bias=False, - kernel_initializer='ones', - bias_initializer='ones', - kernel_regularizer='l2', - bias_regularizer='l1', - use_batch_norm=True, - use_sync_bn=True, - bn_momentum=0.98, - bn_epsilon=0.002, - use_residual=True, - use_dropout=True, - dropout_rate=0.5, - dropout_type='spatial', - name='conv_block', - dtype='float32', - trainable=True) - - block = conv_blocks.ConvBlock(**config) - self.assertEqual(block.get_config(), config) - - block2 = conv_blocks.ConvBlock.from_config(block.get_config()) - self.assertAllEqual(block.get_config(), block2.get_config()) - - -if __name__ == '__main__': - tf.test.main() diff --git a/tensorflow_mri/python/layers/conv_endec.py b/tensorflow_mri/python/layers/conv_endec.py deleted file mode 100644 index 65030aac..00000000 --- a/tensorflow_mri/python/layers/conv_endec.py +++ /dev/null @@ -1,274 +0,0 @@ -# Copyright 2021 University College London. 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. -# ============================================================================== -"""Convolutional encoder-decoder layers.""" - -import tensorflow as tf - -from tensorflow_mri.python.layers import conv_blocks -from tensorflow_mri.python.util import api_util -from tensorflow_mri.python.util import check_util -from tensorflow_mri.python.util import deprecation -from tensorflow_mri.python.util import layer_util - - -@api_util.export("layers.UNet") -@tf.keras.utils.register_keras_serializable(package='MRI') -@deprecation.deprecated( - date=deprecation.REMOVAL_DATE['0.20.0'], - instructions='Use `tfmri.models.UNetND` instead.') -class UNet(tf.keras.layers.Layer): - """A UNet layer. - - Args: - scales: The number of scales. `scales - 1` pooling layers will be added to - the model. Lowering the depth may reduce the amount of memory required for - training. - base_filters: The number of filters that the first layer in the - convolution network will have. The number of filters in following layers - will be calculated from this number. Lowering this number may reduce the - amount of memory required for training. - kernel_size: An integer or tuple/list of `rank` integers, specifying the - size of the convolution window. Can be a single integer to specify the - same value for all spatial dimensions. - pool_size: The pooling size for the pooling operations. Defaults to 2. - block_depth: The number of layers in each convolutional block. Defaults to - 2. - use_deconv: If `True`, transpose convolution (deconvolution) will be used - instead of up-sampling. This increases the amount memory required during - training. Defaults to `False`. - rank: An integer specifying the number of spatial dimensions. Defaults to 2. - activation: A callable or a Keras activation identifier. Defaults to - `'relu'`. - kernel_initializer: A `tf.keras.initializers.Initializer` or a Keras - initializer identifier. Initializer for convolutional kernels. Defaults to - `'VarianceScaling'`. - bias_initializer: A `tf.keras.initializers.Initializer` or a Keras - initializer identifier. Initializer for bias terms. Defaults to `'Zeros'`. - kernel_regularizer: A `tf.keras.initializers.Regularizer` or a Keras - regularizer identifier. Regularizer for convolutional kernels. Defaults to - `None`. - bias_regularizer: A `tf.keras.initializers.Regularizer` or a Keras - regularizer identifier. Regularizer for bias terms. Defaults to `None`. - use_batch_norm: If `True`, use batch normalization. Defaults to `False`. - use_sync_bn: If `True`, use synchronised batch normalization. Defaults to - `False`. - bn_momentum: A `float`. Momentum for the moving average in batch - normalization. - bn_epsilon: A `float`. Small float added to variance to avoid dividing by - zero during batch normalization. - out_channels: An `int`. The number of output channels. - out_activation: A callable or a Keras activation identifier. The output - activation. Defaults to `None`. - use_global_residual: A `boolean`. If `True`, adds a global residual - connection to create a residual learning network. Defaults to `False`. - use_dropout: A `boolean`. If `True`, a dropout layer is inserted after - each activation. Defaults to `False`. - dropout_rate: A `float`. The dropout rate. Only relevant if `use_dropout` is - `True`. Defaults to 0.3. - dropout_type: A `str`. The dropout type. Must be one of `'standard'` or - `'spatial'`. Standard dropout drops individual elements from the feature - maps, whereas spatial dropout drops entire feature maps. Only relevant if - `use_dropout` is `True`. Defaults to `'standard'`. - **kwargs: Additional keyword arguments to be passed to base class. - """ - def __init__(self, - scales, - base_filters, - kernel_size, - pool_size=2, - rank=2, - block_depth=2, - use_deconv=False, - activation='relu', - kernel_initializer='VarianceScaling', - bias_initializer='Zeros', - kernel_regularizer=None, - bias_regularizer=None, - use_batch_norm=False, - use_sync_bn=False, - bn_momentum=0.99, - bn_epsilon=0.001, - out_channels=None, - out_activation=None, - use_global_residual=False, - use_dropout=False, - dropout_rate=0.3, - dropout_type='standard', - **kwargs): - """Creates a UNet layer.""" - self._scales = scales - self._base_filters = base_filters - self._kernel_size = kernel_size - self._pool_size = pool_size - self._rank = rank - self._block_depth = block_depth - self._use_deconv = use_deconv - self._activation = activation - self._kernel_initializer = kernel_initializer - self._bias_initializer = bias_initializer - self._kernel_regularizer = kernel_regularizer - self._bias_regularizer = bias_regularizer - self._use_batch_norm = use_batch_norm - self._use_sync_bn = use_sync_bn - self._bn_momentum = bn_momentum - self._bn_epsilon = bn_epsilon - self._out_channels = out_channels - self._out_activation = out_activation - self._use_global_residual = use_global_residual - self._use_dropout = use_dropout - self._dropout_rate = dropout_rate - self._dropout_type = check_util.validate_enum( - dropout_type, {'standard', 'spatial'}, 'dropout_type') - - block_config = dict( - filters=None, # To be filled for each scale. - kernel_size=self._kernel_size, - strides=1, - rank=self._rank, - activation=self._activation, - kernel_initializer=self._kernel_initializer, - bias_initializer=self._bias_initializer, - kernel_regularizer=self._kernel_regularizer, - bias_regularizer=self._bias_regularizer, - use_batch_norm=self._use_batch_norm, - use_sync_bn=self._use_sync_bn, - bn_momentum=self._bn_momentum, - bn_epsilon=self._bn_epsilon, - use_dropout=self._use_dropout, - dropout_rate=self._dropout_rate, - dropout_type=self._dropout_type) - - pool = layer_util.get_nd_layer('MaxPool', self._rank) - if use_deconv: - upsamp = layer_util.get_nd_layer('ConvTranspose', self._rank) - upsamp_config = dict( - filters=None, # To be filled for each scale. - kernel_size=self._kernel_size, - strides=self._pool_size, - padding='same', - activation=None, - kernel_initializer=self._kernel_initializer, - bias_initializer=self._bias_initializer, - kernel_regularizer=self._kernel_regularizer, - bias_regularizer=self._bias_regularizer) - else: - upsamp = layer_util.get_nd_layer('UpSampling', self._rank) - upsamp_config = dict( - size=self._pool_size) - - if tf.keras.backend.image_data_format() == 'channels_last': - self._channel_axis = -1 - else: - self._channel_axis = 1 - - self._enc_blocks = [] - self._dec_blocks = [] - self._pools = [] - self._upsamps = [] - self._concats = [] - - # Configure backbone and decoder. - for scale in range(self._scales): - num_filters = base_filters * (2 ** scale) - block_config['filters'] = [num_filters] * self._block_depth - self._enc_blocks.append(conv_blocks.ConvBlock(**block_config)) - - if scale < self._scales - 1: - self._pools.append(pool( - pool_size=self._pool_size, - strides=self._pool_size, - padding='same')) - if use_deconv: - upsamp_config['filters'] = num_filters - self._upsamps.append(upsamp(**upsamp_config)) - self._concats.append(tf.keras.layers.Concatenate( - axis=self._channel_axis)) - self._dec_blocks.append(conv_blocks.ConvBlock(**block_config)) - - # Configure output block. - if self._out_channels is not None: - block_config['filters'] = self._out_channels - # If network is residual, the activation is performed after the residual - # addition. - if self._use_global_residual: - block_config['activation'] = None - else: - block_config['activation'] = self._out_activation - self._out_block = conv_blocks.ConvBlock(**block_config) - - # Configure residual addition, if requested. - if self._use_global_residual: - self._add = tf.keras.layers.Add() - self._out_activation_fn = tf.keras.activations.get(self._out_activation) - - super().__init__(**kwargs) - - def call(self, inputs, training=None): # pylint: disable=missing-param-doc,unused-argument - """Runs forward pass on the input tensors.""" - x = inputs - - # Backbone. - cache = [None] * (self._scales - 1) # For skip connections to decoder. - for scale in range(self._scales - 1): - cache[scale] = self._enc_blocks[scale](x) - x = self._pools[scale](cache[scale]) - x = self._enc_blocks[-1](x) - - # Decoder. - for scale in range(self._scales - 2, -1, -1): - x = self._upsamps[scale](x) - x = self._concats[scale]([x, cache[scale]]) - x = self._dec_blocks[scale](x) - - # Head. - if self._out_channels is not None: - x = self._out_block(x) - - # Global residual connection. - if self._use_global_residual: - x = self._add([x, inputs]) - if self._out_activation is not None: - x = self._out_activation_fn(x) - - return x - - def get_config(self): - """Gets layer configuration.""" - config = { - 'scales': self._scales, - 'base_filters': self._base_filters, - 'kernel_size': self._kernel_size, - 'pool_size': self._pool_size, - 'rank': self._rank, - 'block_depth': self._block_depth, - 'use_deconv': self._use_deconv, - 'activation': self._activation, - 'kernel_initializer': self._kernel_initializer, - 'bias_initializer': self._bias_initializer, - 'kernel_regularizer': self._kernel_regularizer, - 'bias_regularizer': self._bias_regularizer, - 'use_batch_norm': self._use_batch_norm, - 'use_sync_bn': self._use_sync_bn, - 'bn_momentum': self._bn_momentum, - 'bn_epsilon': self._bn_epsilon, - 'out_channels': self._out_channels, - 'out_activation': self._out_activation, - 'use_global_residual': self._use_global_residual, - 'use_dropout': self._use_dropout, - 'dropout_rate': self._dropout_rate, - 'dropout_type': self._dropout_type - } - base_config = super().get_config() - return {**base_config, **config} diff --git a/tensorflow_mri/python/layers/conv_endec_test.py b/tensorflow_mri/python/layers/conv_endec_test.py deleted file mode 100644 index 65c53310..00000000 --- a/tensorflow_mri/python/layers/conv_endec_test.py +++ /dev/null @@ -1,96 +0,0 @@ -# Copyright 2021 University College London. 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. -# ============================================================================== -"""Tests for module `conv_endec`.""" - -from absl.testing import parameterized -import tensorflow as tf - -from tensorflow_mri.python.layers import conv_endec -from tensorflow_mri.python.util import test_util - - -class UNetTest(test_util.TestCase): - """U-Net tests.""" - @parameterized.parameters((3, 16, 3, 2, None, True, False), - (2, 4, 3, 3, None, False, False), - (2, 8, 5, 2, 2, False, False), - (2, 8, 5, 2, 16, False, True)) - @test_util.run_in_graph_and_eager_modes - def test_unet_creation(self, # pylint: disable=missing-param-doc - scales, - base_filters, - kernel_size, - rank, - out_channels, - use_deconv, - use_global_residual): - """Test object creation.""" - inputs = tf.keras.Input( - shape=(128,) * rank + (16,), batch_size=1) - - network = conv_endec.UNet( - scales=scales, - base_filters=base_filters, - kernel_size=kernel_size, - rank=rank, - use_deconv=use_deconv, - out_channels=out_channels, - use_global_residual=use_global_residual) - - features = network(inputs) - if out_channels is None: - out_channels = base_filters - - self.assertAllEqual(features.shape, [1] + [128] * rank + [out_channels]) - - - def test_serialize_deserialize(self): - """Test de/serialization.""" - config = dict( - scales=3, - base_filters=16, - kernel_size=2, - pool_size=2, - rank=2, - block_depth=2, - use_deconv=True, - activation='tanh', - kernel_initializer='ones', - bias_initializer='ones', - kernel_regularizer='l2', - bias_regularizer='l1', - use_batch_norm=True, - use_sync_bn=True, - bn_momentum=0.98, - bn_epsilon=0.002, - out_channels=1, - out_activation='relu', - use_global_residual=True, - use_dropout=True, - dropout_rate=0.5, - dropout_type='spatial', - name='conv_block', - dtype='float32', - trainable=True) - - block = conv_endec.UNet(**config) - self.assertEqual(block.get_config(), config) - - block2 = conv_endec.UNet.from_config(block.get_config()) - self.assertAllEqual(block.get_config(), block2.get_config()) - - -if __name__ == '__main__': - tf.test.main() From 63e978811e9fc2038733a4d9e8b5cd9b30e85e77 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 1 Sep 2022 18:20:47 +0000 Subject: [PATCH 079/101] Refactoring linalg module, working on type spec for linear operators --- tensorflow_mri/_api/linalg/__init__.py | 6 +- tensorflow_mri/python/linalg/__init__.py | 4 +- .../python/linalg/conjugate_gradient.py | 17 +- .../python/linalg/linear_operator.py | 140 +++++++++- .../linalg/linear_operator_gram_matrix.py | 34 +-- .../python/linalg/linear_operator_gram_mri.py | 144 ---------- .../linalg/linear_operator_gram_mri_test.py | 76 ----- .../linalg/linear_operator_gram_nufft.py | 259 ------------------ .../linalg/linear_operator_gram_nufft_test.py | 77 ------ ...dentity.py => linear_operator_identity.py} | 40 ++- .../python/linalg/linear_operator_mri.py | 146 +++++++++- .../python/linalg/linear_operator_mri_test.py | 50 ++++ .../python/linalg/linear_operator_nufft.py | 239 ++++++++++++++++ .../linalg/linear_operator_nufft_test.py | 47 ++++ tensorflow_mri/python/ops/recon_ops.py | 3 +- 15 files changed, 664 insertions(+), 618 deletions(-) delete mode 100644 tensorflow_mri/python/linalg/linear_operator_gram_mri.py delete mode 100755 tensorflow_mri/python/linalg/linear_operator_gram_mri_test.py delete mode 100644 tensorflow_mri/python/linalg/linear_operator_gram_nufft.py delete mode 100755 tensorflow_mri/python/linalg/linear_operator_gram_nufft_test.py rename tensorflow_mri/python/linalg/{linear_operator_scaled_identity.py => linear_operator_identity.py} (76%) diff --git a/tensorflow_mri/_api/linalg/__init__.py b/tensorflow_mri/_api/linalg/__init__.py index 6876e706..eda23081 100644 --- a/tensorflow_mri/_api/linalg/__init__.py +++ b/tensorflow_mri/_api/linalg/__init__.py @@ -9,10 +9,10 @@ from tensorflow_mri.python.linalg.linear_operator_composition import LinearOperatorComposition as LinearOperatorComposition from tensorflow_mri.python.linalg.linear_operator_diag import LinearOperatorDiag as LinearOperatorDiag from tensorflow_mri.python.linalg.linear_operator_finite_difference import LinearOperatorFiniteDifference as LinearOperatorFiniteDifference -from tensorflow_mri.python.linalg.linear_operator_scaled_identity import LinearOperatorScaledIdentity as LinearOperatorScaledIdentity +from tensorflow_mri.python.linalg.linear_operator_identity import LinearOperatorScaledIdentity as LinearOperatorScaledIdentity from tensorflow_mri.python.linalg.linear_operator_gram_matrix import LinearOperatorGramMatrix as LinearOperatorGramMatrix from tensorflow_mri.python.linalg.linear_operator_nufft import LinearOperatorNUFFT as LinearOperatorNUFFT -from tensorflow_mri.python.linalg.linear_operator_gram_nufft import LinearOperatorGramNUFFT as LinearOperatorGramNUFFT +from tensorflow_mri.python.linalg.linear_operator_nufft import LinearOperatorGramNUFFT as LinearOperatorGramNUFFT from tensorflow_mri.python.linalg.linear_operator_mri import LinearOperatorMRI as LinearOperatorMRI -from tensorflow_mri.python.linalg.linear_operator_gram_mri import LinearOperatorGramMRI as LinearOperatorGramMRI +from tensorflow_mri.python.linalg.linear_operator_mri import LinearOperatorGramMRI as LinearOperatorGramMRI from tensorflow_mri.python.linalg.linear_operator_wavelet import LinearOperatorWavelet as LinearOperatorWavelet diff --git a/tensorflow_mri/python/linalg/__init__.py b/tensorflow_mri/python/linalg/__init__.py index a8797cd4..81eeafaa 100644 --- a/tensorflow_mri/python/linalg/__init__.py +++ b/tensorflow_mri/python/linalg/__init__.py @@ -21,10 +21,8 @@ from tensorflow_mri.python.linalg import linear_operator_diag from tensorflow_mri.python.linalg import linear_operator_finite_difference from tensorflow_mri.python.linalg import linear_operator_gram_matrix -from tensorflow_mri.python.linalg import linear_operator_gram_mri -from tensorflow_mri.python.linalg import linear_operator_gram_nufft +from tensorflow_mri.python.linalg import linear_operator_identity from tensorflow_mri.python.linalg import linear_operator_mri from tensorflow_mri.python.linalg import linear_operator_nufft -from tensorflow_mri.python.linalg import linear_operator_scaled_identity from tensorflow_mri.python.linalg import linear_operator_wavelet from tensorflow_mri.python.linalg import linear_operator diff --git a/tensorflow_mri/python/linalg/conjugate_gradient.py b/tensorflow_mri/python/linalg/conjugate_gradient.py index 4aba7357..7917d374 100644 --- a/tensorflow_mri/python/linalg/conjugate_gradient.py +++ b/tensorflow_mri/python/linalg/conjugate_gradient.py @@ -48,18 +48,19 @@ def conjugate_gradient(operator, name=None): r"""Conjugate gradient solver. - Solves a linear system of equations :math:`Ax = b` for self-adjoint, positive - definite matrix :math:`A` and right-hand side vector :math:`b`, using an - iterative, matrix-free algorithm where the action of the matrix :math:`A` is + Solves a linear system of equations $Ax = b$ for self-adjoint, positive + definite matrix $A$ and right-hand side vector $b$, using an + iterative, matrix-free algorithm where the action of the matrix $A$ is represented by `operator`. The iteration terminates when either the number of iterations exceeds `max_iterations` or when the residual norm has been reduced to `tol` times its initial value, i.e. - :math:`(\left\| b - A x_k \right\| <= \mathrm{tol} \left\| b \right\|\\)`. + $(\left\| b - A x_k \right\| <= \mathrm{tol} \left\| b \right\|\\)$. - .. note:: - This function is similar to - `tf.linalg.experimental.conjugate_gradient`, except it adds support for - complex-valued linear systems and for imaging operators. + ```{note} + This function is similar to + `tf.linalg.experimental.conjugate_gradient`, except it adds support for + complex-valued linear systems and for imaging operators. + ``` Args: operator: A `LinearOperator` that is self-adjoint and positive definite. diff --git a/tensorflow_mri/python/linalg/linear_operator.py b/tensorflow_mri/python/linalg/linear_operator.py index 4d6f5a84..7b95e99b 100644 --- a/tensorflow_mri/python/linalg/linear_operator.py +++ b/tensorflow_mri/python/linalg/linear_operator.py @@ -15,10 +15,11 @@ """Base linear operator.""" import abc -import functools +import numpy as np import tensorflow as tf -from tensorflow.python.ops.linalg import linear_operator +from tensorflow.python.framework import type_spec +from tensorflow.python.ops.linalg import linear_operator as tf_linear_operator from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import tensor_util @@ -494,5 +495,136 @@ def _batch_shape_tensor(self): return self.operator.batch_shape_tensor() -make_composite_tensor = functools.partial( - linear_operator.make_composite_tensor, module_name="tfmri.linalg") +class _LinearOperatorSpec(type_spec.BatchableTypeSpec): + """A tf.TypeSpec for `LinearOperator` objects. + + This is very similar to `tf.linalg.LinearOperatorSpec`, but it adds a + `shape` attribute which is required by Keras. + + Note that this attribute is redundant, as it can always be computed from + other attributes. However, the details of this computation vary between + operators, so its easier to just store it. + """ + __slots__ = ("_shape", + "_param_specs", + "_non_tensor_params", + "_prefer_static_fields") + + def __init__(self, + shape, + param_specs, + non_tensor_params, + prefer_static_fields): + """Initializes a new `_LinearOperatorSpec`. + + Args: + shape: A `tf.TensorShape`. + param_specs: Python `dict` of `tf.TypeSpec` instances that describe + kwargs to the `LinearOperator`'s constructor that are `Tensor`-like or + `CompositeTensor` subclasses. + non_tensor_params: Python `dict` containing non-`Tensor` and non- + `CompositeTensor` kwargs to the `LinearOperator`'s constructor. + prefer_static_fields: Python `tuple` of strings corresponding to the names + of `Tensor`-like args to the `LinearOperator`s constructor that may be + stored as static values, if known. These are typically shapes, indices, + or axis values. + """ + self._shape = shape + self._param_specs = param_specs + self._non_tensor_params = non_tensor_params + self._prefer_static_fields = prefer_static_fields + + @classmethod + def from_operator(cls, operator): + """Builds a `_LinearOperatorSpec` from a `LinearOperator` instance. + + Args: + operator: An instance of `LinearOperator`. + + Returns: + linear_operator_spec: An instance of `_LinearOperatorSpec` to be used as + the `TypeSpec` of `operator`. + """ + validation_fields = ("is_non_singular", "is_self_adjoint", + "is_positive_definite", "is_square") + kwargs = tf_linear_operator._extract_attrs( + operator, + keys=set(operator._composite_tensor_fields + validation_fields)) # pylint: disable=protected-access + + non_tensor_params = {} + param_specs = {} + for k, v in list(kwargs.items()): + type_spec_or_v = tf_linear_operator._extract_type_spec_recursively(v) + is_tensor = [isinstance(x, type_spec.TypeSpec) + for x in tf.nest.flatten(type_spec_or_v)] + if all(is_tensor): + param_specs[k] = type_spec_or_v + elif not any(is_tensor): + non_tensor_params[k] = v + else: + raise NotImplementedError(f"Field {k} contains a mix of `Tensor` and " + f" non-`Tensor` values.") + + return cls( + shape=operator.shape, + param_specs=param_specs, + non_tensor_params=non_tensor_params, + prefer_static_fields=operator._composite_tensor_prefer_static_fields) # pylint: disable=protected-access + + def _to_components(self, obj): + return tf_linear_operator._extract_attrs(obj, keys=list(self._param_specs)) + + def _from_components(self, components): + kwargs = dict(self._non_tensor_params, **components) + return self.value_type(**kwargs) + + @property + def _component_specs(self): + return self._param_specs + + def _serialize(self): + return (self._shape, + self._param_specs, + self._non_tensor_params, + self._prefer_static_fields) + + def _copy(self, **overrides): + kwargs = { + "shape": self._shape, + "param_specs": self._param_specs, + "non_tensor_params": self._non_tensor_params, + "prefer_static_fields": self._prefer_static_fields + } + kwargs.update(overrides) + return type(self)(**kwargs) + + def _batch(self, batch_size): + """Returns a TypeSpec representing a batch of objects with this TypeSpec.""" + return self._copy( + param_specs=tf.nest.map_structure( + lambda spec: spec._batch(batch_size), # pylint: disable=protected-access + self._param_specs)) + + def _unbatch(self, batch_size): + """Returns a TypeSpec representing a single element of this TypeSpec.""" + return self._copy( + param_specs=tf.nest.map_structure( + lambda spec: spec._unbatch(), # pylint: disable=protected-access + self._param_specs)) + + @property + def shape(self): + return self._shape + + +def make_composite_tensor(cls, module_name="tfmri.linalg"): + """Class decorator to convert `LinearOperator`s to `CompositeTensor`s. + + Overrides the default `make_composite_tensor` to use the custom + `LinearOperatorSpec`. + """ + spec_name = "{}Spec".format(cls.__name__) + spec_type = type(spec_name, (_LinearOperatorSpec,), {"value_type": cls}) + type_spec.register("{}.{}".format(module_name, spec_name))(spec_type) + cls._type_spec = property(spec_type.from_operator) # pylint: disable=protected-access + return cls diff --git a/tensorflow_mri/python/linalg/linear_operator_gram_matrix.py b/tensorflow_mri/python/linalg/linear_operator_gram_matrix.py index 552e003b..78df3c19 100644 --- a/tensorflow_mri/python/linalg/linear_operator_gram_matrix.py +++ b/tensorflow_mri/python/linalg/linear_operator_gram_matrix.py @@ -19,7 +19,7 @@ from tensorflow_mri.python.linalg import linear_operator from tensorflow_mri.python.linalg import linear_operator_addition from tensorflow_mri.python.linalg import linear_operator_composition -from tensorflow_mri.python.linalg import linear_operator_scaled_identity +from tensorflow_mri.python.linalg import linear_operator_identity from tensorflow_mri.python.util import api_util @@ -27,41 +27,41 @@ class LinearOperatorGramMatrix(linear_operator.LinearOperator): # pylint: disable=abstract-method r"""Linear operator representing the Gram matrix of an operator. - If :math:`A` is a `LinearOperator`, this operator is equivalent to - :math:`A^H A`. + If $A$ is a `LinearOperator`, this operator is equivalent to + $A^H A$. - The Gram matrix of :math:`A` appears in the normal equation - :math:`A^H A x = A^H b` associated with the least squares problem - :math:`{\mathop{\mathrm{argmin}}_x} {\left \| Ax-b \right \|_2^2}`. + The Gram matrix of $A$ appears in the normal equation + $A^H A x = A^H b$ associated with the least squares problem + ${\mathop{\mathrm{argmin}}_x} {\left \| Ax-b \right \|_2^2}$. This operator is self-adjoint and positive definite. Therefore, linear systems defined by this linear operator can be solved using the conjugate gradient method. This operator supports the optional addition of a regularization parameter - :math:`\lambda` and a transform matrix :math:`T`. If these are provided, - this operator becomes :math:`A^H A + \lambda T^H T`. This appears + $\lambda$ and a transform matrix $T$. If these are provided, + this operator becomes $A^H A + \lambda T^H T$. This appears in the regularized normal equation - :math:`\left ( A^H A + \lambda T^H T \right ) x = A^H b + \lambda T^H T x_0`, + $\left ( A^H A + \lambda T^H T \right ) x = A^H b + \lambda T^H T x_0$, associated with the regularized least squares problem - :math:`{\mathop{\mathrm{argmin}}_x} {\left \| Ax-b \right \|_2^2 + \lambda \left \| T(x-x_0) \right \|_2^2}`. + ${\mathop{\mathrm{argmin}}_x} {\left \| Ax-b \right \|_2^2 + \lambda \left \| T(x-x_0) \right \|_2^2}$. Args: - operator: A `tfmri.linalg.LinearOperator`. The operator :math:`A` whose Gram + operator: A `tfmri.linalg.LinearOperator`. The operator $A$ whose Gram matrix is represented by this linear operator. reg_parameter: A `Tensor` of shape `[B1, ..., Bb]` and real dtype. - The regularization parameter :math:`\lambda`. Defaults to 0. + The regularization parameter $\lambda$. Defaults to 0. reg_operator: A `tfmri.linalg.LinearOperator`. The regularization transform - :math:`T`. Defaults to the identity. + $T$. Defaults to the identity. gram_operator: A `tfmri.linalg.LinearOperator`. The Gram matrix - :math:`A^H A`. This may be optionally provided to use a specialized + $A^H A$. This may be optionally provided to use a specialized Gram matrix implementation. Defaults to `None`. is_non_singular: Expect that this operator is non-singular. is_self_adjoint: Expect that this operator is equal to its Hermitian transpose. is_positive_definite: Expect that this operator is positive definite, - meaning the quadratic form :math:`x^H A x` has positive real part for all - nonzero :math:`x`. Note that we do not require the operator to be + meaning the quadratic form $x^H A x$ has positive real part for all + nonzero $x$. Note that we do not require the operator to be self-adjoint to be positive-definite. is_square: Expect that this operator acts like square [batch] matrices. name: A name for this `LinearOperator`. @@ -103,7 +103,7 @@ def __init__(self, raise ValueError("A Gram matrix is always square.") if self._reg_parameter is not None: - reg_operator_gm = linear_operator_scaled_identity.LinearOperatorScaledIdentity( + reg_operator_gm = linear_operator_identity.LinearOperatorScaledIdentity( shape=self._operator.domain_shape, multiplier=tf.cast(self._reg_parameter, self._operator.dtype)) if self._reg_operator is not None: diff --git a/tensorflow_mri/python/linalg/linear_operator_gram_mri.py b/tensorflow_mri/python/linalg/linear_operator_gram_mri.py deleted file mode 100644 index ca99548d..00000000 --- a/tensorflow_mri/python/linalg/linear_operator_gram_mri.py +++ /dev/null @@ -1,144 +0,0 @@ -# Copyright 2021 University College London. 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. -# ============================================================================== -"""Linear algebra operations. - -This module contains linear operators and solvers. -""" - -import collections - -import tensorflow as tf - -from tensorflow_mri.python.util import api_util -from tensorflow_mri.python.linalg import linear_operator_gram_nufft -from tensorflow_mri.python.linalg import linear_operator_mri - - -@api_util.export("linalg.LinearOperatorGramMRI") -class LinearOperatorGramMRI(linear_operator_mri.LinearOperatorMRI): # pylint: disable=abstract-method - """Linear operator representing an MRI encoding matrix. - - If :math:`A` is a `tfmri.linalg.LinearOperatorMRI`, then this ooperator - represents the matrix :math:`G = A^H A`. - - In certain circumstances, this operator may be able to apply the matrix - :math:`G` more efficiently than the composition :math:`G = A^H A` using - `tfmri.linalg.LinearOperatorMRI` objects. - - Args: - image_shape: A `tf.TensorShape` or a list of `ints`. The shape of the images - that this operator acts on. Must have length 2 or 3. - extra_shape: An optional `tf.TensorShape` or list of `ints`. Additional - dimensions that should be included within the operator domain. Note that - `extra_shape` is not needed to reconstruct independent batches of images. - However, it is useful when this operator is used as part of a - reconstruction that performs computation along non-spatial dimensions, - e.g. for temporal regularization. Defaults to `None`. - mask: An optional `tf.Tensor` of type `tf.bool`. The sampling mask. Must - have shape `[..., *S]`, where `S` is the `image_shape` and `...` is - the batch shape, which can have any number of dimensions. If `mask` is - passed, this operator represents an undersampled MRI operator. - trajectory: An optional `tf.Tensor` of type `float32` or `float64`. Must - have shape `[..., M, N]`, where `N` is the rank (number of spatial - dimensions), `M` is the number of samples in the encoded space and `...` - is the batch shape, which can have any number of dimensions. If - `trajectory` is passed, this operator represents a non-Cartesian MRI - operator. - density: An optional `tf.Tensor` of type `float32` or `float64`. The - sampling densities. Must have shape `[..., M]`, where `M` is the number of - samples and `...` is the batch shape, which can have any number of - dimensions. This input is only relevant for non-Cartesian MRI operators. - If passed, the non-Cartesian operator will include sampling density - compensation. If `None`, the operator will not perform sampling density - compensation. - sensitivities: An optional `tf.Tensor` of type `complex64` or `complex128`. - The coil sensitivity maps. Must have shape `[..., C, *S]`, where `S` - is the `image_shape`, `C` is the number of coils and `...` is the batch - shape, which can have any number of dimensions. - phase: An optional `tf.Tensor` of type `float32` or `float64`. A phase - estimate for the image. If provided, this operator will be - phase-constrained. - fft_norm: FFT normalization mode. Must be `None` (no normalization) - or `'ortho'`. Defaults to `'ortho'`. - sens_norm: A `boolean`. Whether to normalize coil sensitivities. Defaults to - `True`. - dynamic_domain: A `str`. The domain of the dynamic dimension, if present. - Must be one of `'time'` or `'frequency'`. May only be provided together - with a non-scalar `extra_shape`. The dynamic dimension is the last - dimension of `extra_shape`. The `'time'` mode (default) should be - used for regular dynamic reconstruction. The `'frequency'` mode should be - used for reconstruction in x-f space. - toeplitz_nufft: A `boolean`. If `True`, uses the Toeplitz approach [5] - to compute :math:`F^H F x`, where :math:`F` is the non-uniform Fourier - operator. If `False`, the same operation is performed using the standard - NUFFT operation. The Toeplitz approach might be faster than the direct - approach but is slightly less accurate. This argument is only relevant - for non-Cartesian reconstruction and will be ignored for Cartesian - problems. - dtype: A `tf.dtypes.DType`. The dtype of this operator. Must be `complex64` - or `complex128`. Defaults to `complex64`. - name: An optional `str`. The name of this operator. - """ - def __init__(self, - image_shape, - extra_shape=None, - mask=None, - trajectory=None, - density=None, - sensitivities=None, - phase=None, - fft_norm='ortho', - sens_norm=True, - dynamic_domain=None, - toeplitz_nufft=False, - dtype=tf.complex64, - name="LinearOperatorGramMRI"): - super().__init__( - image_shape, - extra_shape=extra_shape, - mask=mask, - trajectory=trajectory, - density=density, - sensitivities=sensitivities, - phase=phase, - fft_norm=fft_norm, - sens_norm=sens_norm, - dynamic_domain=dynamic_domain, - dtype=dtype, - name=name - ) - - self.toeplitz_nufft = toeplitz_nufft - if self.toeplitz_nufft and self.is_non_cartesian: - # Create a Gram NUFFT operator with Toeplitz embedding. - self._linop_gram_nufft = linear_operator_gram_nufft.LinearOperatorGramNUFFT( - image_shape, trajectory=self._trajectory, density=self._density, - norm=fft_norm, toeplitz=True) - # Disable NUFFT computation on base class. The NUFFT will instead be - # performed by the Gram NUFFT operator. - self._skip_nufft = True - - def _transform(self, x, adjoint=False): - x = super()._transform(x) - if self.toeplitz_nufft: - x = self._linop_gram_nufft.transform(x) - x = super()._transform(x, adjoint=True) - return x - - def _range_shape(self): - return self._domain_shape() - - def _range_shape_tensor(self): - return self._domain_shape_tensor() diff --git a/tensorflow_mri/python/linalg/linear_operator_gram_mri_test.py b/tensorflow_mri/python/linalg/linear_operator_gram_mri_test.py deleted file mode 100755 index da93a00b..00000000 --- a/tensorflow_mri/python/linalg/linear_operator_gram_mri_test.py +++ /dev/null @@ -1,76 +0,0 @@ -# Copyright 2021 University College London. 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. -# ============================================================================== -"""Tests for module `linear_operator_gram_mri`.""" -# pylint: disable=missing-class-docstring,missing-function-docstring - -from absl.testing import parameterized -import tensorflow as tf - -from tensorflow_mri.python.linalg import linear_operator_gram_mri -from tensorflow_mri.python.ops import image_ops -from tensorflow_mri.python.ops import traj_ops -from tensorflow_mri.python.util import test_util - - -class LinearOperatorGramMRITest(test_util.TestCase): - @parameterized.product(batch=[False, True], extra=[False, True], - toeplitz_nufft=[False, True]) - def test_general(self, batch, extra, toeplitz_nufft): - resolution = 128 - image_shape = [resolution, resolution] - num_coils = 4 - image, sensitivities = image_ops.phantom( - shape=image_shape, num_coils=num_coils, dtype=tf.complex64, - return_sensitivities=True) - image = image_ops.phantom(shape=image_shape, dtype=tf.complex64) - trajectory = traj_ops.radial_trajectory(resolution, resolution // 2 + 1, - flatten_encoding_dims=True) - density = traj_ops.radial_density(resolution, resolution // 2 + 1, - flatten_encoding_dims=True) - if batch: - image = tf.stack([image, image * 2]) - if extra: - extra_shape = [2] - else: - extra_shape = None - else: - extra_shape = None - - linop = linear_operator_gram_mri.LinearOperatorMRI( - image_shape, extra_shape=extra_shape, - trajectory=trajectory, density=density, - sensitivities=sensitivities) - linop_gram = linear_operator_gram_mri.LinearOperatorGramMRI( - image_shape, extra_shape=extra_shape, - trajectory=trajectory, density=density, - sensitivities=sensitivities, toeplitz_nufft=toeplitz_nufft) - - # Test shapes. - expected_domain_shape = image_shape - if extra_shape is not None: - expected_domain_shape = extra_shape + image_shape - self.assertAllClose(expected_domain_shape, linop_gram.domain_shape) - self.assertAllClose(expected_domain_shape, linop_gram.domain_shape_tensor()) - self.assertAllClose(expected_domain_shape, linop_gram.range_shape) - self.assertAllClose(expected_domain_shape, linop_gram.range_shape_tensor()) - - # Test transform. - expected = linop.transform(linop.transform(image), adjoint=True) - self.assertAllClose(expected, linop_gram.transform(image), - rtol=1e-4, atol=1e-4) - - -if __name__ == '__main__': - tf.test.main() diff --git a/tensorflow_mri/python/linalg/linear_operator_gram_nufft.py b/tensorflow_mri/python/linalg/linear_operator_gram_nufft.py deleted file mode 100644 index 4da917dd..00000000 --- a/tensorflow_mri/python/linalg/linear_operator_gram_nufft.py +++ /dev/null @@ -1,259 +0,0 @@ -# Copyright 2021 University College London. 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. -# ============================================================================== -"""Gram matrix of an NUFFT linear operator.""" - -import tensorflow as tf - -from tensorflow_mri.python.ops import array_ops -from tensorflow_mri.python.ops import fft_ops -from tensorflow_mri.python.util import api_util -from tensorflow_mri.python.linalg import linear_operator_nufft - - -@api_util.export("linalg.LinearOperatorGramNUFFT") -class LinearOperatorGramNUFFT(linear_operator_nufft.LinearOperatorNUFFT): # pylint: disable=abstract-method - """Linear operator acting like the Gram matrix of an NUFFT operator. - - If :math:`F` is a `tfmri.linalg.LinearOperatorNUFFT`, then this operator - applies :math:`F^H F`. This operator is self-adjoint. - - Args: - domain_shape: A 1D integer `tf.Tensor`. The domain shape of this - operator. This is usually the shape of the image but may include - additional dimensions. - trajectory: A `tf.Tensor` of type `float32` or `float64`. Contains the - sampling locations or *k*-space trajectory. Must have shape - `[..., M, N]`, where `N` is the rank (number of dimensions), `M` is - the number of samples and `...` is the batch shape, which can have any - number of dimensions. - density: A `tf.Tensor` of type `float32` or `float64`. Contains the - sampling density at each point in `trajectory`. Must have shape - `[..., M]`, where `M` is the number of samples and `...` is the batch - shape, which can have any number of dimensions. Defaults to `None`, in - which case the density is assumed to be 1.0 in all locations. - norm: A `str`. The FFT normalization mode. Must be `None` (no normalization) - or `'ortho'`. - toeplitz: A `boolean`. If `True`, uses the Toeplitz approach [1] - to compute :math:`F^H F x`, where :math:`F` is the NUFFT operator. - If `False`, the same operation is performed using the standard - NUFFT operation. The Toeplitz approach might be faster than the direct - approach but is slightly less accurate. This argument is only relevant - for non-Cartesian reconstruction and will be ignored for Cartesian - problems. - name: An optional `str`. The name of this operator. - - References: - [1] Fessler, J. A., Lee, S., Olafsson, V. T., Shi, H. R., & Noll, D. C. - (2005). Toeplitz-based iterative image reconstruction for MRI with - correction for magnetic field inhomogeneity. IEEE Transactions on Signal - Processing, 53(9), 3393-3402. - """ - def __init__(self, - domain_shape, - trajectory, - density=None, - norm='ortho', - toeplitz=False, - name="LinearOperatorNUFFT"): - super().__init__( - domain_shape=domain_shape, - trajectory=trajectory, - density=density, - norm=norm, - name=name - ) - - self.toeplitz = toeplitz - if self.toeplitz: - # Compute the FFT shift for adjoint NUFFT computation. - self._fft_shift = tf.cast(self._grid_shape // 2, self.dtype.real_dtype) - # Compute the Toeplitz kernel. - self._toeplitz_kernel = self._compute_toeplitz_kernel() - # Kernel shape (without batch dimensions). - self._kernel_shape = tf.shape(self._toeplitz_kernel)[-self.rank_tensor():] - - def _transform(self, x, adjoint=False): # pylint: disable=unused-argument - """Applies this linear operator.""" - # This operator is self-adjoint, so `adjoint` arg is unused. - if self.toeplitz: - # Using specialized Toeplitz implementation. - return self._transform_toeplitz(x) - # Using standard NUFFT implementation. - return super()._transform(super()._transform(x), adjoint=True) - - def _transform_toeplitz(self, x): - """Applies this linear operator using the Toeplitz approach.""" - input_shape = tf.shape(x) - fft_axes = tf.range(-self.rank_tensor(), 0) - x = fft_ops.fftn(x, axes=fft_axes, shape=self._kernel_shape) - x *= self._toeplitz_kernel - x = fft_ops.ifftn(x, axes=fft_axes) - x = tf.slice(x, tf.zeros([tf.rank(x)], dtype=tf.int32), input_shape) - return x - - def _compute_toeplitz_kernel(self): - """Computes the kernel for the Toeplitz approach.""" - trajectory = self.trajectory - weights = self.weights - if self.rank is None: - raise NotImplementedError( - f"The rank of {self.name} must be known statically.") - - if weights is None: - # If no weights were passed, use ones. - weights = tf.ones(tf.shape(trajectory)[:-1], dtype=self.dtype.real_dtype) - # Cast weights to complex dtype. - weights = tf.cast(tf.math.sqrt(weights), self.dtype) - - # Compute N-D kernel recursively. Begin with last axis. - last_axis = self.rank - 1 - kernel = self._compute_kernel_recursive(trajectory, weights, last_axis) - - # Make sure that the kernel is symmetric/Hermitian/self-adjoint. - kernel = self._enforce_kernel_symmetry(kernel) - - # Additional normalization by sqrt(2 ** rank). This is required because - # we are using FFTs with twice the length of the original image. - if self.norm == 'ortho': - kernel *= tf.cast(tf.math.sqrt(2.0 ** self.rank), kernel.dtype) - - # Put the kernel in Fourier space. - fft_axes = list(range(-self.rank, 0)) - fft_norm = self.norm or "backward" - return fft_ops.fftn(kernel, axes=fft_axes, norm=fft_norm) - - def _compute_kernel_recursive(self, trajectory, weights, axis): - """Recursively computes the kernel for the Toeplitz approach. - - This function works by computing the two halves of the kernel along each - axis. The "left" half is computed using the input trajectory. The "right" - half is computed using the trajectory flipped along the current axis, and - then reversed. Then the two halves are concatenated, with a block of zeros - inserted in between. If there is more than one axis, the process is repeated - recursively for each axis. - - This function calls the adjoint NUFFT 2 ** N times, where N is the number - of dimensions. NOTE: this could be optimized to 2 ** (N - 1) calls. - - Args: - trajectory: A `tf.Tensor` containing the current *k*-space trajectory. - weights: A `tf.Tensor` containing the current density compensation - weights. - axis: An `int` denoting the current axis. - - Returns: - A `tf.Tensor` containing the kernel. - - Raises: - NotImplementedError: If the rank of the operator is not known statically. - """ - # Account for the batch dimensions. We do not need to do the recursion - # for these. - batch_dims = self.batch_shape.rank - if batch_dims is None: - raise NotImplementedError( - f"The number of batch dimensions of {self.name} must be known " - f"statically.") - # The current axis without the batch dimensions. - image_axis = axis + batch_dims - if axis == 0: - # Outer-most axis. Compute left half, then use Hermitian symmetry to - # compute right half. - # TODO(jmontalt): there should be a way to compute the NUFFT only once. - kernel_left = self._nufft_adjoint(weights, trajectory) - flippings = tf.tensor_scatter_nd_update( - tf.ones([self.rank_tensor()]), [[axis]], [-1]) - kernel_right = self._nufft_adjoint(weights, trajectory * flippings) - else: - # We still have two or more axes to process. Compute left and right kernels - # by calling this function recursively. We call ourselves twice, first - # with current frequencies, then with negated frequencies along current - # axes. - kernel_left = self._compute_kernel_recursive( - trajectory, weights, axis - 1) - flippings = tf.tensor_scatter_nd_update( - tf.ones([self.rank_tensor()]), [[axis]], [-1]) - kernel_right = self._compute_kernel_recursive( - trajectory * flippings, weights, axis - 1) - - # Remove zero frequency and reverse. - kernel_right = tf.reverse(array_ops.slice_along_axis( - kernel_right, image_axis, 1, tf.shape(kernel_right)[image_axis] - 1), - [image_axis]) - - # Create block of zeros to be inserted between the left and right halves of - # the kernel. - zeros_shape = tf.concat([ - tf.shape(kernel_left)[:image_axis], [1], - tf.shape(kernel_left)[(image_axis + 1):]], 0) - zeros = tf.zeros(zeros_shape, dtype=kernel_left.dtype) - - # Concatenate the left and right halves of kernel, with a block of zeros in - # the middle. - kernel = tf.concat([kernel_left, zeros, kernel_right], image_axis) - return kernel - - def _nufft_adjoint(self, x, trajectory=None): - """Applies the adjoint NUFFT operator. - - We use this instead of `super()._transform(x, adjoint=True)` because we - need to be able to change the trajectory and to apply an FFT shift. - - Args: - x: A `tf.Tensor` containing the input data (typically the weights or - ones). - trajectory: A `tf.Tensor` containing the *k*-space trajectory, which - may have been flipped and therefore different from the original. If - `None`, the original trajectory is used. - - Returns: - A `tf.Tensor` containing the result of the adjoint NUFFT. - """ - # Apply FFT shift. - x *= tf.math.exp(tf.dtypes.complex( - tf.constant(0, dtype=self.dtype.real_dtype), - tf.math.reduce_sum(trajectory * self._fft_shift, -1))) - # Temporarily update trajectory. - if trajectory is not None: - temp = self.trajectory - self.trajectory = trajectory - x = super()._transform(x, adjoint=True) - if trajectory is not None: - self.trajectory = temp - return x - - def _enforce_kernel_symmetry(self, kernel): - """Enforces Hermitian symmetry on an input kernel. - - Args: - kernel: A `tf.Tensor`. An approximately Hermitian kernel. - - Returns: - A Hermitian-symmetric kernel. - """ - kernel_axes = list(range(-self.rank, 0)) - reversed_kernel = tf.roll( - tf.reverse(kernel, kernel_axes), - shift=tf.ones([tf.size(kernel_axes)], dtype=tf.int32), - axis=kernel_axes) - return (kernel + tf.math.conj(reversed_kernel)) / 2 - - def _range_shape(self): - # Override the NUFFT operator's range shape. The range shape for this - # operator is the same as the domain shape. - return self._domain_shape() - - def _range_shape_tensor(self): - return self._domain_shape_tensor() diff --git a/tensorflow_mri/python/linalg/linear_operator_gram_nufft_test.py b/tensorflow_mri/python/linalg/linear_operator_gram_nufft_test.py deleted file mode 100755 index 82cb1e9f..00000000 --- a/tensorflow_mri/python/linalg/linear_operator_gram_nufft_test.py +++ /dev/null @@ -1,77 +0,0 @@ -# Copyright 2021 University College London. 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. -# ============================================================================== -"""Tests for module `linear_operator_gram_nufft`.""" -# pylint: disable=missing-class-docstring,missing-function-docstring - -from absl.testing import parameterized -import numpy as np -import tensorflow as tf - -from tensorflow_mri.python.geometry import rotation_2d -from tensorflow_mri.python.linalg import linear_operator_gram_nufft -from tensorflow_mri.python.linalg import linear_operator_nufft -from tensorflow_mri.python.ops import image_ops -from tensorflow_mri.python.ops import traj_ops -from tensorflow_mri.python.util import test_util - - -class LinearOperatorGramNUFFTTest(test_util.TestCase): - @parameterized.product( - density=[False, True], - norm=[None, 'ortho'], - toeplitz=[False, True], - batch=[False, True] - ) - def test_general(self, density, norm, toeplitz, batch): - with tf.device('/cpu:0'): - image_shape = (128, 128) - image = image_ops.phantom(shape=image_shape, dtype=tf.complex64) - trajectory = traj_ops.radial_trajectory( - 128, 129, flatten_encoding_dims=True) - if density is True: - density = traj_ops.radial_density( - 128, 129, flatten_encoding_dims=True) - else: - density = None - - # If testing batches, create new inputs to generate a batch. - if batch: - image = tf.stack([image, image * 0.5]) - trajectory = tf.stack([ - trajectory, - rotation_2d.Rotation2D.from_euler([np.pi / 2]).rotate(trajectory)]) - if density is not None: - density = tf.stack([density, density]) - - linop = linear_operator_nufft.LinearOperatorNUFFT( - image_shape, trajectory=trajectory, density=density, norm=norm) - linop_gram = linear_operator_gram_nufft.LinearOperatorGramNUFFT( - image_shape, trajectory=trajectory, density=density, norm=norm, - toeplitz=toeplitz) - - recon = linop.transform(linop.transform(image), adjoint=True) - recon_gram = linop_gram.transform(image) - - if norm is None: - # Reduce the magnitude of these values to avoid the need to use a large - # tolerance. - recon /= tf.cast(tf.math.reduce_prod(image_shape), tf.complex64) - recon_gram /= tf.cast(tf.math.reduce_prod(image_shape), tf.complex64) - - self.assertAllClose(recon, recon_gram, rtol=1e-4, atol=1e-4) - - -if __name__ == '__main__': - tf.test.main() diff --git a/tensorflow_mri/python/linalg/linear_operator_scaled_identity.py b/tensorflow_mri/python/linalg/linear_operator_identity.py similarity index 76% rename from tensorflow_mri/python/linalg/linear_operator_scaled_identity.py rename to tensorflow_mri/python/linalg/linear_operator_identity.py index e0de5665..5250e0c7 100644 --- a/tensorflow_mri/python/linalg/linear_operator_scaled_identity.py +++ b/tensorflow_mri/python/linalg/linear_operator_identity.py @@ -22,35 +22,39 @@ @api_util.export("linalg.LinearOperatorScaledIdentity") +@linear_operator.make_composite_tensor class LinearOperatorScaledIdentity(linear_operator.LinearOperatorMixin, # pylint: disable=abstract-method tf.linalg.LinearOperatorScaledIdentity): """Linear operator representing a scaled identity matrix. - .. note: - Similar to `tf.linalg.LinearOperatorScaledIdentity`_, but with imaging - extensions. + This operator acts like a scaled identity matrix $A = cI$. + + ```{note} + This operator is a drop-in replacement of + `tf.linalg.LinearOperatorScaledIdentity`, with extended functionality. + ``` Args: - shape: Non-negative integer `Tensor`. The shape of the operator. - multiplier: A `Tensor` of shape `[B1, ..., Bb]`, or `[]` (a scalar). + domain_shape: A 1D integer `Tensor`. The domain/range domain_shape of the operator. + multiplier: A `tf.Tensor` of arbitrary domain_shape. Its domain_shape will become the + batch domain_shape of the operator. Its dtype will determine the dtype of the + operator. is_non_singular: Expect that this operator is non-singular. is_self_adjoint: Expect that this operator is equal to its hermitian transpose. is_positive_definite: Expect that this operator is positive definite, - meaning the quadratic form `x^H A x` has positive real part for all - nonzero `x`. Note that we do not require the operator to be + meaning the quadratic form $x^H A x$ has positive real part for all + nonzero $x$. Note that we do not require the operator to be self-adjoint to be positive-definite. See: https://en.wikipedia.org/wiki/Positive-definite_matrix#Extension_for_non-symmetric_matrices is_square: Expect that this operator acts like square [batch] matrices. - assert_proper_shapes: Python `bool`. If `False`, only perform static - checks that initialization and method arguments have proper shape. + assert_proper_shapes: A boolean. If `False`, only perform static + checks that initialization and method arguments have proper domain_shape. If `True`, and static checks are inconclusive, add asserts to the graph. name: A name for this `LinearOperator`. - - .. _tf.linalg.LinearOperatorScaledIdentity: https://www.tensorflow.org/api_docs/python/tf/linalg/LinearOperatorScaledIdentity """ def __init__(self, - shape, + domain_shape, multiplier, is_non_singular=None, is_self_adjoint=None, @@ -60,12 +64,12 @@ def __init__(self, name="LinearOperatorScaledIdentity"): self._domain_shape_tensor_value = tensor_util.convert_shape_to_tensor( - shape, name="shape") + domain_shape, name="domain_shape") self._domain_shape_value = tf.TensorShape(tf.get_static_value( self._domain_shape_tensor_value)) super().__init__( - num_rows=tf.math.reduce_prod(shape), + num_rows=tf.math.reduce_prod(domain_shape), multiplier=multiplier, is_non_singular=is_non_singular, is_self_adjoint=is_self_adjoint, @@ -101,3 +105,11 @@ def _range_shape_tensor(self): def _batch_shape_tensor(self): return tf.shape(self.multiplier) + + @property + def _composite_tensor_fields(self): + return ("domain_shape", "multiplier", "assert_proper_shapes") + + @property + def _composite_tensor_prefer_static_fields(self): + return ("domain_shape",) diff --git a/tensorflow_mri/python/linalg/linear_operator_mri.py b/tensorflow_mri/python/linalg/linear_operator_mri.py index 31168882..36479539 100644 --- a/tensorflow_mri/python/linalg/linear_operator_mri.py +++ b/tensorflow_mri/python/linalg/linear_operator_mri.py @@ -18,6 +18,7 @@ import tensorflow as tf +from tensorflow_mri.python.linalg import linear_operator_nufft from tensorflow_mri.python.ops import fft_ops from tensorflow_mri.python.ops import math_ops from tensorflow_mri.python.util import api_util @@ -30,8 +31,9 @@ @api_util.export("linalg.LinearOperatorMRI") +@linear_operator.make_composite_tensor class LinearOperatorMRI(linear_operator.LinearOperator): # pylint: disable=abstract-method - r"""Linear operator representing an MRI encoding matrix. + r"""Linear operator acting like an MRI measurement system. The MRI operator, $A$, maps a [batch of] images, $x$ to a [batch of] measurement data (*k*-space), $b$. @@ -556,16 +558,6 @@ def num_coils_tensor(self): return tf.convert_to_tensor(-1, dtype=tf.int32) return tf.shape(self._sensitivities)[-(self._rank + 1)] - @property - def _composite_tensor_fields(self): - return ("image_shape", - "extra_shape", - "mask", - "trajectory", - "density", - "sensitivities", - "phase") - def _ignore_batch_dims_in_shape(self, shape, argname): if shape is None: return None @@ -583,3 +575,135 @@ def _ignore_batch_dims_in_shape(self, shape, argname): f"It is up to you to verify if this behavior is correct.") return tf.ensure_shape(shape[0], shape.shape[1:]) return shape + + @property + def _composite_tensor_fields(self): + return ("image_shape", + "extra_shape", + "mask", + "trajectory", + "density", + "sensitivities", + "phase") + + @property + def _composite_tensor_prefer_static_fields(self): + return ("image_shape", "extra_shape") + + +@api_util.export("linalg.LinearOperatorGramMRI") +class LinearOperatorGramMRI(LinearOperatorMRI): # pylint: disable=abstract-method + """Linear operator representing the Gram matrix of an MRI measurement system. + + If $A$ is a `tfmri.linalg.LinearOperatorMRI`, then this ooperator + represents the matrix $G = A^H A$. + + In certain circumstances, this operator may be able to apply the matrix + $G$ more efficiently than the composition $G = A^H A$ using + `tfmri.linalg.LinearOperatorMRI` objects. + + Args: + image_shape: A 1D integer `tf.Tensor`. The shape of the images + that this operator acts on. Must have length 2 or 3. + extra_shape: An optional 1D integer `tf.Tensor`. Additional + dimensions that should be included within the operator domain. Note that + `extra_shape` is not needed to reconstruct independent batches of images. + However, it is useful when this operator is used as part of a + reconstruction that performs computation along non-spatial dimensions, + e.g. for temporal regularization. Defaults to `None`. + mask: An optional `tf.Tensor` of type `tf.bool`. The sampling mask. Must + have shape `[..., *S]`, where `S` is the `image_shape` and `...` is + the batch shape, which can have any number of dimensions. If `mask` is + passed, this operator represents an undersampled MRI operator. + trajectory: An optional `tf.Tensor` of type `float32` or `float64`. Must + have shape `[..., M, N]`, where `N` is the rank (number of spatial + dimensions), `M` is the number of samples in the encoded space and `...` + is the batch shape, which can have any number of dimensions. If + `trajectory` is passed, this operator represents a non-Cartesian MRI + operator. + density: An optional `tf.Tensor` of type `float32` or `float64`. The + sampling densities. Must have shape `[..., M]`, where `M` is the number of + samples and `...` is the batch shape, which can have any number of + dimensions. This input is only relevant for non-Cartesian MRI operators. + If passed, the non-Cartesian operator will include sampling density + compensation. If `None`, the operator will not perform sampling density + compensation. + sensitivities: An optional `tf.Tensor` of type `complex64` or `complex128`. + The coil sensitivity maps. Must have shape `[..., C, *S]`, where `S` + is the `image_shape`, `C` is the number of coils and `...` is the batch + shape, which can have any number of dimensions. + phase: An optional `tf.Tensor` of type `float32` or `float64`. A phase + estimate for the image. If provided, this operator will be + phase-constrained. + fft_norm: FFT normalization mode. Must be `None` (no normalization) + or `'ortho'`. Defaults to `'ortho'`. + sens_norm: A `boolean`. Whether to normalize coil sensitivities. Defaults to + `True`. + dynamic_domain: A `str`. The domain of the dynamic dimension, if present. + Must be one of `'time'` or `'frequency'`. May only be provided together + with a non-scalar `extra_shape`. The dynamic dimension is the last + dimension of `extra_shape`. The `'time'` mode (default) should be + used for regular dynamic reconstruction. The `'frequency'` mode should be + used for reconstruction in x-f space. + toeplitz_nufft: A `boolean`. If `True`, uses the Toeplitz approach [5] + to compute :math:`F^H F x`, where :math:`F` is the non-uniform Fourier + operator. If `False`, the same operation is performed using the standard + NUFFT operation. The Toeplitz approach might be faster than the direct + approach but is slightly less accurate. This argument is only relevant + for non-Cartesian reconstruction and will be ignored for Cartesian + problems. + dtype: A `tf.dtypes.DType`. The dtype of this operator. Must be `complex64` + or `complex128`. Defaults to `complex64`. + name: An optional `str`. The name of this operator. + """ + def __init__(self, + image_shape, + extra_shape=None, + mask=None, + trajectory=None, + density=None, + sensitivities=None, + phase=None, + fft_norm='ortho', + sens_norm=True, + dynamic_domain=None, + toeplitz_nufft=False, + dtype=tf.complex64, + name="LinearOperatorGramMRI"): + super().__init__( + image_shape, + extra_shape=extra_shape, + mask=mask, + trajectory=trajectory, + density=density, + sensitivities=sensitivities, + phase=phase, + fft_norm=fft_norm, + sens_norm=sens_norm, + dynamic_domain=dynamic_domain, + dtype=dtype, + name=name + ) + + self.toeplitz_nufft = toeplitz_nufft + if self.toeplitz_nufft and self.is_non_cartesian: + # Create a Gram NUFFT operator with Toeplitz embedding. + self._linop_gram_nufft = linear_operator_nufft.LinearOperatorGramNUFFT( + image_shape, trajectory=self._trajectory, density=self._density, + norm=fft_norm, toeplitz=True) + # Disable NUFFT computation on base class. The NUFFT will instead be + # performed by the Gram NUFFT operator. + self._skip_nufft = True + + def _transform(self, x, adjoint=False): + x = super()._transform(x) + if self.toeplitz_nufft: + x = self._linop_gram_nufft.transform(x) + x = super()._transform(x, adjoint=True) + return x + + def _range_shape(self): + return self._domain_shape() + + def _range_shape_tensor(self): + return self._domain_shape_tensor() diff --git a/tensorflow_mri/python/linalg/linear_operator_mri_test.py b/tensorflow_mri/python/linalg/linear_operator_mri_test.py index 92618154..0d5d1d76 100755 --- a/tensorflow_mri/python/linalg/linear_operator_mri_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_mri_test.py @@ -15,6 +15,7 @@ """Tests for module `linear_operator_mri`.""" # pylint: disable=missing-class-docstring,missing-function-docstring +from absl.testing import parameterized import tensorflow as tf from tensorflow_mri.python.linalg import linear_operator_mri @@ -160,5 +161,54 @@ def test_nufft_with_sensitivities(self): self.assertAllClose(expected, recon) + +class LinearOperatorGramMRITest(test_util.TestCase): + @parameterized.product(batch=[False, True], extra=[False, True], + toeplitz_nufft=[False, True]) + def test_general(self, batch, extra, toeplitz_nufft): + resolution = 128 + image_shape = [resolution, resolution] + num_coils = 4 + image, sensitivities = image_ops.phantom( + shape=image_shape, num_coils=num_coils, dtype=tf.complex64, + return_sensitivities=True) + image = image_ops.phantom(shape=image_shape, dtype=tf.complex64) + trajectory = traj_ops.radial_trajectory(resolution, resolution // 2 + 1, + flatten_encoding_dims=True) + density = traj_ops.radial_density(resolution, resolution // 2 + 1, + flatten_encoding_dims=True) + if batch: + image = tf.stack([image, image * 2]) + if extra: + extra_shape = [2] + else: + extra_shape = None + else: + extra_shape = None + + linop = linear_operator_mri.LinearOperatorMRI( + image_shape, extra_shape=extra_shape, + trajectory=trajectory, density=density, + sensitivities=sensitivities) + linop_gram = linear_operator_mri.LinearOperatorGramMRI( + image_shape, extra_shape=extra_shape, + trajectory=trajectory, density=density, + sensitivities=sensitivities, toeplitz_nufft=toeplitz_nufft) + + # Test shapes. + expected_domain_shape = image_shape + if extra_shape is not None: + expected_domain_shape = extra_shape + image_shape + self.assertAllClose(expected_domain_shape, linop_gram.domain_shape) + self.assertAllClose(expected_domain_shape, linop_gram.domain_shape_tensor()) + self.assertAllClose(expected_domain_shape, linop_gram.range_shape) + self.assertAllClose(expected_domain_shape, linop_gram.range_shape_tensor()) + + # Test transform. + expected = linop.transform(linop.transform(image), adjoint=True) + self.assertAllClose(expected, linop_gram.transform(image), + rtol=1e-4, atol=1e-4) + + if __name__ == '__main__': tf.test.main() diff --git a/tensorflow_mri/python/linalg/linear_operator_nufft.py b/tensorflow_mri/python/linalg/linear_operator_nufft.py index a08848be..39a1940e 100644 --- a/tensorflow_mri/python/linalg/linear_operator_nufft.py +++ b/tensorflow_mri/python/linalg/linear_operator_nufft.py @@ -19,6 +19,7 @@ import tensorflow as tf +from tensorflow_mri.python.ops import array_ops from tensorflow_mri.python.ops import fft_ops from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util @@ -57,6 +58,7 @@ class LinearOperatorNUFFT(linear_operator.LinearOperator): # pylint: disable=ab and wish to apply the full compensation, you can do so via the `preprocess` method. + Example: >>> # Create some data. >>> image_shape = (128, 128) >>> image = tfmri.image.phantom(shape=image_shape, dtype=tf.complex64) @@ -263,3 +265,240 @@ def rank(self): def rank_tensor(self): return self._rank_dynamic + + +@api_util.export("linalg.LinearOperatorGramNUFFT") +class LinearOperatorGramNUFFT(LinearOperatorNUFFT): # pylint: disable=abstract-method + """Linear operator acting like the Gram matrix of an NUFFT operator. + + If $F$ is a `tfmri.linalg.LinearOperatorNUFFT`, then this operator + applies $F^H F$. This operator is self-adjoint. + + Args: + domain_shape: A 1D integer `tf.Tensor`. The domain shape of this + operator. This is usually the shape of the image but may include + additional dimensions. + trajectory: A `tf.Tensor` of type `float32` or `float64`. Contains the + sampling locations or *k*-space trajectory. Must have shape + `[..., M, N]`, where `N` is the rank (number of dimensions), `M` is + the number of samples and `...` is the batch shape, which can have any + number of dimensions. + density: A `tf.Tensor` of type `float32` or `float64`. Contains the + sampling density at each point in `trajectory`. Must have shape + `[..., M]`, where `M` is the number of samples and `...` is the batch + shape, which can have any number of dimensions. Defaults to `None`, in + which case the density is assumed to be 1.0 in all locations. + norm: A `str`. The FFT normalization mode. Must be `None` (no normalization) + or `'ortho'`. + toeplitz: A `boolean`. If `True`, uses the Toeplitz approach [1] + to compute $F^H F x$, where $F$ is the NUFFT operator. + If `False`, the same operation is performed using the standard + NUFFT operation. The Toeplitz approach might be faster than the direct + approach but is slightly less accurate. This argument is only relevant + for non-Cartesian reconstruction and will be ignored for Cartesian + problems. + name: An optional `str`. The name of this operator. + + References: + 1. Fessler, J. A., Lee, S., Olafsson, V. T., Shi, H. R., & Noll, D. C. + (2005). Toeplitz-based iterative image reconstruction for MRI with + correction for magnetic field inhomogeneity. IEEE Transactions on Signal + Processing, 53(9), 3393-3402. + """ + def __init__(self, + domain_shape, + trajectory, + density=None, + norm='ortho', + toeplitz=False, + name="LinearOperatorNUFFT"): + super().__init__( + domain_shape=domain_shape, + trajectory=trajectory, + density=density, + norm=norm, + name=name + ) + + self.toeplitz = toeplitz + if self.toeplitz: + # Compute the FFT shift for adjoint NUFFT computation. + self._fft_shift = tf.cast(self._grid_shape // 2, self.dtype.real_dtype) + # Compute the Toeplitz kernel. + self._toeplitz_kernel = self._compute_toeplitz_kernel() + # Kernel shape (without batch dimensions). + self._kernel_shape = tf.shape(self._toeplitz_kernel)[-self.rank_tensor():] + + def _transform(self, x, adjoint=False): # pylint: disable=unused-argument + """Applies this linear operator.""" + # This operator is self-adjoint, so `adjoint` arg is unused. + if self.toeplitz: + # Using specialized Toeplitz implementation. + return self._transform_toeplitz(x) + # Using standard NUFFT implementation. + return super()._transform(super()._transform(x), adjoint=True) + + def _transform_toeplitz(self, x): + """Applies this linear operator using the Toeplitz approach.""" + input_shape = tf.shape(x) + fft_axes = tf.range(-self.rank_tensor(), 0) + x = fft_ops.fftn(x, axes=fft_axes, shape=self._kernel_shape) + x *= self._toeplitz_kernel + x = fft_ops.ifftn(x, axes=fft_axes) + x = tf.slice(x, tf.zeros([tf.rank(x)], dtype=tf.int32), input_shape) + return x + + def _compute_toeplitz_kernel(self): + """Computes the kernel for the Toeplitz approach.""" + trajectory = self.trajectory + weights = self.weights + if self.rank is None: + raise NotImplementedError( + f"The rank of {self.name} must be known statically.") + + if weights is None: + # If no weights were passed, use ones. + weights = tf.ones(tf.shape(trajectory)[:-1], dtype=self.dtype.real_dtype) + # Cast weights to complex dtype. + weights = tf.cast(tf.math.sqrt(weights), self.dtype) + + # Compute N-D kernel recursively. Begin with last axis. + last_axis = self.rank - 1 + kernel = self._compute_kernel_recursive(trajectory, weights, last_axis) + + # Make sure that the kernel is symmetric/Hermitian/self-adjoint. + kernel = self._enforce_kernel_symmetry(kernel) + + # Additional normalization by sqrt(2 ** rank). This is required because + # we are using FFTs with twice the length of the original image. + if self.norm == 'ortho': + kernel *= tf.cast(tf.math.sqrt(2.0 ** self.rank), kernel.dtype) + + # Put the kernel in Fourier space. + fft_axes = list(range(-self.rank, 0)) + fft_norm = self.norm or "backward" + return fft_ops.fftn(kernel, axes=fft_axes, norm=fft_norm) + + def _compute_kernel_recursive(self, trajectory, weights, axis): + """Recursively computes the kernel for the Toeplitz approach. + + This function works by computing the two halves of the kernel along each + axis. The "left" half is computed using the input trajectory. The "right" + half is computed using the trajectory flipped along the current axis, and + then reversed. Then the two halves are concatenated, with a block of zeros + inserted in between. If there is more than one axis, the process is repeated + recursively for each axis. + + This function calls the adjoint NUFFT 2 ** N times, where N is the number + of dimensions. NOTE: this could be optimized to 2 ** (N - 1) calls. + + Args: + trajectory: A `tf.Tensor` containing the current *k*-space trajectory. + weights: A `tf.Tensor` containing the current density compensation + weights. + axis: An `int` denoting the current axis. + + Returns: + A `tf.Tensor` containing the kernel. + + Raises: + NotImplementedError: If the rank of the operator is not known statically. + """ + # Account for the batch dimensions. We do not need to do the recursion + # for these. + batch_dims = self.batch_shape.rank + if batch_dims is None: + raise NotImplementedError( + f"The number of batch dimensions of {self.name} must be known " + f"statically.") + # The current axis without the batch dimensions. + image_axis = axis + batch_dims + if axis == 0: + # Outer-most axis. Compute left half, then use Hermitian symmetry to + # compute right half. + # TODO(jmontalt): there should be a way to compute the NUFFT only once. + kernel_left = self._nufft_adjoint(weights, trajectory) + flippings = tf.tensor_scatter_nd_update( + tf.ones([self.rank_tensor()]), [[axis]], [-1]) + kernel_right = self._nufft_adjoint(weights, trajectory * flippings) + else: + # We still have two or more axes to process. Compute left and right kernels + # by calling this function recursively. We call ourselves twice, first + # with current frequencies, then with negated frequencies along current + # axes. + kernel_left = self._compute_kernel_recursive( + trajectory, weights, axis - 1) + flippings = tf.tensor_scatter_nd_update( + tf.ones([self.rank_tensor()]), [[axis]], [-1]) + kernel_right = self._compute_kernel_recursive( + trajectory * flippings, weights, axis - 1) + + # Remove zero frequency and reverse. + kernel_right = tf.reverse(array_ops.slice_along_axis( + kernel_right, image_axis, 1, tf.shape(kernel_right)[image_axis] - 1), + [image_axis]) + + # Create block of zeros to be inserted between the left and right halves of + # the kernel. + zeros_shape = tf.concat([ + tf.shape(kernel_left)[:image_axis], [1], + tf.shape(kernel_left)[(image_axis + 1):]], 0) + zeros = tf.zeros(zeros_shape, dtype=kernel_left.dtype) + + # Concatenate the left and right halves of kernel, with a block of zeros in + # the middle. + kernel = tf.concat([kernel_left, zeros, kernel_right], image_axis) + return kernel + + def _nufft_adjoint(self, x, trajectory=None): + """Applies the adjoint NUFFT operator. + + We use this instead of `super()._transform(x, adjoint=True)` because we + need to be able to change the trajectory and to apply an FFT shift. + + Args: + x: A `tf.Tensor` containing the input data (typically the weights or + ones). + trajectory: A `tf.Tensor` containing the *k*-space trajectory, which + may have been flipped and therefore different from the original. If + `None`, the original trajectory is used. + + Returns: + A `tf.Tensor` containing the result of the adjoint NUFFT. + """ + # Apply FFT shift. + x *= tf.math.exp(tf.dtypes.complex( + tf.constant(0, dtype=self.dtype.real_dtype), + tf.math.reduce_sum(trajectory * self._fft_shift, -1))) + # Temporarily update trajectory. + if trajectory is not None: + temp = self.trajectory + self.trajectory = trajectory + x = super()._transform(x, adjoint=True) + if trajectory is not None: + self.trajectory = temp + return x + + def _enforce_kernel_symmetry(self, kernel): + """Enforces Hermitian symmetry on an input kernel. + + Args: + kernel: A `tf.Tensor`. An approximately Hermitian kernel. + + Returns: + A Hermitian-symmetric kernel. + """ + kernel_axes = list(range(-self.rank, 0)) + reversed_kernel = tf.roll( + tf.reverse(kernel, kernel_axes), + shift=tf.ones([tf.size(kernel_axes)], dtype=tf.int32), + axis=kernel_axes) + return (kernel + tf.math.conj(reversed_kernel)) / 2 + + def _range_shape(self): + # Override the NUFFT operator's range shape. The range shape for this + # operator is the same as the domain shape. + return self._domain_shape() + + def _range_shape_tensor(self): + return self._domain_shape_tensor() diff --git a/tensorflow_mri/python/linalg/linear_operator_nufft_test.py b/tensorflow_mri/python/linalg/linear_operator_nufft_test.py index bfcac13f..e74cae39 100755 --- a/tensorflow_mri/python/linalg/linear_operator_nufft_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_nufft_test.py @@ -19,6 +19,7 @@ import numpy as np import tensorflow as tf +from tensorflow_mri.python.geometry import rotation_2d from tensorflow_mri.python.linalg import linear_operator_nufft from tensorflow_mri.python.ops import fft_ops from tensorflow_mri.python.ops import image_ops @@ -198,5 +199,51 @@ def test_with_density(self): self.assertAllClose(recon, recon_d2) +class LinearOperatorGramNUFFTTest(test_util.TestCase): + @parameterized.product( + density=[False, True], + norm=[None, 'ortho'], + toeplitz=[False, True], + batch=[False, True] + ) + def test_general(self, density, norm, toeplitz, batch): + with tf.device('/cpu:0'): + image_shape = (128, 128) + image = image_ops.phantom(shape=image_shape, dtype=tf.complex64) + trajectory = traj_ops.radial_trajectory( + 128, 129, flatten_encoding_dims=True) + if density is True: + density = traj_ops.radial_density( + 128, 129, flatten_encoding_dims=True) + else: + density = None + + # If testing batches, create new inputs to generate a batch. + if batch: + image = tf.stack([image, image * 0.5]) + trajectory = tf.stack([ + trajectory, + rotation_2d.Rotation2D.from_euler([np.pi / 2]).rotate(trajectory)]) + if density is not None: + density = tf.stack([density, density]) + + linop = linear_operator_nufft.LinearOperatorNUFFT( + image_shape, trajectory=trajectory, density=density, norm=norm) + linop_gram = linear_operator_nufft.LinearOperatorGramNUFFT( + image_shape, trajectory=trajectory, density=density, norm=norm, + toeplitz=toeplitz) + + recon = linop.transform(linop.transform(image), adjoint=True) + recon_gram = linop_gram.transform(image) + + if norm is None: + # Reduce the magnitude of these values to avoid the need to use a large + # tolerance. + recon /= tf.cast(tf.math.reduce_prod(image_shape), tf.complex64) + recon_gram /= tf.cast(tf.math.reduce_prod(image_shape), tf.complex64) + + self.assertAllClose(recon, recon_gram, rtol=1e-4, atol=1e-4) + + if __name__ == '__main__': tf.test.main() diff --git a/tensorflow_mri/python/ops/recon_ops.py b/tensorflow_mri/python/ops/recon_ops.py index 5c2085ba..0f4c3fdd 100644 --- a/tensorflow_mri/python/ops/recon_ops.py +++ b/tensorflow_mri/python/ops/recon_ops.py @@ -25,7 +25,6 @@ from tensorflow_mri.python.coils import coil_combination from tensorflow_mri.python.linalg import conjugate_gradient from tensorflow_mri.python.linalg import linear_operator_gram_matrix -from tensorflow_mri.python.linalg import linear_operator_gram_mri from tensorflow_mri.python.linalg import linear_operator_mri from tensorflow_mri.python.ops import array_ops from tensorflow_mri.python.ops import convex_ops @@ -227,7 +226,7 @@ def reconstruct_lstsq(kspace, # If using Toeplitz NUFFT, we need to use the specialized Gram MRI operator. if toeplitz_nufft and operator.is_non_cartesian: - gram_operator = linear_operator_gram_mri.LinearOperatorGramMRI( + gram_operator = linear_operator_mri.LinearOperatorGramMRI( image_shape, extra_shape=extra_shape, mask=mask, From ae4d9ac30af027532cdcd67da792e3b9201b42ab Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Fri, 2 Sep 2022 14:44:26 +0000 Subject: [PATCH 080/101] Working on ReconAdjoint layer --- tensorflow_mri/_api/layers/__init__.py | 1 + tensorflow_mri/_api/recon/__init__.py | 2 +- .../python/coils/coil_sensitivities.py | 32 +++--- tensorflow_mri/python/layers/__init__.py | 2 + tensorflow_mri/python/layers/recon_adjoint.py | 106 ++++++++++++++++++ .../python/layers/recon_adjoint_test.py | 76 +++++++++++++ .../python/linalg/linear_operator_mri.py | 36 +++++- tensorflow_mri/python/recon/recon_adjoint.py | 38 +++++-- 8 files changed, 264 insertions(+), 29 deletions(-) create mode 100644 tensorflow_mri/python/layers/recon_adjoint.py create mode 100644 tensorflow_mri/python/layers/recon_adjoint_test.py diff --git a/tensorflow_mri/_api/layers/__init__.py b/tensorflow_mri/_api/layers/__init__.py index 58fb6ba3..b02feb8a 100644 --- a/tensorflow_mri/_api/layers/__init__.py +++ b/tensorflow_mri/_api/layers/__init__.py @@ -21,6 +21,7 @@ from tensorflow_mri.python.layers.pooling import MaxPooling2D as MaxPool2D from tensorflow_mri.python.layers.pooling import MaxPooling3D as MaxPooling3D from tensorflow_mri.python.layers.pooling import MaxPooling3D as MaxPool3D +from tensorflow_mri.python.layers.recon_adjoint import ReconAdjoint as ReconAdjoint from tensorflow_mri.python.layers.reshaping import UpSampling1D as UpSampling1D from tensorflow_mri.python.layers.reshaping import UpSampling2D as UpSampling2D from tensorflow_mri.python.layers.reshaping import UpSampling3D as UpSampling3D diff --git a/tensorflow_mri/_api/recon/__init__.py b/tensorflow_mri/_api/recon/__init__.py index 6a418f93..2178ba71 100644 --- a/tensorflow_mri/_api/recon/__init__.py +++ b/tensorflow_mri/_api/recon/__init__.py @@ -2,7 +2,7 @@ # Do not edit. """Signal reconstruction.""" -from tensorflow_mri.python.recon.recon_adjoint import recon_adjoint as custom_adjoint +from tensorflow_mri.python.recon.recon_adjoint import recon_adjoint as adjoint_universal from tensorflow_mri.python.recon.recon_adjoint import recon_adjoint_mri as adjoint from tensorflow_mri.python.recon.recon_adjoint import recon_adjoint_mri as adj from tensorflow_mri.python.ops.recon_ops import reconstruct_lstsq as least_squares diff --git a/tensorflow_mri/python/coils/coil_sensitivities.py b/tensorflow_mri/python/coils/coil_sensitivities.py index 5b0e3df6..0d47a24c 100644 --- a/tensorflow_mri/python/coils/coil_sensitivities.py +++ b/tensorflow_mri/python/coils/coil_sensitivities.py @@ -409,7 +409,7 @@ def _apply_uniform_filter(tensor, size=5): @api_util.export("coils.estimate_sensitivities_universal") def estimate_sensitivities_universal( - meas_data, + data, operator, calib_data=None, calib_fn=None, @@ -418,7 +418,7 @@ def estimate_sensitivities_universal( """Estimates coil sensitivities (universal). This function is designed to standardize the computation of coil - sensitivities in different contexts. The `meas_data` argument can accept + sensitivities in different contexts. The `data` argument can accept arbitrary measurement data (e.g., N-dimensional, Cartesian/non-Cartesian *k*-space tensors). In addition, this function expects a linear `operator` which describes the action of the measurement system (e.g., the MR imaging @@ -426,9 +426,9 @@ def estimate_sensitivities_universal( This function also accepts an optional `calib_data` tensor or an optional `calib_fn` function, in case the calibration should be performed with data - other than `meas_data`. `calib_data` may be used to provide the calibration + other than `data`. `calib_data` may be used to provide the calibration data directly, whereas `calib_fn` may be used to specify the rules to extract - it from `meas_data`. + it from `data`. ```{note} This function is part of the family of @@ -463,16 +463,16 @@ def estimate_sensitivities_universal( ... center_size=[256, 24]) >>> # We can create a function that extracts the calibration data from >>> # an arbitrary *k*-space by applying the calibration mask below. - >>> def calib_fn(meas_data, operator): - ... # Returns `meas_data` where `calib_mask` is `True`, 0 otherwise. - ... return tf.where(calib_mask, meas_data, tf.zeros_like(meas_data)) + >>> def calib_fn(data, operator): + ... # Returns `data` where `calib_mask` is `True`, 0 otherwise. + ... return tf.where(calib_mask, data, tf.zeros_like(data)) >>> # Finally, compute the coil sensitivities using the above function >>> # to extract the calibration data. >>> maps = tfmri.coils.estimate_sensitivities_universal( ... kspace, linop_mri, calib_fn=calib_fn) Args: - meas_data: A `tf.Tensor` containing the measurement or observation data. + data: A `tf.Tensor` containing the measurement or observation data. Must be compatible with the range of `operator`, i.e., it should be a plausible output of the system operator. Accordingly, it should be a plausible input for the adjoint of the system operator. @@ -481,7 +481,7 @@ def estimate_sensitivities_universal( ``` operator: A `tfmri.linalg.LinearOperator` describing the action of the measurement system. `operator` maps the causal factors to the measurement - or observation data. Its range must be compatible with `meas_data`. + or observation data. Its range must be compatible with `data`. ```{tip} In MRI, this is usually an operator mapping images to the corresponding *k*-space data. For most MRI experiments, you can use @@ -489,14 +489,14 @@ def estimate_sensitivities_universal( ``` calib_data: A `tf.Tensor` containing the calibration data. Must be compatible with `operator`. If `None`, the calibration data will be - extracted from the `meas_data` tensor using the `calib_fn` function. + extracted from the `data` tensor using the `calib_fn` function. ```{tip} In MRI, this is usually the central, fully-sampled region of *k*-space. ``` calib_fn: A callable which extracts the calibration data from the input - `meas_data`. Must have signature - `calib_fn(meas_data, operator) -> calib_data`. If `None`, `calib_data` - will be used for calibration. If `calib_data` is also `None`, `meas_data` + `data`. Must have signature + `calib_fn(data, operator) -> calib_data`. If `None`, `calib_data` + will be used for calibration. If `calib_data` is also `None`, `data` will be used directly for calibration. method: A `str` specifying which coil sensitivity estimation algorithm to use. Must be one of `'direct'`, `'walsh'`, `'inati'` or `'espirit'`. @@ -513,12 +513,12 @@ def estimate_sensitivities_universal( """ with tf.name_scope(kwargs.get('name', 'estimate_sensitivities_universal')): rank = operator.rank - meas_data = tf.convert_to_tensor(meas_data) + data = tf.convert_to_tensor(data) if calib_data is None and calib_fn is None: - calib_data = meas_data + calib_data = data elif calib_data is None and calib_fn is not None: - calib_data = calib_fn(meas_data, operator) + calib_data = calib_fn(data, operator) elif calib_data is not None and calib_fn is None: calib_data = tf.convert_to_tensor(calib_data) else: diff --git a/tensorflow_mri/python/layers/__init__.py b/tensorflow_mri/python/layers/__init__.py index d9692f0f..40991b3c 100644 --- a/tensorflow_mri/python/layers/__init__.py +++ b/tensorflow_mri/python/layers/__init__.py @@ -14,9 +14,11 @@ # ============================================================================== """Keras layers.""" +from tensorflow_mri.python.layers import concatenate from tensorflow_mri.python.layers import convolutional from tensorflow_mri.python.layers import normalization from tensorflow_mri.python.layers import pooling from tensorflow_mri.python.layers import preproc_layers +from tensorflow_mri.python.layers import recon_adjoint from tensorflow_mri.python.layers import reshaping from tensorflow_mri.python.layers import signal_layers diff --git a/tensorflow_mri/python/layers/recon_adjoint.py b/tensorflow_mri/python/layers/recon_adjoint.py new file mode 100644 index 00000000..189db735 --- /dev/null +++ b/tensorflow_mri/python/layers/recon_adjoint.py @@ -0,0 +1,106 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Adjoint reconstruction layer.""" + +import tensorflow as tf + +from tensorflow_mri.python.ops import math_ops +from tensorflow_mri.python.recon import recon_adjoint +from tensorflow_mri.python.util import api_util + + +@api_util.export("layers.ReconAdjoint") +@tf.keras.utils.register_keras_serializable(package="MRI") +class ReconAdjoint(tf.keras.layers.Layer): + r"""Adjoint reconstruction layer. + + This layer reconstructs a signal using the adjoint of the specified system + operator. + + ```{seealso} + This is the Keras layer equivalent of `tfmri.recon.adjoint_universal`. + ``` + + Given measurement data $b$ generated by a linear system $A$ such that + $Ax = b$, this function estimates the corresponding signal $x$ as + $x = A^H b$, where $A$ is the specified linear operator. + + ## Inputs + + This layer's `call` method expects the following inputs: + + - data: A `tf.Tensor` of real or complex dtype. The measurement data $b$. + Its shape must be compatible with `operator.range_shape`. + - operator: A `tfmri.linalg.LinearOperator` representing the system operator + $A$. Its range shape must be compatible with `data.shape`. + + ```{attention} + Both `data` and `operator` should be passed as part of the first positional + `inputs` argument, either as as a `tuple` or as a `dict`, in order to take + advantage of this argument's special rules. For more information, see + https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer#call. + ``` + + ## Outputs + + This layer's `call` method returns a `tf.Tensor` containing the reconstructed + signal. Has the same dtype as `data` and shape + `batch_shape + operator.domain_shape`. `batch_shape` is the result of + broadcasting the batch shapes of `data` and `operator`. + + Args: + expand_channel_dim: A `boolean`. Whether to expand the channel dimension. + If `True`, the output has shape `[*batch_shape, ${dim_names}, 1]`. + If `False`, the output has shape `[*batch_shape, ${dim_names}]`. + Defaults to `True`. + reinterpret_complex: A `boolean`. Whether to reinterpret a complex-valued + output image as a dual-channel real image. Defaults to `False`. + **kwargs: Keyword arguments to be passed to base layer + `tf.keras.layers.Layer`. + """ + def __init__(self, + expand_channel_dim=True, + reinterpret_complex=False, + **kwargs): + super().__init__(**kwargs) + self.expand_channel_dim = expand_channel_dim + self.reinterpret_complex = reinterpret_complex + + def call(self, inputs): + data, operator = parse_inputs(inputs) + image = recon_adjoint.recon_adjoint(data, operator) + if self.expand_channel_dim: + image = tf.expand_dims(image, axis=-1) + if self.reinterpret_complex and tf.as_dtype(self.dtype).is_complex: + image = math_ops.view_as_real(image, stacked=False) + return image + + def get_config(self): + base_config = super().get_config() + config = { + 'expand_channel_dim': self.expand_channel_dim, + 'reinterpret_complex': self.reinterpret_complex + } + return {**base_config, **config} + + +def parse_inputs(inputs): + def _parse_inputs(data, operator): + return data, operator + if isinstance(inputs, tuple): + return _parse_inputs(*inputs) + elif isinstance(inputs, dict): + return _parse_inputs(**inputs) + raise ValueError('inputs must be a tuple or dict') diff --git a/tensorflow_mri/python/layers/recon_adjoint_test.py b/tensorflow_mri/python/layers/recon_adjoint_test.py new file mode 100644 index 00000000..2bcd62e2 --- /dev/null +++ b/tensorflow_mri/python/layers/recon_adjoint_test.py @@ -0,0 +1,76 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Tests for module `recon_adjoint`.""" + +import os +import tempfile + +from absl.testing import parameterized +import tensorflow as tf + +from tensorflow_mri.python.linalg import linear_operator_mri +from tensorflow_mri.python.layers import recon_adjoint as recon_adjoint_layer +from tensorflow_mri.python.recon import recon_adjoint +from tensorflow_mri.python.util import test_util + + +class ReconAdjointTest(test_util.TestCase): + @parameterized.product(expand_channel_dim=[True, False]) + def test_recon_adjoint(self, expand_channel_dim): + # Create layer. + layer = recon_adjoint_layer.ReconAdjoint( + expand_channel_dim=expand_channel_dim) + + # Generate k-space data. + image_shape = tf.constant([4, 4]) + kspace = tf.dtypes.complex( + tf.random.stateless_normal(shape=image_shape, seed=[11, 22]), + tf.random.stateless_normal(shape=image_shape, seed=[12, 34])) + + # Reconstruct image. + expected = recon_adjoint.recon_adjoint_mri(kspace, image_shape) + if expand_channel_dim: + expected = tf.expand_dims(expected, axis=-1) + + operator = linear_operator_mri.LinearOperatorMRI(image_shape) + + # Test with tuple inputs. + input_data = (kspace, operator) + result = layer(input_data) + self.assertAllClose(expected, result) + + # Test with dict inputs. + input_data = {'data': kspace, 'operator': operator} + result = layer(input_data) + self.assertAllClose(expected, result) + + # Test (de)serialization. + layer = recon_adjoint_layer.ReconAdjoint.from_config(layer.get_config()) + result = layer(input_data) + self.assertAllClose(expected, result) + + # Test in model. + inputs = {k: tf.keras.Input(type_spec=tf.type_spec_from_value(v)) + for k, v in input_data.items()} + model = tf.keras.Model(inputs, layer(inputs)) + result = model(input_data) + self.assertAllClose(expected, result) + + # Test saving/loading. + saved_model = os.path.join(tempfile.mkdtemp(), 'saved_model') + model.save(saved_model) + model = tf.keras.models.load_model(saved_model) + result = model(input_data) + self.assertAllClose(expected, result) diff --git a/tensorflow_mri/python/linalg/linear_operator_mri.py b/tensorflow_mri/python/linalg/linear_operator_mri.py index 36479539..8793beb3 100644 --- a/tensorflow_mri/python/linalg/linear_operator_mri.py +++ b/tensorflow_mri/python/linalg/linear_operator_mri.py @@ -105,6 +105,19 @@ class LinearOperatorMRI(linear_operator.LinearOperator): # pylint: disable=abst dimension of `extra_shape`. The `'time'` mode (default) should be used for regular dynamic reconstruction. The `'frequency'` mode should be used for reconstruction in x-f space. + is_non_singular: A boolean, or `None`. Whether this operator is expected + to be non-singular. Defaults to `None`. + is_self_adjoint: A boolean, or `None`. Whether this operator is expected + to be equal to its Hermitian transpose. If `dtype` is real, this is + equivalent to being symmetric. Defaults to `None`. + is_positive_definite: A boolean, or `None`. Whether this operators is + expected to be positive definite, meaning the quadratic form $x^H A x$ + has positive real part for all nonzero $x$. Note that we do not require + the operator to be self-adjoint to be positive-definite. See: + https://en.wikipedia.org/wiki/Positive-definite_matrix#Extension_for_non-symmetric_matrices. + Defaults to `None`. + is_square: A boolean, or `None`. Expect that this operator acts like a + square matrix (or a batch of square matrices). Defaults to `None`. dtype: A `tf.dtypes.DType`. The dtype of this operator. Must be `complex64` or `complex128`. Defaults to `complex64`. name: An optional `str`. The name of this operator. @@ -121,6 +134,10 @@ def __init__(self, sens_norm=True, intensity_correction=True, dynamic_domain=None, + is_non_singular=None, + is_self_adjoint=None, + is_positive_definite=None, + is_square=None, dtype=tf.complex64, name=None): # pylint: disable=invalid-unary-operand-type @@ -136,9 +153,19 @@ def __init__(self, sens_norm=sens_norm, intensity_correction=intensity_correction, dynamic_domain=dynamic_domain, + is_non_singular=is_non_singular, + is_self_adjoint=is_self_adjoint, + is_positive_definite=is_positive_definite, + is_square=is_square, dtype=dtype, name=name) - super().__init__(dtype, name=name, parameters=parameters) + super().__init__(dtype=dtype, + is_non_singular=is_non_singular, + is_self_adjoint=is_self_adjoint, + is_positive_definite=is_positive_definite, + is_square=is_square, + name=name, + parameters=parameters) # Set dtype. dtype = tf.as_dtype(dtype) @@ -584,7 +611,12 @@ def _composite_tensor_fields(self): "trajectory", "density", "sensitivities", - "phase") + "phase", + "fft_norm", + "sens_norm", + "intensity_correction", + "dynamic_domain", + "dtype") @property def _composite_tensor_prefer_static_fields(self): diff --git a/tensorflow_mri/python/recon/recon_adjoint.py b/tensorflow_mri/python/recon/recon_adjoint.py index e5e6717e..7a3fe2d5 100644 --- a/tensorflow_mri/python/recon/recon_adjoint.py +++ b/tensorflow_mri/python/recon/recon_adjoint.py @@ -20,21 +20,39 @@ from tensorflow_mri.python.linalg import linear_operator_mri -@api_util.export("recon.custom_adjoint") +@api_util.export("recon.adjoint_universal") def recon_adjoint(data, operator): r"""Reconstructs a signal using the adjoint of the system operator. - Given measurement data :math:`b` generated by a linear system :math:`A` such - that :math:`Ax = b`, this function estimates the corresponding signal - :math:`x` as :math:`x = A^H b`, where :math:`A` is the specified linear - operator. + Given measurement data $b$ generated by a linear system $A$ such that + $Ax = b$, this function estimates the corresponding signal $x$ as + $x = A^H b$, where $A$ is the specified linear operator. + + ```{note} + This function is part of the family of + [universal operators](https://mrphys.github.io/tensorflow-mri/guide/universal/), + a set of functions designed to work flexibly with any linear system. + ``` + + ```{seealso} + `tfmri.recon.adjoint` is an MRI-specific version of this function and may be + used to perform zero-filled reconstructions. + ``` Args: - data: A `tf.Tensor` of real or complex dtype. The measured data. - operator: A `tfmri.linalg.LinearOperator` representing the system operator. + data: A `tf.Tensor` of real or complex dtype. The measurement data $b$. + Its shape must be compatible with `operator.range_shape`. + operator: A `tfmri.linalg.LinearOperator` representing the system operator + $A$. Its range shape must be compatible with `data.shape`. + ```{tip} + You can use any of the operators in `tfmri.linalg`, a composition of + multiple operators, or a subclassed operator. + ``` Returns: - A `tf.Tensor` with the same dtype as `data`. The reconstructed signal. + A `tf.Tensor` containing the reconstructed signal. Has the same dtype as + `data` and shape `batch_shape + operator.domain_shape`. `batch_shape` is + the result of broadcasting the batch shapes of `data` and `operator`. """ data = tf.convert_to_tensor(data) data = operator.preprocess(data, adjoint=True) @@ -54,8 +72,8 @@ def recon_adjoint_mri(kspace, sens_norm=True): r"""Reconstructs an MR image using the adjoint MRI operator. - Given *k*-space data :math:`b`, this function estimates the corresponding - image as :math:`x = A^H b`, where :math:`A` is the MRI linear operator. + Given *k*-space data $b$, this function estimates the corresponding + image as $x = A^H b$, where $A$ is the MRI linear operator. This operator supports Cartesian and non-Cartesian *k*-space data. From 82c257223f78b2a3d719272a686059bcf4a7493f Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Fri, 2 Sep 2022 14:48:47 +0000 Subject: [PATCH 081/101] Doc improvements --- tensorflow_mri/python/coils/coil_sensitivities.py | 3 ++- tensorflow_mri/python/layers/recon_adjoint.py | 15 +++++++++++---- tensorflow_mri/python/recon/recon_adjoint.py | 3 ++- 3 files changed, 15 insertions(+), 6 deletions(-) diff --git a/tensorflow_mri/python/coils/coil_sensitivities.py b/tensorflow_mri/python/coils/coil_sensitivities.py index 0d47a24c..5f7f410c 100644 --- a/tensorflow_mri/python/coils/coil_sensitivities.py +++ b/tensorflow_mri/python/coils/coil_sensitivities.py @@ -433,7 +433,8 @@ def estimate_sensitivities_universal( ```{note} This function is part of the family of [universal operators](https://mrphys.github.io/tensorflow-mri/guide/universal/), - a set of functions designed to work flexibly with any linear system. + a set of functions and classes designed to work flexibly with any linear + system. ``` Example: diff --git a/tensorflow_mri/python/layers/recon_adjoint.py b/tensorflow_mri/python/layers/recon_adjoint.py index 189db735..de46acca 100644 --- a/tensorflow_mri/python/layers/recon_adjoint.py +++ b/tensorflow_mri/python/layers/recon_adjoint.py @@ -29,14 +29,21 @@ class ReconAdjoint(tf.keras.layers.Layer): This layer reconstructs a signal using the adjoint of the specified system operator. - ```{seealso} - This is the Keras layer equivalent of `tfmri.recon.adjoint_universal`. - ``` - Given measurement data $b$ generated by a linear system $A$ such that $Ax = b$, this function estimates the corresponding signal $x$ as $x = A^H b$, where $A$ is the specified linear operator. + ```{note} + This function is part of the family of + [universal operators](https://mrphys.github.io/tensorflow-mri/guide/universal/), + a set of functions and classes designed to work flexibly with any linear + system. + ``` + + ```{seealso} + This is the Keras layer equivalent of `tfmri.recon.adjoint_universal`. + ``` + ## Inputs This layer's `call` method expects the following inputs: diff --git a/tensorflow_mri/python/recon/recon_adjoint.py b/tensorflow_mri/python/recon/recon_adjoint.py index 7a3fe2d5..dbfc70c7 100644 --- a/tensorflow_mri/python/recon/recon_adjoint.py +++ b/tensorflow_mri/python/recon/recon_adjoint.py @@ -31,7 +31,8 @@ def recon_adjoint(data, operator): ```{note} This function is part of the family of [universal operators](https://mrphys.github.io/tensorflow-mri/guide/universal/), - a set of functions designed to work flexibly with any linear system. + a set of functions and classes designed to work flexibly with any linear + system. ``` ```{seealso} From 24ec5b4c2e29d0e079dfbe71923b38f4037dd7dc Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Fri, 2 Sep 2022 16:54:20 +0000 Subject: [PATCH 082/101] Fixed bug in linear operator, rotations, add TFMRI doc links --- tensorflow_mri/python/geometry/rotation_2d.py | 33 +++++++++++++------ .../python/geometry/rotation_2d_test.py | 16 ++++++--- tensorflow_mri/python/geometry/rotation_3d.py | 9 +++-- .../python/geometry/rotation_3d_test.py | 16 ++++++--- .../python/linalg/linear_operator.py | 9 ++++- tensorflow_mri/python/recon/recon_adjoint.py | 2 +- tools/docs/conf.py | 8 +++++ 7 files changed, 69 insertions(+), 24 deletions(-) diff --git a/tensorflow_mri/python/geometry/rotation_2d.py b/tensorflow_mri/python/geometry/rotation_2d.py index b3946f0b..84d45ad3 100644 --- a/tensorflow_mri/python/geometry/rotation_2d.py +++ b/tensorflow_mri/python/geometry/rotation_2d.py @@ -66,10 +66,9 @@ class Rotation2D(tf.experimental.BatchableExtensionType): ## Shape and dtype `Rotation2D` objects have a shape and a dtype, accessible via the `shape` and - `dtype` properties. The shape represents the shape of the array of - "rotations", so it is essentially the batch shape of the corresponding - rotation matrix or angles array (i.e., a `Rotation2D` representing a single - rotation has a scalar shape). + `dtype` properties. Because this operator acts like a rotation matrix, its + shape corresponds to the shape of the rotation matrix. In other words, + `rot.shape` is equal to `rot.as_matrix().shape`. ```{note} As with `tf.Tensor`s, the `shape` attribute contains the static shape @@ -101,6 +100,10 @@ class Rotation2D(tf.experimental.BatchableExtensionType): * - API - Description - Notes + * - `tf.convert_to_tensor` + - Converts a `Rotation2D` to a `tf.Tensor` containing the corresponding + rotation matrix. + - `tf.convert_to_tensor(rot)` is equivalent to `rot.as_matrix()`. * - `tf.linalg.matmul` - Composes two `Rotation2D` objects. - `tf.linalg.matmul(rot1, rot2)` is equivalent to `rot1 @ rot2`. @@ -112,10 +115,15 @@ class Rotation2D(tf.experimental.BatchableExtensionType): - ``` + ```{tip} + In general, a `Rotation2D` object behaves like a rotation matrix, although + its internal representation may differ. + ``` + ```{warning} - While other TensorFlow APIs may also work as expected when passed a - `Rotation2D`, this is not supported and their behavior may change in the - future. + While other TensorFlow APIs may also work as expected when passed a + `Rotation2D`, this is not supported and their behavior may change in the + future. ``` Example: @@ -123,7 +131,7 @@ class Rotation2D(tf.experimental.BatchableExtensionType): >>> # Initialize a rotation object using a rotation matrix. >>> rot = tfmri.geometry.Rotation2D.from_matrix([[0.0, -1.0], [1.0, 0.0]]) >>> print(rot) - tfmri.geometry.Rotation2D(shape=(), dtype=float32) + tfmri.geometry.Rotation2D(shape=(2, 2), dtype=float32) >>> # Rotate a point. >>> point = tf.constant([1.0, 0.0], dtype=tf.float32) >>> rotated = rot.rotate(point) @@ -348,7 +356,7 @@ def shape(self): Returns: A `tf.TensorShape`. """ - return self._matrix.shape[:-2] + return self._matrix.shape @property def dtype(self): @@ -360,6 +368,11 @@ def dtype(self): return self._matrix.dtype +@tf.experimental.dispatch_for_api(tf.convert_to_tensor, {'value': Rotation2D}) +def convert_to_tensor(value, dtype=None, dtype_hint=None, name=None): + return value.as_matrix() + + @tf.experimental.dispatch_for_api( tf.linalg.matmul, {'a': Rotation2D, 'b': Rotation2D}) def matmul(a, b, @@ -399,4 +412,4 @@ def matvec(a, b, @tf.experimental.dispatch_for_api(tf.shape, {'input': Rotation2D}) def shape(input, out_type=tf.int32, name=None): - return tf.shape(input.as_matrix(), out_type=out_type, name=name)[:-2] + return tf.shape(input.as_matrix(), out_type=out_type, name=name) diff --git a/tensorflow_mri/python/geometry/rotation_2d_test.py b/tensorflow_mri/python/geometry/rotation_2d_test.py index 93341a8c..352e72f5 100644 --- a/tensorflow_mri/python/geometry/rotation_2d_test.py +++ b/tensorflow_mri/python/geometry/rotation_2d_test.py @@ -45,12 +45,12 @@ class Rotation2DTest(test_util.TestCase): def test_shape(self): """Tests shape.""" rot = Rotation2D.from_euler([0.0]) - self.assertAllEqual([], rot.shape) - self.assertAllEqual([], tf.shape(rot)) + self.assertAllEqual([2, 2], rot.shape) + self.assertAllEqual([2, 2], tf.shape(rot)) rot = Rotation2D.from_euler([[0.0], [np.pi]]) - self.assertAllEqual([2], rot.shape) - self.assertAllEqual([2], tf.shape(rot)) + self.assertAllEqual([2, 2, 2], rot.shape) + self.assertAllEqual([2, 2, 2], tf.shape(rot)) def test_equal(self): """Tests equality operator.""" @@ -72,7 +72,7 @@ def test_equal(self): def test_repr(self): """Tests that repr works.""" - expected = "" + expected = "" rot = Rotation2D.from_euler([0.0]) self.assertEqual(expected, repr(rot)) self.assertEqual(expected[1:-1], str(rot)) @@ -92,6 +92,12 @@ def test_matvec(self): vec = tf.constant([1.0, -1.0]) self.assertAllClose(rot.rotate(vec), tf.linalg.matvec(rot, vec)) + def test_convert_to_tensor(self): + """Tests that conversion to tensor works.""" + rot = Rotation2D.from_euler([0.0]) + self.assertIsInstance(tf.convert_to_tensor(rot), tf.Tensor) + self.assertAllClose(np.eye(2), tf.convert_to_tensor(rot)) + @parameterized.named_parameters( ("0", [0.0]), ("45", [np.pi / 4]), diff --git a/tensorflow_mri/python/geometry/rotation_3d.py b/tensorflow_mri/python/geometry/rotation_3d.py index 6b0ab544..5b623ce5 100644 --- a/tensorflow_mri/python/geometry/rotation_3d.py +++ b/tensorflow_mri/python/geometry/rotation_3d.py @@ -239,7 +239,7 @@ def shape(self): Returns: A `tf.TensorShape`. """ - return self._matrix.shape[:-2] + return self._matrix.shape @property def dtype(self): @@ -251,6 +251,11 @@ def dtype(self): return self._matrix.dtype +@tf.experimental.dispatch_for_api(tf.convert_to_tensor, {'value': Rotation3D}) +def convert_to_tensor(value, dtype=None, dtype_hint=None, name=None): + return value.as_matrix() + + @tf.experimental.dispatch_for_api( tf.linalg.matmul, {'a': Rotation3D, 'b': Rotation3D}) def matmul(a, b, @@ -290,4 +295,4 @@ def matvec(a, b, @tf.experimental.dispatch_for_api(tf.shape, {'input': Rotation3D}) def shape(input, out_type=tf.int32, name=None): - return tf.shape(input.as_matrix(), out_type=out_type, name=name)[:-2] + return tf.shape(input.as_matrix(), out_type=out_type, name=name) diff --git a/tensorflow_mri/python/geometry/rotation_3d_test.py b/tensorflow_mri/python/geometry/rotation_3d_test.py index bb96dfae..c212dfa1 100644 --- a/tensorflow_mri/python/geometry/rotation_3d_test.py +++ b/tensorflow_mri/python/geometry/rotation_3d_test.py @@ -44,12 +44,12 @@ class Rotation3DTest(test_util.TestCase): def test_shape(self): """Tests shape.""" rot = Rotation3D.from_euler([0.0, 0.0, 0.0]) - self.assertAllEqual([], rot.shape) - self.assertAllEqual([], tf.shape(rot)) + self.assertAllEqual([3, 3], rot.shape) + self.assertAllEqual([3, 3], tf.shape(rot)) rot = Rotation3D.from_euler([[0.0, 0.0, 0.0], [np.pi, 0.0, 0.0]]) - self.assertAllEqual([2], rot.shape) - self.assertAllEqual([2], tf.shape(rot)) + self.assertAllEqual([2, 3, 3], rot.shape) + self.assertAllEqual([2, 3, 3], tf.shape(rot)) def test_equal(self): """Tests equality operator.""" @@ -72,7 +72,13 @@ def test_equal(self): def test_repr(self): rot = Rotation3D.from_euler([0.0, 0.0, 0.0]) self.assertEqual( - "", repr(rot)) + "", repr(rot)) + + def test_convert_to_tensor(self): + """Tests that conversion to tensor works.""" + rot = Rotation3D.from_euler([0.0, 0.0, 0.0]) + self.assertIsInstance(tf.convert_to_tensor(rot), tf.Tensor) + self.assertAllClose(np.eye(3), tf.convert_to_tensor(rot)) def test_from_axis_angle_normalized_random(self): """Tests that axis-angles can be converted to rotation matrices.""" diff --git a/tensorflow_mri/python/linalg/linear_operator.py b/tensorflow_mri/python/linalg/linear_operator.py index 7b95e99b..5eeb5a6d 100644 --- a/tensorflow_mri/python/linalg/linear_operator.py +++ b/tensorflow_mri/python/linalg/linear_operator.py @@ -605,7 +605,7 @@ def _batch(self, batch_size): lambda spec: spec._batch(batch_size), # pylint: disable=protected-access self._param_specs)) - def _unbatch(self, batch_size): + def _unbatch(self): """Returns a TypeSpec representing a single element of this TypeSpec.""" return self._copy( param_specs=tf.nest.map_structure( @@ -614,8 +614,15 @@ def _unbatch(self, batch_size): @property def shape(self): + """Returns a `tf.TensorShape` representing the static shape.""" + # This property is required to use linear operators with Keras. return self._shape + def with_shape(self, shape): + """Returns a new `tf.TypeSpec` with the given shape.""" + # This method is required to use linear operators with Keras. + return self._copy(shape=shape) + def make_composite_tensor(cls, module_name="tfmri.linalg"): """Class decorator to convert `LinearOperator`s to `CompositeTensor`s. diff --git a/tensorflow_mri/python/recon/recon_adjoint.py b/tensorflow_mri/python/recon/recon_adjoint.py index dbfc70c7..a4e69626 100644 --- a/tensorflow_mri/python/recon/recon_adjoint.py +++ b/tensorflow_mri/python/recon/recon_adjoint.py @@ -16,8 +16,8 @@ import tensorflow as tf -from tensorflow_mri.python.util import api_util from tensorflow_mri.python.linalg import linear_operator_mri +from tensorflow_mri.python.util import api_util @api_util.export("recon.adjoint_universal") diff --git a/tools/docs/conf.py b/tools/docs/conf.py index 5b6b5532..c564fd45 100644 --- a/tools/docs/conf.py +++ b/tools/docs/conf.py @@ -260,6 +260,7 @@ def process_docstring(app, what, name, obj, options, lines): # pylint: disable= blankline_re = re.compile(r"^\s*$") prompt_re = re.compile(r"^\s*>>>") tf_symbol_re = re.compile(r"`(?Ptf\.[a-zA-Z0-9_.]+)`") + tfmri_symbol_re = re.compile(r"`(?Ptfmri\.[a-zA-Z0-9_.]+)`") # Loop initialization. `insert_lines` keeps a list of lines to be inserted # as well as their positions. @@ -295,6 +296,13 @@ def process_docstring(app, what, name, obj, options, lines): # pylint: disable= link = f"https://www.tensorflow.org/api_docs/python/{symbol.replace('.', '/')}" lines[lineno] = line.replace(f"`{symbol}`", f"[`{symbol}`]({link})") + # Add links to TFMRI symbols. + m = tfmri_symbol_re.search(line) + if m: + symbol = m.group('symbol') + link = f"https://mrphys.github.io/tensorflow-mri/api_docs/{symbol.replace('.', '/')}" + lines[lineno] = line.replace(f"`{symbol}`", f"[`{symbol}`]({link})") + # Now insert the lines (in reversed order so that line numbers stay valid). for lineno, line in reversed(insert_lines): lines.insert(lineno, line) From c98dd9f547d4ca8fd9cb30089fbb9495f29e4835 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Fri, 2 Sep 2022 18:17:25 +0000 Subject: [PATCH 083/101] Add density property to MRI linop --- tensorflow_mri/python/linalg/linear_operator_mri.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/tensorflow_mri/python/linalg/linear_operator_mri.py b/tensorflow_mri/python/linalg/linear_operator_mri.py index 8793beb3..80c45456 100644 --- a/tensorflow_mri/python/linalg/linear_operator_mri.py +++ b/tensorflow_mri/python/linalg/linear_operator_mri.py @@ -537,6 +537,14 @@ def trajectory(self): """ return self._trajectory + @property + def density(self): + """The density compensation function. + + Returns `None` for Cartesian imaging. + """ + return self._density + @property def is_cartesian(self): """Whether this is a Cartesian MRI operator.""" From 96cfa72a00b9afe7b5e716a043201e24fe3d8a57 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Mon, 5 Sep 2022 16:14:45 +0000 Subject: [PATCH 084/101] New MRI layers --- CODEOWNERS | 1 + .../python/coils/coil_sensitivities.py | 55 +++++-- .../python/layers/coil_sensitivities.py | 154 ++++++++++++++++++ .../python/layers/data_consistency.py | 112 +++++++++++++ tensorflow_mri/python/layers/recon_adjoint.py | 41 ++++- tensorflow_mri/python/util/layer_util.py | 9 + 6 files changed, 352 insertions(+), 20 deletions(-) create mode 100644 CODEOWNERS create mode 100644 tensorflow_mri/python/layers/coil_sensitivities.py create mode 100644 tensorflow_mri/python/layers/data_consistency.py diff --git a/CODEOWNERS b/CODEOWNERS new file mode 100644 index 00000000..16609512 --- /dev/null +++ b/CODEOWNERS @@ -0,0 +1 @@ +* @jmontalt diff --git a/tensorflow_mri/python/coils/coil_sensitivities.py b/tensorflow_mri/python/coils/coil_sensitivities.py index 5f7f410c..6d70fad8 100644 --- a/tensorflow_mri/python/coils/coil_sensitivities.py +++ b/tensorflow_mri/python/coils/coil_sensitivities.py @@ -413,7 +413,7 @@ def estimate_sensitivities_universal( operator, calib_data=None, calib_fn=None, - method='walsh', + algorithm='walsh', **kwargs): """Estimates coil sensitivities (universal). @@ -494,16 +494,28 @@ def estimate_sensitivities_universal( ```{tip} In MRI, this is usually the central, fully-sampled region of *k*-space. ``` - calib_fn: A callable which extracts the calibration data from the input - `data`. Must have signature - `calib_fn(data, operator) -> calib_data`. If `None`, `calib_data` - will be used for calibration. If `calib_data` is also `None`, `data` - will be used directly for calibration. - method: A `str` specifying which coil sensitivity estimation algorithm to - use. Must be one of `'direct'`, `'walsh'`, `'inati'` or `'espirit'`. + calib_fn: A callable which returns the calibration data given the input + `data` and `operator`. Must have signature + `calib_fn(data: tf.Tensor, operator: tfmri.linalg.LinearOperator) -> tf.Tensor`. + If `None`, `calib_data` will be used for calibration. If `calib_data` is + also `None`, `data` will be used directly for calibration. + algorithm: A `str` or a callable specifying the coil sensitivity estimation + algorithm. Must be one of the following: + - A `str` to use one of the default algorithms, which are: + - `'direct'`: Uses images extracted from calibration data directly as + coil sensitivities. + - `'walsh'`: Implements the algorithm described in Walsh et al. [1]. + - `'inati'`: Implements the algorithm described in Inati et al. [2]. + - `'espirit'`: Implements the algorithm described in Uecker et al. [3]. + - A callable which returns the coil sensitivity maps given + `calib_data` and `operator`. Must have signature + `algorithm(calib_data: tf.Tensor, operator: tfmri.linalg.LinearOperator, **kwargs) -> tf.Tensor`, + i.e., it should accept the calibration data and return the coil + sensitivity maps. Defaults to `'walsh'`. - **kwargs: Additional keyword arguments depending on the `method`. For a - list of available arguments, see `tfmri.coils.estimate_sensitivites`. + **kwargs: Additional keyword arguments to be passed to the coil sensitivity + estimation algorithm. For a list of arguments available for the default + algorithms, see `tfmri.coils.estimate_sensitivites`. Returns: A `tf.Tensor` of shape `[..., coils, *spatial_dims]` containing the coil @@ -511,6 +523,19 @@ def estimate_sensitivities_universal( Raises: ValueError: If both `calib_data` and `calib_fn` are provided. + + References: + 1. Walsh, D.O., Gmitro, A.F. and Marcellin, M.W. (2000), Adaptive + reconstruction of phased array MR imagery. Magn. Reson. Med., 43: + 682-690. https://doi.org/10.1002/(SICI)1522-2594(200005)43:5<682::AID-MRM10>3.0.CO;2-G + 2. Inati, S.J., Hansen, M.S. and Kellman, P. (2014). A fast optimal + method for coil sensitivity estimation and adaptive coil combination for + complex images. Proceedings of the 2014 Joint Annual Meeting + ISMRM-ESMRMB. + 3. Uecker, M., Lai, P., Murphy, M.J., Virtue, P., Elad, M., Pauly, J.M., + Vasanawala, S.S. and Lustig, M. (2014), ESPIRiT—an eigenvalue approach + to autocalibrating parallel MRI: Where SENSE meets GRAPPA. Magn. Reson. + Med., 71: 990-1001. https://doi.org/10.1002/mrm.24751 """ with tf.name_scope(kwargs.get('name', 'estimate_sensitivities_universal')): rank = operator.rank @@ -526,17 +551,21 @@ def estimate_sensitivities_universal( raise ValueError( "Only one of `calib_data` and `calib_fn` may be specified.") + if callable(algorithm): + # Using a custom algorithm. + return algorithm(calib_data, operator, **kwargs) + # Reconstruct image. calib_data = recon_adjoint.recon_adjoint(calib_data, operator) # If method is `'direct'`, we simply return the reconstructed calibration # data. - if method == 'direct': + if algorithm == 'direct': return calib_data # ESPIRiT method takes in k-space data, so convert back to k-space in this # case. - if method == 'espirit': + if algorithm == 'espirit': axes = list(range(-rank, 0)) calib_data = fft_ops.fftn(calib_data, axes=axes, norm='ortho', shift=True) @@ -550,7 +579,7 @@ def estimate_sensitivities_universal( maps = tf.map_fn( functools.partial(estimate_sensitivities, coil_axis=-(rank + 1), - method=method, + method=algorithm, **kwargs), calib_data) diff --git a/tensorflow_mri/python/layers/coil_sensitivities.py b/tensorflow_mri/python/layers/coil_sensitivities.py new file mode 100644 index 00000000..56b5e647 --- /dev/null +++ b/tensorflow_mri/python/layers/coil_sensitivities.py @@ -0,0 +1,154 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Coil sensitivity estimation layer.""" + +import string + +import tensorflow as tf + +from tensorflow_mri.python.activations import complex_activations +from tensorflow_mri.python.coils import coil_sensitivities +from tensorflow_mri.python.linalg import linear_operator_mri +from tensorflow_mri.python.ops import math_ops +from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.util import doc_util +from tensorflow_mri.python.util import model_util + + +class CoilSensitivityEstimation(tf.keras.layers.Layer): + r"""${rank}D coil sensitivity estimation layer. + + This layer extracts a calibration region and estimates the coil sensitivity + maps. + """ + def __init__(self, + rank, + calib_fn=None, + algorithm='walsh', + algorithm_kwargs=None, + refine_sensitivities=False, + refinement_network=None, + normalize_sensitivities=True, + expand_channel_dim=False, + reinterpret_complex=False, + **kwargs): + super().__init__(**kwargs) + self.rank = rank + self.calib_fn = calib_fn + self.algorithm = algorithm + self.algorithm_kwargs = algorithm_kwargs or {} + self.refine_sensitivities = refine_sensitivities + self.refinement_network = refinement_network + self.normalize_sensitivities = normalize_sensitivities + self.expand_channel_dim = expand_channel_dim + self.reinterpret_complex = reinterpret_complex + + if self.refine_sensitivities and self.refinement_network is None: + # Default map refinement network. + dtype = tf.as_dtype(self.dtype) + network_class = model_util.get_nd_model('UNet', rank) + network_kwargs = dict( + filters=[32, 64, 128], + kernel_size=3, + activation=('relu' if self.reinterpret_complex else 'complex_relu'), + output_filters=2 if self.reinterpret_complex else 1, + dtype=dtype.real_dtype if self.reinterpret_complex else dtype) + self.refinement_network = tf.keras.layers.TimeDistributed( + network_class(**network_kwargs)) + + def call(self, inputs): + data, operator, calib_data = parse_inputs(inputs) + + # Compute coil sensitivities. + maps = coil_sensitivities.estimate_sensitivities_universal( + data, + operator, + calib_data=calib_data, + calib_fn=self.calib_fn, + algorithm=self.algorithm, + **self.algorithm_kwargs) + + # Maybe refine coil sensitivities. + if self.refine_sensitivities: + maps = tf.expand_dims(maps, axis=-1) + if self.reinterpret_complex: + maps = math_ops.view_as_real(maps, stacked=False) + maps = self.refinement_network(maps) + if self.reinterpret_complex: + maps = math_ops.view_as_complex(maps, stacked=False) + maps = tf.squeeze(maps, axis=-1) + + # Maybe normalize coil sensitivities. + if self.normalize_sensitivities: + coil_axis = -(self.rank + 1) + maps = math_ops.normalize_no_nan(maps, axis=coil_axis) + + # # Post-processing. + # if self.expand_channel_dim: + # maps = tf.expand_dims(maps, axis=-1) + # if self.reinterpret_complex and maps.dtype.is_complex: + # maps = math_ops.view_as_real(maps, stacked=False) + + return maps + + def get_config(self): + base_config = super().get_config() + config = { + 'calib_fn': self.calib_fn, + 'algorithm': self.algorithm, + 'algorithm_kwargs': self.algorithm_kwargs, + 'refine_sensitivities': self.refine_sensitivities, + 'refinement_network': self.refinement_network, + 'normalize_sensitivities': self.normalize_sensitivities, + 'expand_channel_dim': self.expand_channel_dim, + 'reinterpret_complex': self.reinterpret_complex, + } + return {**base_config, **config} + + +def parse_inputs(inputs): + def _parse_inputs(data, operator, calib_data=None): + return data, operator, calib_data + if isinstance(inputs, tuple): + return _parse_inputs(*inputs) + elif isinstance(inputs, dict): + return _parse_inputs(**inputs) + raise ValueError('inputs must be a tuple or dict') + + +@api_util.export("layers.CoilSensitivityEstimation2D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class CoilSensitivityEstimation2D(CoilSensitivityEstimation): + def __init__(self, *args, **kwargs): + super().__init__(2, *args, **kwargs) + + +@api_util.export("models.CoilSensitivityEstimation3D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class CoilSensitivityEstimation3D(CoilSensitivityEstimation): + def __init__(self, *args, **kwargs): + super().__init__(3, *args, **kwargs) + + +CoilSensitivityEstimation2D.__doc__ = string.Template( + CoilSensitivityEstimation.__doc__).safe_substitute(rank=2) +CoilSensitivityEstimation3D.__doc__ = string.Template( + CoilSensitivityEstimation.__doc__).safe_substitute(rank=3) + + +CoilSensitivityEstimation2D.__signature__ = doc_util.get_nd_layer_signature( + CoilSensitivityEstimation) +CoilSensitivityEstimation3D.__signature__ = doc_util.get_nd_layer_signature( + CoilSensitivityEstimation) diff --git a/tensorflow_mri/python/layers/data_consistency.py b/tensorflow_mri/python/layers/data_consistency.py new file mode 100644 index 00000000..ae6b44e5 --- /dev/null +++ b/tensorflow_mri/python/layers/data_consistency.py @@ -0,0 +1,112 @@ +# Copyright 2022 University College London. 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. +# ============================================================================== +"""Data consistency layers.""" + +import string + +import tensorflow as tf + +from tensorflow_mri.python.ops import math_ops +from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.util import doc_util + + +class LeastSquaresGradientDescent(tf.keras.layers.Layer): + """Least squares gradient descent layer. + """ + def __init__(self, + rank, + scale_initializer=1.0, + expand_channel_dim=False, + reinterpret_complex=False, + **kwargs): + super().__init__(**kwargs) + self.rank = rank + if isinstance(scale_initializer, (float, int)): + self.scale_initializer = tf.keras.initializers.Constant(scale_initializer) + else: + self.scale_initializer = tf.keras.initializers.get(scale_initializer) + self.expand_channel_dim = expand_channel_dim + self.reinterpret_complex = reinterpret_complex + + def build(self, input_shape): + super().build(input_shape) + self.scale = self.add_weight( + name='scale', + shape=(), + dtype=tf.as_dtype(self.dtype).real_dtype, + initializer=self.scale_initializer, + trainable=self.trainable, + constraint=tf.keras.constraints.NonNeg()) + + def call(self, inputs): + image, data, operator = parse_inputs(inputs) + if self.reinterpret_complex: + image = math_ops.view_as_complex(image, stacked=False) + if self.expand_channel_dim: + image = tf.squeeze(image, axis=-1) + image -= tf.cast(self.scale, image.dtype) * operator.transform( + operator.transform(image) - data, adjoint=True) + if self.expand_channel_dim: + image = tf.expand_dims(image, axis=-1) + if self.reinterpret_complex: + image = math_ops.view_as_real(image, stacked=False) + return image + + def get_config(self): + base_config = super().get_config() + config = { + 'scale_initializer': tf.keras.initializers.serialize( + self.scale_initializer), + 'expand_channel_dim': self.expand_channel_dim, + 'reinterpret_complex': self.reinterpret_complex + } + return {**base_config, **config} + + +def parse_inputs(inputs): + def _parse_inputs(image, data, operator): + return image, data, operator + if isinstance(inputs, tuple): + return _parse_inputs(*inputs) + elif isinstance(inputs, dict): + return _parse_inputs(**inputs) + raise ValueError('inputs must be a tuple or dict') + + +@api_util.export("layers.LeastSquaresGradientDescent2D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class LeastSquaresGradientDescent2D(LeastSquaresGradientDescent): + def __init__(self, *args, **kwargs): + super().__init__(2, *args, **kwargs) + + +@api_util.export("models.LeastSquaresGradientDescent3D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class LeastSquaresGradientDescent3D(LeastSquaresGradientDescent): + def __init__(self, *args, **kwargs): + super().__init__(3, *args, **kwargs) + + +LeastSquaresGradientDescent2D.__doc__ = string.Template( + LeastSquaresGradientDescent.__doc__).safe_substitute(rank=2) +LeastSquaresGradientDescent3D.__doc__ = string.Template( + LeastSquaresGradientDescent.__doc__).safe_substitute(rank=3) + + +LeastSquaresGradientDescent2D.__signature__ = doc_util.get_nd_layer_signature( + LeastSquaresGradientDescent) +LeastSquaresGradientDescent3D.__signature__ = doc_util.get_nd_layer_signature( + LeastSquaresGradientDescent) diff --git a/tensorflow_mri/python/layers/recon_adjoint.py b/tensorflow_mri/python/layers/recon_adjoint.py index de46acca..3535b05c 100644 --- a/tensorflow_mri/python/layers/recon_adjoint.py +++ b/tensorflow_mri/python/layers/recon_adjoint.py @@ -14,17 +14,18 @@ # ============================================================================== """Adjoint reconstruction layer.""" +import string + import tensorflow as tf from tensorflow_mri.python.ops import math_ops from tensorflow_mri.python.recon import recon_adjoint from tensorflow_mri.python.util import api_util +from tensorflow_mri.python.util import doc_util -@api_util.export("layers.ReconAdjoint") -@tf.keras.utils.register_keras_serializable(package="MRI") class ReconAdjoint(tf.keras.layers.Layer): - r"""Adjoint reconstruction layer. + r"""${rank}D adjoint reconstruction layer. This layer reconstructs a signal using the adjoint of the specified system operator. @@ -69,8 +70,8 @@ class ReconAdjoint(tf.keras.layers.Layer): Args: expand_channel_dim: A `boolean`. Whether to expand the channel dimension. - If `True`, the output has shape `[*batch_shape, ${dim_names}, 1]`. - If `False`, the output has shape `[*batch_shape, ${dim_names}]`. + If `True`, output has shape `batch_shape + operator.domain_shape + [1]`. + If `False`, output has shape `batch_shape + operator.domain_shape`. Defaults to `True`. reinterpret_complex: A `boolean`. Whether to reinterpret a complex-valued output image as a dual-channel real image. Defaults to `False`. @@ -78,10 +79,12 @@ class ReconAdjoint(tf.keras.layers.Layer): `tf.keras.layers.Layer`. """ def __init__(self, - expand_channel_dim=True, + rank, + expand_channel_dim=False, reinterpret_complex=False, **kwargs): super().__init__(**kwargs) + self.rank = rank # Currently unused. self.expand_channel_dim = expand_channel_dim self.reinterpret_complex = reinterpret_complex @@ -90,7 +93,7 @@ def call(self, inputs): image = recon_adjoint.recon_adjoint(data, operator) if self.expand_channel_dim: image = tf.expand_dims(image, axis=-1) - if self.reinterpret_complex and tf.as_dtype(self.dtype).is_complex: + if self.reinterpret_complex and image.dtype.is_complex: image = math_ops.view_as_real(image, stacked=False) return image @@ -111,3 +114,27 @@ def _parse_inputs(data, operator): elif isinstance(inputs, dict): return _parse_inputs(**inputs) raise ValueError('inputs must be a tuple or dict') + + +@api_util.export("layers.ReconAdjoint2D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class ReconAdjoint2D(ReconAdjoint): + def __init__(self, *args, **kwargs): + super().__init__(2, *args, **kwargs) + + +@api_util.export("models.ReconAdjoint3D") +@tf.keras.utils.register_keras_serializable(package='MRI') +class ReconAdjoint3D(ReconAdjoint): + def __init__(self, *args, **kwargs): + super().__init__(3, *args, **kwargs) + + +ReconAdjoint2D.__doc__ = string.Template( + ReconAdjoint.__doc__).safe_substitute(rank=2) +ReconAdjoint3D.__doc__ = string.Template( + ReconAdjoint.__doc__).safe_substitute(rank=3) + + +ReconAdjoint2D.__signature__ = doc_util.get_nd_layer_signature(ReconAdjoint) +ReconAdjoint3D.__signature__ = doc_util.get_nd_layer_signature(ReconAdjoint) diff --git a/tensorflow_mri/python/util/layer_util.py b/tensorflow_mri/python/util/layer_util.py index a4064fb0..0df7c1da 100644 --- a/tensorflow_mri/python/util/layer_util.py +++ b/tensorflow_mri/python/util/layer_util.py @@ -16,10 +16,13 @@ import tensorflow as tf +from tensorflow_mri.python.layers import coil_sensitivities from tensorflow_mri.python.layers import convolutional +from tensorflow_mri.python.layers import data_consistency from tensorflow_mri.python.layers import padding from tensorflow_mri.python.layers import pooling from tensorflow_mri.python.layers import reshaping +from tensorflow_mri.python.layers import recon_adjoint from tensorflow_mri.python.layers import signal_layers @@ -47,6 +50,8 @@ def get_nd_layer(name, rank): ('AveragePooling', 1): pooling.AveragePooling1D, ('AveragePooling', 2): pooling.AveragePooling2D, ('AveragePooling', 3): pooling.AveragePooling3D, + ('CoilSensitivityEstimation', 2): coil_sensitivities.CoilSensitivityEstimation2D, + ('CoilSensitivityEstimation', 3): coil_sensitivities.CoilSensitivityEstimation3D, ('Conv', 1): convolutional.Conv1D, ('Conv', 2): convolutional.Conv2D, ('Conv', 3): convolutional.Conv3D, @@ -76,11 +81,15 @@ def get_nd_layer(name, rank): ('IDWT', 1): signal_layers.IDWT1D, ('IDWT', 2): signal_layers.IDWT2D, ('IDWT', 3): signal_layers.IDWT3D, + ('LeastSquaresGradientDescent', 2): data_consistency.LeastSquaresGradientDescent2D, + ('LeastSquaresGradientDescent', 3): data_consistency.LeastSquaresGradientDescent3D, ('LocallyConnected', 1): tf.keras.layers.LocallyConnected1D, ('LocallyConnected', 2): tf.keras.layers.LocallyConnected2D, ('MaxPool', 1): pooling.MaxPooling1D, ('MaxPool', 2): pooling.MaxPooling2D, ('MaxPool', 3): pooling.MaxPooling3D, + ('ReconAdjoint', 2): recon_adjoint.ReconAdjoint2D, + ('ReconAdjoint', 3): recon_adjoint.ReconAdjoint3D, ('SeparableConv', 1): tf.keras.layers.SeparableConv1D, ('SeparableConv', 2): tf.keras.layers.SeparableConv2D, ('SpatialDropout', 1): tf.keras.layers.SpatialDropout1D, From b2bf5ed5a00a55b968fefbad415fb60ce091dac7 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Mon, 5 Sep 2022 16:21:49 +0000 Subject: [PATCH 085/101] Update API --- tensorflow_mri/_api/layers/__init__.py | 7 ++++++- tensorflow_mri/_api/signal/__init__.py | 6 +++--- tensorflow_mri/python/layers/__init__.py | 2 ++ tensorflow_mri/python/layers/coil_sensitivities.py | 2 +- tensorflow_mri/python/layers/data_consistency.py | 2 +- tensorflow_mri/python/layers/recon_adjoint.py | 2 +- 6 files changed, 14 insertions(+), 7 deletions(-) diff --git a/tensorflow_mri/_api/layers/__init__.py b/tensorflow_mri/_api/layers/__init__.py index b02feb8a..793dd295 100644 --- a/tensorflow_mri/_api/layers/__init__.py +++ b/tensorflow_mri/_api/layers/__init__.py @@ -2,12 +2,16 @@ # Do not edit. """Keras layers.""" +from tensorflow_mri.python.layers.coil_sensitivities import CoilSensitivityEstimation2D as CoilSensitivityEstimation2D +from tensorflow_mri.python.layers.coil_sensitivities import CoilSensitivityEstimation3D as CoilSensitivityEstimation3D from tensorflow_mri.python.layers.convolutional import Conv1D as Conv1D from tensorflow_mri.python.layers.convolutional import Conv1D as Convolution1D from tensorflow_mri.python.layers.convolutional import Conv2D as Conv2D from tensorflow_mri.python.layers.convolutional import Conv2D as Convolution2D from tensorflow_mri.python.layers.convolutional import Conv3D as Conv3D from tensorflow_mri.python.layers.convolutional import Conv3D as Convolution3D +from tensorflow_mri.python.layers.data_consistency import LeastSquaresGradientDescent2D as LeastSquaresGradientDescent2D +from tensorflow_mri.python.layers.data_consistency import LeastSquaresGradientDescent3D as LeastSquaresGradientDescent3D from tensorflow_mri.python.layers.normalization import Normalized as Normalized from tensorflow_mri.python.layers.pooling import AveragePooling1D as AveragePooling1D from tensorflow_mri.python.layers.pooling import AveragePooling1D as AvgPool1D @@ -21,7 +25,8 @@ from tensorflow_mri.python.layers.pooling import MaxPooling2D as MaxPool2D from tensorflow_mri.python.layers.pooling import MaxPooling3D as MaxPooling3D from tensorflow_mri.python.layers.pooling import MaxPooling3D as MaxPool3D -from tensorflow_mri.python.layers.recon_adjoint import ReconAdjoint as ReconAdjoint +from tensorflow_mri.python.layers.recon_adjoint import ReconAdjoint2D as ReconAdjoint2D +from tensorflow_mri.python.layers.recon_adjoint import ReconAdjoint3D as ReconAdjoint3D from tensorflow_mri.python.layers.reshaping import UpSampling1D as UpSampling1D from tensorflow_mri.python.layers.reshaping import UpSampling2D as UpSampling2D from tensorflow_mri.python.layers.reshaping import UpSampling3D as UpSampling3D diff --git a/tensorflow_mri/_api/signal/__init__.py b/tensorflow_mri/_api/signal/__init__.py index fb4161e1..b6f632a6 100644 --- a/tensorflow_mri/_api/signal/__init__.py +++ b/tensorflow_mri/_api/signal/__init__.py @@ -9,6 +9,9 @@ from tensorflow_mri.python.ops.wavelet_ops import dwt_max_level as max_wavelet_level from tensorflow_mri.python.ops.wavelet_ops import coeffs_to_tensor as wavelet_coeffs_to_tensor from tensorflow_mri.python.ops.wavelet_ops import tensor_to_coeffs as tensor_to_wavelet_coeffs +from tensorflow_mri.python.ops.fft_ops import fftn as fft +from tensorflow_mri.python.ops.fft_ops import ifftn as ifft +from tensorflow_nufft.python.ops.nufft_ops import nufft as nufft from tensorflow_mri.python.ops.signal_ops import hann as hann from tensorflow_mri.python.ops.signal_ops import hamming as hamming from tensorflow_mri.python.ops.signal_ops import atanfilt as atanfilt @@ -16,6 +19,3 @@ from tensorflow_mri.python.ops.signal_ops import separable_window as separable_window from tensorflow_mri.python.ops.signal_ops import filter_kspace as filter_kspace from tensorflow_mri.python.ops.signal_ops import crop_kspace as crop_kspace -from tensorflow_mri.python.ops.fft_ops import fftn as fft -from tensorflow_mri.python.ops.fft_ops import ifftn as ifft -from tensorflow_nufft.python.ops.nufft_ops import nufft as nufft diff --git a/tensorflow_mri/python/layers/__init__.py b/tensorflow_mri/python/layers/__init__.py index 40991b3c..d97fe263 100644 --- a/tensorflow_mri/python/layers/__init__.py +++ b/tensorflow_mri/python/layers/__init__.py @@ -14,8 +14,10 @@ # ============================================================================== """Keras layers.""" +from tensorflow_mri.python.layers import coil_sensitivities from tensorflow_mri.python.layers import concatenate from tensorflow_mri.python.layers import convolutional +from tensorflow_mri.python.layers import data_consistency from tensorflow_mri.python.layers import normalization from tensorflow_mri.python.layers import pooling from tensorflow_mri.python.layers import preproc_layers diff --git a/tensorflow_mri/python/layers/coil_sensitivities.py b/tensorflow_mri/python/layers/coil_sensitivities.py index 56b5e647..5e7321bc 100644 --- a/tensorflow_mri/python/layers/coil_sensitivities.py +++ b/tensorflow_mri/python/layers/coil_sensitivities.py @@ -135,7 +135,7 @@ def __init__(self, *args, **kwargs): super().__init__(2, *args, **kwargs) -@api_util.export("models.CoilSensitivityEstimation3D") +@api_util.export("layers.CoilSensitivityEstimation3D") @tf.keras.utils.register_keras_serializable(package='MRI') class CoilSensitivityEstimation3D(CoilSensitivityEstimation): def __init__(self, *args, **kwargs): diff --git a/tensorflow_mri/python/layers/data_consistency.py b/tensorflow_mri/python/layers/data_consistency.py index ae6b44e5..62d0224f 100644 --- a/tensorflow_mri/python/layers/data_consistency.py +++ b/tensorflow_mri/python/layers/data_consistency.py @@ -93,7 +93,7 @@ def __init__(self, *args, **kwargs): super().__init__(2, *args, **kwargs) -@api_util.export("models.LeastSquaresGradientDescent3D") +@api_util.export("layers.LeastSquaresGradientDescent3D") @tf.keras.utils.register_keras_serializable(package='MRI') class LeastSquaresGradientDescent3D(LeastSquaresGradientDescent): def __init__(self, *args, **kwargs): diff --git a/tensorflow_mri/python/layers/recon_adjoint.py b/tensorflow_mri/python/layers/recon_adjoint.py index 3535b05c..db610fe3 100644 --- a/tensorflow_mri/python/layers/recon_adjoint.py +++ b/tensorflow_mri/python/layers/recon_adjoint.py @@ -123,7 +123,7 @@ def __init__(self, *args, **kwargs): super().__init__(2, *args, **kwargs) -@api_util.export("models.ReconAdjoint3D") +@api_util.export("layers.ReconAdjoint3D") @tf.keras.utils.register_keras_serializable(package='MRI') class ReconAdjoint3D(ReconAdjoint): def __init__(self, *args, **kwargs): From 8176df975a2601087a5d9d67c663a7a61f73d378 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 7 Sep 2022 11:48:26 +0100 Subject: [PATCH 086/101] Changed math syntax to MyST --- tensorflow_mri/python/activations/__init__.py | 6 +-- .../python/linalg/linear_operator.py | 12 +++--- .../python/linalg/linear_operator_addition.py | 8 ++-- .../linalg/linear_operator_composition.py | 8 ++-- .../python/linalg/linear_operator_diag.py | 4 +- .../python/linalg/linear_operator_mri.py | 2 +- .../python/losses/confusion_losses.py | 4 +- tensorflow_mri/python/losses/iqa_losses.py | 8 ++-- tensorflow_mri/python/ops/convex_ops.py | 40 +++++++++---------- tensorflow_mri/python/ops/math_ops.py | 24 +++++------ tensorflow_mri/python/ops/optimizer_ops.py | 14 +++---- tensorflow_mri/python/ops/recon_ops.py | 6 +-- 12 files changed, 68 insertions(+), 68 deletions(-) diff --git a/tensorflow_mri/python/activations/__init__.py b/tensorflow_mri/python/activations/__init__.py index 2421d271..398a8f60 100644 --- a/tensorflow_mri/python/activations/__init__.py +++ b/tensorflow_mri/python/activations/__init__.py @@ -53,7 +53,7 @@ def serialize(activation): A `str` denoting the name attribute of the input function. Raises: - ValueError: The input function is not a valid one. + ValueError: If the input function is not a valid one. """ return keras.activations.serialize(activation) @@ -130,8 +130,8 @@ def get(identifier): ValueError: Unknown activation function:abcd Raises: - ValueError: Input is an unknown function or string, i.e., the input does - not denote any defined function. + ValueError: If the input is an unknown function or string, i.e., the input + does not denote any defined function. """ if identifier is None: return keras.activations.linear diff --git a/tensorflow_mri/python/linalg/linear_operator.py b/tensorflow_mri/python/linalg/linear_operator.py index 5eeb5a6d..7ca2c860 100644 --- a/tensorflow_mri/python/linalg/linear_operator.py +++ b/tensorflow_mri/python/linalg/linear_operator.py @@ -423,8 +423,8 @@ class LinearOperator(LinearOperatorMixin, tf.linalg.LinearOperator): # pylint: is_self_adjoint: Expect that this operator is equal to its Hermitian transpose. If `dtype` is real, this is equivalent to being symmetric. is_positive_definite: Expect that this operator is positive definite, - meaning the quadratic form :math:`x^H A x` has positive real part for all - nonzero :math:`x`. Note that we do not require the operator to be + meaning the quadratic form $x^H A x$ has positive real part for all + nonzero $x$. Note that we do not require the operator to be self-adjoint to be positive-definite. is_square: Expect that this operator acts like square [batch] matrices. name: A name for this `LinearOperator`. @@ -443,8 +443,8 @@ class LinearOperatorAdjoint(LinearOperatorMixin, # pylint: disable=abstract-met tf.linalg.LinearOperatorAdjoint): """Linear operator representing the adjoint of another operator. - `LinearOperatorAdjoint` is initialized with an operator :math:`A` and - represents its adjoint :math:`A^H`. + `LinearOperatorAdjoint` is initialized with an operator $A$ and + represents its adjoint $A^H$. .. note: Similar to `tf.linalg.LinearOperatorAdjoint`_, but with imaging extensions. @@ -455,8 +455,8 @@ class LinearOperatorAdjoint(LinearOperatorMixin, # pylint: disable=abstract-met is_self_adjoint: Expect that this operator is equal to its Hermitian transpose. is_positive_definite: Expect that this operator is positive definite, - meaning the quadratic form :math:`x^H A x` has positive real part for all - nonzero :math:`x`. Note that we do not require the operator to be + meaning the quadratic form $x^H A x$ has positive real part for all + nonzero $x$. Note that we do not require the operator to be self-adjoint to be positive-definite. is_square: Expect that this operator acts like square [batch] matrices. name: A name for this `LinearOperator`. Default is `operator.name + diff --git a/tensorflow_mri/python/linalg/linear_operator_addition.py b/tensorflow_mri/python/linalg/linear_operator_addition.py index 5097cd59..332799e4 100644 --- a/tensorflow_mri/python/linalg/linear_operator_addition.py +++ b/tensorflow_mri/python/linalg/linear_operator_addition.py @@ -26,8 +26,8 @@ class LinearOperatorAddition(linear_operator.LinearOperatorMixin, # pylint: dis """Adds one or more linear operators. `LinearOperatorAddition` is initialized with a list of operators - :math:`A_1, A_2, ..., A_J` and represents their addition - :math:`A_1 + A_2 + ... + A_J`. + $A_1, A_2, ..., A_J$ and represents their addition + $A_1 + A_2 + ... + A_J$. Args: operators: A `list` of `LinearOperator` objects, each with the same `dtype` @@ -36,8 +36,8 @@ class LinearOperatorAddition(linear_operator.LinearOperatorMixin, # pylint: dis is_self_adjoint: Expect that this operator is equal to its Hermitian transpose. is_positive_definite: Expect that this operator is positive definite, - meaning the quadratic form :math:`x^H A x` has positive real part for all - nonzero :math:`x`. Note that we do not require the operator to be + meaning the quadratic form $x^H A x$ has positive real part for all + nonzero $x$. Note that we do not require the operator to be self-adjoint to be positive-definite. is_square: Expect that this operator acts like square [batch] matrices. name: A name for this `LinearOperator`. Default is the individual diff --git a/tensorflow_mri/python/linalg/linear_operator_composition.py b/tensorflow_mri/python/linalg/linear_operator_composition.py index 3078ba71..c6d268b9 100644 --- a/tensorflow_mri/python/linalg/linear_operator_composition.py +++ b/tensorflow_mri/python/linalg/linear_operator_composition.py @@ -27,8 +27,8 @@ class LinearOperatorComposition(linear_operator.LinearOperatorMixin, # pylint: """Composes one or more linear operators. `LinearOperatorComposition` is initialized with a list of operators - :math:`A_1, A_2, ..., A_J` and represents their composition - :math:`A_1 A_2 ... A_J`. + $A_1, A_2, ..., A_J$ and represents their composition + $A_1 A_2 ... A_J$. .. note: Similar to `tf.linalg.LinearOperatorComposition`_, but with imaging @@ -41,8 +41,8 @@ class LinearOperatorComposition(linear_operator.LinearOperatorMixin, # pylint: is_self_adjoint: Expect that this operator is equal to its Hermitian transpose. is_positive_definite: Expect that this operator is positive definite, - meaning the quadratic form :math:`x^H A x` has positive real part for all - nonzero :math:`x`. Note that we do not require the operator to be + meaning the quadratic form $x^H A x$ has positive real part for all + nonzero $x$. Note that we do not require the operator to be self-adjoint to be positive-definite. is_square: Expect that this operator acts like square [batch] matrices. name: A name for this `LinearOperator`. Default is the individual diff --git a/tensorflow_mri/python/linalg/linear_operator_diag.py b/tensorflow_mri/python/linalg/linear_operator_diag.py index a6658317..6d8f3295 100644 --- a/tensorflow_mri/python/linalg/linear_operator_diag.py +++ b/tensorflow_mri/python/linalg/linear_operator_diag.py @@ -42,8 +42,8 @@ class LinearOperatorDiag(linear_operator.LinearOperatorMixin, # pylint: disable is_self_adjoint: Expect that this operator is equal to its Hermitian transpose. If `diag` is real, this is auto-set to `True`. is_positive_definite: Expect that this operator is positive definite, - meaning the quadratic form :math:`x^H A x` has positive real part for all - nonzero :math:`x`. Note that we do not require the operator to be + meaning the quadratic form $x^H A x$ has positive real part for all + nonzero $x$. Note that we do not require the operator to be self-adjoint to be positive-definite. is_square: Expect that this operator acts like square [batch] matrices. name: A name for this `LinearOperator`. diff --git a/tensorflow_mri/python/linalg/linear_operator_mri.py b/tensorflow_mri/python/linalg/linear_operator_mri.py index 80c45456..d9743225 100644 --- a/tensorflow_mri/python/linalg/linear_operator_mri.py +++ b/tensorflow_mri/python/linalg/linear_operator_mri.py @@ -686,7 +686,7 @@ class LinearOperatorGramMRI(LinearOperatorMRI): # pylint: disable=abstract-meth used for regular dynamic reconstruction. The `'frequency'` mode should be used for reconstruction in x-f space. toeplitz_nufft: A `boolean`. If `True`, uses the Toeplitz approach [5] - to compute :math:`F^H F x`, where :math:`F` is the non-uniform Fourier + to compute $F^H F x$, where $F$ is the non-uniform Fourier operator. If `False`, the same operation is performed using the standard NUFFT operation. The Toeplitz approach might be faster than the direct approach but is slightly less accurate. This argument is only relevant diff --git a/tensorflow_mri/python/losses/confusion_losses.py b/tensorflow_mri/python/losses/confusion_losses.py index 0650192b..8ecacb4a 100644 --- a/tensorflow_mri/python/losses/confusion_losses.py +++ b/tensorflow_mri/python/losses/confusion_losses.py @@ -244,9 +244,9 @@ class FocalTverskyLoss(ConfusionLoss): epsilon: A `float`. A smoothing factor. Defaults to 1e-5. Notes: - [1] and [2] use inverted notations for the :math:`\alpha` and :math:`\beta` + [1] and [2] use inverted notations for the $\alpha$ and $\beta$ parameters. Here we use the notation of [1]. Also note that [2] refers to - :math:`\gamma` as :math:`\frac{1}{\gamma}`. + $\gamma$ as $\frac{1}{\gamma}$. References: [1] Salehi, S. S. M., Erdogmus, D., & Gholipour, A. (2017, September). diff --git a/tensorflow_mri/python/losses/iqa_losses.py b/tensorflow_mri/python/losses/iqa_losses.py index 99598450..629d53be 100644 --- a/tensorflow_mri/python/losses/iqa_losses.py +++ b/tensorflow_mri/python/losses/iqa_losses.py @@ -87,7 +87,7 @@ def get_config(self): class SSIMLoss(LossFunctionWrapperIQA): """Computes the structural similarity (SSIM) loss. - The SSIM loss is equal to :math:`1.0 - \textrm{SSIM}`. + The SSIM loss is equal to $1.0 - \textrm{SSIM}$. Args: max_val: The dynamic range of the images (i.e., the difference between @@ -161,7 +161,7 @@ def __init__(self, class SSIMMultiscaleLoss(LossFunctionWrapperIQA): """Computes the multiscale structural similarity (MS-SSIM) loss. - The MS-SSIM loss is equal to :math:`1.0 - \textrm{MS-SSIM}`. + The MS-SSIM loss is equal to $1.0 - \textrm{MS-SSIM}$. Args: max_val: The dynamic range of the images (i.e., the difference between @@ -243,7 +243,7 @@ def ssim_loss(y_true, y_pred, max_val=None, k1=0.01, k2=0.03, batch_dims=None, image_dims=None): r"""Computes the structural similarity (SSIM) loss. - The SSIM loss is equal to :math:`1.0 - \textrm{SSIM}`. + The SSIM loss is equal to $1.0 - \textrm{SSIM}$. Args: y_true: A `Tensor`. Ground truth images. For 2D images, must have rank >= 3 @@ -308,7 +308,7 @@ def ssim_multiscale_loss(y_true, y_pred, max_val=None, batch_dims=None, image_dims=None): r"""Computes the multiscale structural similarity (MS-SSIM) loss. - The MS-SSIM loss is equal to :math:`1.0 - \textrm{MS-SSIM}`. + The MS-SSIM loss is equal to $1.0 - \textrm{MS-SSIM}$. Args: y_true: A `Tensor`. Ground truth images. For 2D images, must have rank >= 3 diff --git a/tensorflow_mri/python/ops/convex_ops.py b/tensorflow_mri/python/ops/convex_ops.py index 76b89e56..b9dd61fc 100644 --- a/tensorflow_mri/python/ops/convex_ops.py +++ b/tensorflow_mri/python/ops/convex_ops.py @@ -38,8 +38,8 @@ class ConvexFunction(): r"""Base class defining a [batch of] convex function[s]. Represents a closed proper convex function - :math:`f : \mathbb{R}^{n}\rightarrow \mathbb{R}` or - :math:`f : \mathbb{C}^{n}\rightarrow \mathbb{R}`. + $f : \mathbb{R}^{n}\rightarrow \mathbb{R}$ or + $f : \mathbb{C}^{n}\rightarrow \mathbb{R}$. Subclasses should implement the `_call` and `_prox` methods to define the forward pass and the proximal mapping, respectively. Gradients are @@ -291,8 +291,8 @@ def _check_input_dtype(self, arg): class ConvexFunctionAffineMappingComposition(ConvexFunction): """Composes a convex function and an affine mapping. - Represents :math:`f(Ax + b)`, where :math:`f` is a `ConvexFunction`, - :math:`A` is a `LinearOperator` and :math:`b` is a constant `Tensor`. + Represents $f(Ax + b)$, where $f$ is a `ConvexFunction`, + $A$ is a `LinearOperator` and $b$ is a constant `Tensor`. Args: function: A `ConvexFunction`. @@ -350,8 +350,8 @@ class ConvexFunctionLinearOperatorComposition( # pylint: disable=abstract-metho ConvexFunctionAffineMappingComposition): r"""Composes a convex function and a linear operator. - Represents :math:`f(Ax)`, where :math:`f` is a `ConvexFunction` and - :math:`A` is a `LinearOperator`. + Represents $f(Ax)$, where $f$ is a `ConvexFunction` and + $A$ is a `LinearOperator`. Args: function: A `ConvexFunction`. @@ -619,15 +619,15 @@ def _prox(self, x, scale=None): class ConvexFunctionTikhonov(ConvexFunctionAffineMappingComposition): # pylint: disable=abstract-method r"""A `ConvexFunction` representing a Tikhonov regularization term. - For a given input :math:`x`, computes - :math:`\lambda \left\| T(x - x_0) \right\|_2^2`, where :math:`\lambda` is a - scaling factor, :math:`T` is any linear operator and :math:`x_0` is + For a given input $x$, computes + $\lambda \left\| T(x - x_0) \right\|_2^2$, where $\lambda$ is a + scaling factor, $T$ is any linear operator and $x_0$ is a prior estimate. Args: - transform: A `tf.linalg.LinearOperator`. The Tikhonov operator :math:`T`. + transform: A `tf.linalg.LinearOperator`. The Tikhonov operator $T$. Defaults to the identity operator. - prior: A `tf.Tensor`. The prior estimate :math:`x_0`. Defaults to 0. + prior: A `tf.Tensor`. The prior estimate $x_0$. Defaults to 0. domain_dimension: A scalar integer `tf.Tensor`. The dimension of the domain. scale: A `float`. The scaling factor. dtype: A `tf.DType`. The dtype of the inputs. Defaults to `float32`. @@ -673,8 +673,8 @@ def prior(self): class ConvexFunctionTotalVariation(ConvexFunctionLinearOperatorComposition): # pylint: disable=abstract-method r"""A `ConvexFunction` representing a total variation regularization term. - For a given input :math:`x`, computes :math:`\lambda \left\| Dx \right\|_1`, - where :math:`\lambda` is a scaling factor and :math:`D` is the finite + For a given input $x$, computes $\lambda \left\| Dx \right\|_1$, + where $\lambda$ is a scaling factor and $D$ is the finite difference operator. Args: @@ -722,8 +722,8 @@ def __init__(self, class ConvexFunctionL1Wavelet(ConvexFunctionLinearOperatorComposition): # pylint: disable=abstract-method r"""A `ConvexFunction` representing an L1 wavelet regularization term. - For a given input :math:`x`, computes :math:`\lambda \left\| Dx \right\|_1`, - where :math:`\lambda` is a scaling factor and :math:`D` is a wavelet + For a given input $x$, computes $\lambda \left\| Dx \right\|_1$, + where $\lambda$ is a scaling factor and $D$ is a wavelet decomposition operator (see `tfmri.linalg.LinearOperatorWavelet`). Args: @@ -776,7 +776,7 @@ def _shape_tensor(self): class ConvexFunctionQuadratic(ConvexFunction): # pylint: disable=abstract-method r"""A `ConvexFunction` representing a generic quadratic function. - Represents :math:`f(x) = \frac{1}{2} x^{T} A x + b^{T} x + c`. + Represents $f(x) = \frac{1}{2} x^{T} A x + b^{T} x + c$. Args: quadratic_coefficient: A `tf.Tensor` or a `tf.linalg.LinearOperator` @@ -903,19 +903,19 @@ def constant_coefficient(self): class ConvexFunctionLeastSquares(ConvexFunctionQuadratic): # pylint: disable=abstract-method r"""A `ConvexFunction` representing a least squares function. - Represents :math:`f(x) = \frac{1}{2} {\left \| A x - b \right \|}_{2}^{2}`. + Represents $f(x) = \frac{1}{2} {\left \| A x - b \right \|}_{2}^{2}$. Minimizing `f(x)` is equivalent to finding a solution to the linear system - :math:`Ax - b`. + $Ax - b$. Args: operator: A `tf.Tensor` or a `tfmri.linalg.LinearOperator` representing a - matrix :math:`A` with shape `[..., m, n]`. The linear system operator. + matrix $A$ with shape `[..., m, n]`. The linear system operator. rhs: A `Tensor` representing a vector `b` with shape `[..., m]`. The right-hand side of the linear system. gram_operator: A `tf.Tensor` or a `tfmri.linalg.LinearOperator` representing the Gram matrix of `operator`. This may be used to provide a specialized - implementation of the Gram matrix :math:`A^H A`. Defaults to `None`, in + implementation of the Gram matrix $A^H A$. Defaults to `None`, in which case a naive implementation of the Gram matrix is derived from `operator`. scale: A `float`. A scaling factor. Defaults to 1.0. diff --git a/tensorflow_mri/python/ops/math_ops.py b/tensorflow_mri/python/ops/math_ops.py index 28dfe95f..35bf3ba2 100644 --- a/tensorflow_mri/python/ops/math_ops.py +++ b/tensorflow_mri/python/ops/math_ops.py @@ -253,7 +253,7 @@ def block_soft_threshold(x, threshold, name=None): r"""Block soft thresholding operator. In the context of proximal gradient methods, this function is the proximal - operator of :math:`f = {\left\| x \right\|}_{2}` (L2 norm). + operator of $f = {\left\| x \right\|}_{2}$ (L2 norm). Args: x: A `Tensor` of shape `[..., n]`. @@ -280,7 +280,7 @@ def shrinkage(x, threshold, name=None): r"""Shrinkage operator. In the context of proximal gradient methods, this function is the proximal - operator of :math:`f = \frac{1}{2}{\left\| x \right\|}_{2}^{2}`. + operator of $f = \frac{1}{2}{\left\| x \right\|}_{2}^{2}$. Args: x: A `Tensor` of shape `[..., n]`. @@ -302,7 +302,7 @@ def soft_threshold(x, threshold, name=None): r"""Soft thresholding operator. In the context of proximal gradient methods, this function is the proximal - operator of :math:`f = {\left\| x \right\|}_{1}` (L1 norm). + operator of $f = {\left\| x \right\|}_{1}$ (L1 norm). Args: x: A `Tensor` of shape `[..., n]`. @@ -326,8 +326,8 @@ def indicator_box(x, lower_bound=-1.0, upper_bound=1.0, name=None): Returns `0` if `x` is in the box, `inf` otherwise. - The box of radius :math:`r` is defined as the set of points of - :math:`{R}^{n}` whose components are within the range :math:`[l, u]`. + The box of radius $r$ is defined as the set of points of + ${R}^{n}$ whose components are within the range $[l, u]$. .. math:: \mathcal{C} = \left\{x \in \mathbb{R}^{n} : l \leq x_i \leq u, \forall i = 1, \dots, n \right\} @@ -378,13 +378,13 @@ def indicator_simplex(x, radius=1.0, name=None): Returns `0` if `x` is in the simplex, `inf` otherwise. - The simplex of radius :math:`r` is defined as the set of points of - :math:`\mathbb{R}^{n}` whose elements are nonnegative and sum up to `r`. + The simplex of radius $r$ is defined as the set of points of + $\mathbb{R}^{n}$ whose elements are nonnegative and sum up to `r`. .. math:: \Delta_r = \left\{x \in \mathbb{R}^{n} : \sum_{i=1}^{n} x_i = r \text{ and } x_i >= 0, \forall i = 1, \dots, n \right\} - If :math:`r` is 1, the simplex is also called the unit simplex, standard + If $r$ is 1, the simplex is also called the unit simplex, standard simplex or probability simplex. Args: @@ -426,14 +426,14 @@ def indicator_ball(x, order=2, radius=1.0, name=None): Returns `0` if `x` is in the Lp ball, `inf` otherwise. - The :math:`L_p` ball of radius :math:`r` is defined as the set of points of - :math:`{R}^{n}` whose distance from the origin, as defined by the :math:`L_p` - norm, is less than or equal to :math:`r`. + The $L_p$ ball of radius $r$ is defined as the set of points of + ${R}^{n}$ whose distance from the origin, as defined by the $L_p$ + norm, is less than or equal to $r$. .. math:: \mathcal{B}_r = \left\{x \in \mathbb{R}^{n} : \left\|x\right\|_{p} \leq r \right\} - If :math:`r` is 1, this ball is also called the unit ball of the + If $r$ is 1, this ball is also called the unit ball of the :math`L_p` norm. Args: diff --git a/tensorflow_mri/python/ops/optimizer_ops.py b/tensorflow_mri/python/ops/optimizer_ops.py index 5430c73c..fcd31bc3 100644 --- a/tensorflow_mri/python/ops/optimizer_ops.py +++ b/tensorflow_mri/python/ops/optimizer_ops.py @@ -191,11 +191,11 @@ def admm_minimize(function_f, name=None): r"""Applies the ADMM algorithm to minimize a separable convex function. - Minimizes :math:`f(x) + g(z)`, subject to :math:`Ax + Bz = c`. + Minimizes $f(x) + g(z)$, subject to $Ax + Bz = c$. - If :math:`A`, :math:`B` and :math:`c` are not provided, the constraint - defaults to :math:`x - z = 0`, in which case the problem is equivalent to - minimizing :math:`f(x) + g(x)`. + If $A$, $B$ and $c$ are not provided, the constraint + defaults to $x - z = 0$, in which case the problem is equivalent to + minimizing $f(x) + g(x)$. Args: function_f: A `tfmri.convex.ConvexFunction` of shape `[..., n]` and real or @@ -218,7 +218,7 @@ def admm_minimize(function_f, of iterations of the ADMM update. linearized: A `boolean`. If `True`, use linearized variant of the ADMM algorithm. Linearized ADMM solves problems of the form - :math:`f(x) + g(Ax)` and only requires evaluation of the proximal operator + $f(x) + g(Ax)$ and only requires evaluation of the proximal operator of `g(x)`. This is useful when the proximal operator of `g(Ax)` cannot be easily evaluated, but the proximal operator of `g(x)` can. Defaults to `False`. @@ -452,8 +452,8 @@ def _get_admm_update_fn(function, operator, prox_kwargs=None): r"""Returns a function for the ADMM update. The returned function evaluates the expression - :math:`{\mathop{\mathrm{argmin}}_x} \left ( f(x) + \frac{\rho}{2} \left\| Ax - v \right\|_2^2 \right )` - for a given input :math:`v` and penalty parameter :math:`\rho`. + ${\mathop{\mathrm{argmin}}_x} \left ( f(x) + \frac{\rho}{2} \left\| Ax - v \right\|_2^2 \right )$ + for a given input $v$ and penalty parameter $\rho$. This function will raise an error if the above expression cannot be easily evaluated for the specified convex function and linear operator. diff --git a/tensorflow_mri/python/ops/recon_ops.py b/tensorflow_mri/python/ops/recon_ops.py index 0f4c3fdd..ca1c7e71 100644 --- a/tensorflow_mri/python/ops/recon_ops.py +++ b/tensorflow_mri/python/ops/recon_ops.py @@ -63,8 +63,8 @@ def reconstruct_lstsq(kspace, .. math:: \hat{x} = {\mathop{\mathrm{argmin}}_x} \left (\left\| Ax - y \right\|_2^2 + g(x) \right ) - where :math:`A` is the MRI `LinearOperator`, :math:`x` is the solution, `y` is - the measured *k*-space data, and :math:`g(x)` is an optional `ConvexFunction` + where $A$ is the MRI `LinearOperator`, $x$ is the solution, `y` is + the measured *k*-space data, and $g(x)$ is an optional `ConvexFunction` used for regularization. This operator supports Cartesian and non-Cartesian *k*-space data. @@ -140,7 +140,7 @@ def reconstruct_lstsq(kspace, return_optimizer_state: A `boolean`. If `True`, returns the optimizer state along with the reconstructed image. toeplitz_nufft: A `boolean`. If `True`, uses the Toeplitz approach [5] - to compute :math:`F^H F x`, where :math:`F` is the non-uniform Fourier + to compute $F^H F x$, where $F$ is the non-uniform Fourier operator. If `False`, the same operation is performed using the standard NUFFT operation. The Toeplitz approach might be faster than the direct approach but is slightly less accurate. This argument is only relevant From 8b9fcc7b13f45aa5f34ed87e05f3b4a7f2c64116 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 7 Sep 2022 11:50:13 +0100 Subject: [PATCH 087/101] Updated copyright strings --- setup.py | 2 +- tensorflow_mri/__about__.py | 4 ++-- tensorflow_mri/cc/kernels/traj_kernels.cc | 8 ++++---- tensorflow_mri/cc/ops/traj_ops.cc | 2 +- tensorflow_mri/cc/third_party/fftw/fftw.h | 2 +- tensorflow_mri/python/__init__.py | 2 +- tensorflow_mri/python/activations/__init__.py | 2 +- tensorflow_mri/python/activations/complex_activations.py | 2 +- .../python/activations/complex_activations_test.py | 2 +- tensorflow_mri/python/callbacks/__init__.py | 2 +- tensorflow_mri/python/callbacks/tensorboard_callbacks.py | 2 +- .../python/callbacks/tensorboard_callbacks_test.py | 2 +- tensorflow_mri/python/coils/coil_compression_test.py | 2 +- tensorflow_mri/python/experimental/__init__.py | 2 +- tensorflow_mri/python/experimental/layers.py | 2 +- tensorflow_mri/python/initializers/__init__.py | 2 +- tensorflow_mri/python/initializers/initializers.py | 2 +- tensorflow_mri/python/initializers/initializers_test.py | 2 +- tensorflow_mri/python/io/__init__.py | 2 +- tensorflow_mri/python/io/image_io.py | 2 +- tensorflow_mri/python/io/image_io_test.py | 2 +- tensorflow_mri/python/io/twix_io.py | 2 +- tensorflow_mri/python/io/twix_io_test.py | 2 +- tensorflow_mri/python/layers/convolutional.py | 2 +- tensorflow_mri/python/layers/convolutional_test.py | 2 +- tensorflow_mri/python/layers/data_consistency.py | 2 +- tensorflow_mri/python/layers/padding.py | 2 +- tensorflow_mri/python/layers/pooling.py | 2 +- tensorflow_mri/python/layers/pooling_test.py | 2 +- tensorflow_mri/python/layers/preproc_layers.py | 2 +- tensorflow_mri/python/layers/preproc_layers_test.py | 2 +- tensorflow_mri/python/layers/reshaping.py | 2 +- tensorflow_mri/python/layers/reshaping_test.py | 2 +- tensorflow_mri/python/layers/signal_layers.py | 2 +- tensorflow_mri/python/layers/signal_layers_test.py | 2 +- tensorflow_mri/python/linalg/__init__.py | 2 +- tensorflow_mri/python/linalg/conjugate_gradient.py | 2 +- tensorflow_mri/python/linalg/conjugate_gradient_test.py | 2 +- tensorflow_mri/python/linalg/linear_operator.py | 2 +- tensorflow_mri/python/linalg/linear_operator_addition.py | 2 +- .../python/linalg/linear_operator_addition_test.py | 2 +- tensorflow_mri/python/linalg/linear_operator_adjoint.py | 2 +- .../python/linalg/linear_operator_adjoint_test.py | 2 +- .../python/linalg/linear_operator_composition.py | 2 +- .../python/linalg/linear_operator_composition_test.py | 2 +- tensorflow_mri/python/linalg/linear_operator_diag.py | 2 +- tensorflow_mri/python/linalg/linear_operator_diag_test.py | 2 +- .../python/linalg/linear_operator_finite_difference.py | 2 +- .../linalg/linear_operator_finite_difference_test.py | 2 +- .../python/linalg/linear_operator_gram_matrix.py | 2 +- .../python/linalg/linear_operator_gram_matrix_test.py | 2 +- tensorflow_mri/python/linalg/linear_operator_identity.py | 2 +- tensorflow_mri/python/linalg/linear_operator_mri_test.py | 2 +- tensorflow_mri/python/linalg/linear_operator_nufft.py | 2 +- .../python/linalg/linear_operator_nufft_test.py | 2 +- .../python/linalg/linear_operator_scaled_identity_test.py | 2 +- tensorflow_mri/python/linalg/linear_operator_test.py | 2 +- tensorflow_mri/python/linalg/linear_operator_wavelet.py | 2 +- .../python/linalg/linear_operator_wavelet_test.py | 2 +- tensorflow_mri/python/losses/__init__.py | 2 +- tensorflow_mri/python/losses/confusion_losses.py | 2 +- tensorflow_mri/python/losses/confusion_losses_test.py | 2 +- tensorflow_mri/python/losses/iqa_losses.py | 2 +- tensorflow_mri/python/losses/iqa_losses_test.py | 2 +- tensorflow_mri/python/metrics/__init__.py | 2 +- tensorflow_mri/python/metrics/confusion_metrics.py | 2 +- tensorflow_mri/python/metrics/confusion_metrics_test.py | 2 +- tensorflow_mri/python/metrics/iqa_metrics.py | 2 +- tensorflow_mri/python/metrics/iqa_metrics_test.py | 2 +- tensorflow_mri/python/models/__init__.py | 2 +- tensorflow_mri/python/models/conv_blocks.py | 2 +- tensorflow_mri/python/models/conv_blocks_test.py | 2 +- tensorflow_mri/python/models/conv_endec_test.py | 2 +- tensorflow_mri/python/ops/__init__.py | 2 +- tensorflow_mri/python/ops/array_ops.py | 2 +- tensorflow_mri/python/ops/array_ops_test.py | 2 +- tensorflow_mri/python/ops/convex_ops.py | 2 +- tensorflow_mri/python/ops/convex_ops_test.py | 2 +- tensorflow_mri/python/ops/fft_ops.py | 2 +- tensorflow_mri/python/ops/fft_ops_test.py | 2 +- tensorflow_mri/python/ops/image_ops.py | 2 +- tensorflow_mri/python/ops/image_ops_test.py | 2 +- tensorflow_mri/python/ops/math_ops.py | 2 +- tensorflow_mri/python/ops/math_ops_test.py | 2 +- tensorflow_mri/python/ops/optimizer_ops.py | 2 +- tensorflow_mri/python/ops/optimizer_ops_test.py | 2 +- tensorflow_mri/python/ops/recon_ops.py | 2 +- tensorflow_mri/python/ops/recon_ops_test.py | 2 +- tensorflow_mri/python/ops/signal_ops.py | 2 +- tensorflow_mri/python/ops/signal_ops_test.py | 2 +- tensorflow_mri/python/ops/traj_ops.py | 2 +- tensorflow_mri/python/ops/traj_ops_test.py | 2 +- tensorflow_mri/python/ops/wavelet_ops.py | 2 +- tensorflow_mri/python/ops/wavelet_ops_test.py | 2 +- tensorflow_mri/python/summary/__init__.py | 2 +- tensorflow_mri/python/summary/image_summary.py | 2 +- tensorflow_mri/python/util/__init__.py | 2 +- tensorflow_mri/python/util/api_util.py | 2 +- tensorflow_mri/python/util/check_util.py | 2 +- tensorflow_mri/python/util/check_util_test.py | 2 +- tensorflow_mri/python/util/data_util.py | 2 +- tensorflow_mri/python/util/deprecation.py | 2 +- tensorflow_mri/python/util/import_util.py | 2 +- tensorflow_mri/python/util/import_util_test.py | 2 +- tensorflow_mri/python/util/io_util.py | 2 +- tensorflow_mri/python/util/keras_util.py | 2 +- tensorflow_mri/python/util/keras_util_test.py | 2 +- tensorflow_mri/python/util/layer_util.py | 2 +- tensorflow_mri/python/util/linalg_ext.py | 2 +- tensorflow_mri/python/util/linalg_ext_test.py | 2 +- tensorflow_mri/python/util/math_util.py | 2 +- tensorflow_mri/python/util/model_util.py | 2 +- tensorflow_mri/python/util/nest_util.py | 2 +- tensorflow_mri/python/util/plot_util.py | 2 +- tensorflow_mri/python/util/plot_util_test.py | 2 +- tensorflow_mri/python/util/prefer_static.py | 2 +- tensorflow_mri/python/util/sys_util.py | 2 +- tensorflow_mri/python/util/tensor_util.py | 2 +- tensorflow_mri/python/util/test_util.py | 2 +- tensorflow_mri/python/util/types_util.py | 2 +- tools/docs/conf.py | 2 +- tools/docs/create_documents.py | 2 +- tools/docs/create_templates.py | 2 +- tools/docs/tutorials/recon/cg_sense.ipynb | 2 +- 124 files changed, 128 insertions(+), 128 deletions(-) diff --git a/setup.py b/setup.py index 28241a5d..fe83437b 100755 --- a/setup.py +++ b/setup.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/__about__.py b/tensorflow_mri/__about__.py index 10384209..8670dc3d 100644 --- a/tensorflow_mri/__about__.py +++ b/tensorflow_mri/__about__.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. @@ -35,4 +35,4 @@ __email__ = "javier.montalt@outlook.com" __license__ = "Apache 2.0" -__copyright__ = "2021 University College London" +__copyright__ = "2021 The TensorFlow MRI Authors" diff --git a/tensorflow_mri/cc/kernels/traj_kernels.cc b/tensorflow_mri/cc/kernels/traj_kernels.cc index 5364fab3..339feda5 100644 --- a/tensorflow_mri/cc/kernels/traj_kernels.cc +++ b/tensorflow_mri/cc/kernels/traj_kernels.cc @@ -1,4 +1,4 @@ -/*Copyright 2021 University College London. All Rights Reserved. +/*Copyright 2021 The TensorFlow MRI 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. @@ -25,7 +25,7 @@ class SpiralWaveformOp : public OpKernel { public: explicit SpiralWaveformOp(OpKernelConstruction* ctx) : OpKernel(ctx) { - + string vd_type_str; OP_REQUIRES_OK(ctx, ctx->GetAttr("base_resolution", &base_resolution_)); @@ -64,7 +64,7 @@ class SpiralWaveformOp : public OpKernel { } void Compute(OpKernelContext* ctx) override { - + // Create a buffer tensor. TensorShape temp_waveform_shape({SWF_MAX_WAVEFORM_SIZE, 2}); Tensor temp_waveform; @@ -94,7 +94,7 @@ class SpiralWaveformOp : public OpKernel { ctx, result == 0, errors::Internal( "failed during `calculate_spiral_trajectory`")); - + Tensor waveform = temp_waveform.Slice(0, waveform_length); ctx->set_output(0, waveform); } diff --git a/tensorflow_mri/cc/ops/traj_ops.cc b/tensorflow_mri/cc/ops/traj_ops.cc index c39852d1..76a916bc 100644 --- a/tensorflow_mri/cc/ops/traj_ops.cc +++ b/tensorflow_mri/cc/ops/traj_ops.cc @@ -1,4 +1,4 @@ -/*Copyright 2021 University College London. All Rights Reserved. +/*Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/cc/third_party/fftw/fftw.h b/tensorflow_mri/cc/third_party/fftw/fftw.h index 77332191..af567379 100644 --- a/tensorflow_mri/cc/third_party/fftw/fftw.h +++ b/tensorflow_mri/cc/third_party/fftw/fftw.h @@ -1,4 +1,4 @@ -/* Copyright 2022 University College London. All Rights Reserved. +/* Copyright 2022 The TensorFlow MRI 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 diff --git a/tensorflow_mri/python/__init__.py b/tensorflow_mri/python/__init__.py index 475dc930..8bc1069e 100644 --- a/tensorflow_mri/python/__init__.py +++ b/tensorflow_mri/python/__init__.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/activations/__init__.py b/tensorflow_mri/python/activations/__init__.py index 398a8f60..7a69d45e 100644 --- a/tensorflow_mri/python/activations/__init__.py +++ b/tensorflow_mri/python/activations/__init__.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/activations/complex_activations.py b/tensorflow_mri/python/activations/complex_activations.py index 42ad50a0..424ed9a9 100644 --- a/tensorflow_mri/python/activations/complex_activations.py +++ b/tensorflow_mri/python/activations/complex_activations.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/activations/complex_activations_test.py b/tensorflow_mri/python/activations/complex_activations_test.py index bc7d6c6a..0cfac408 100644 --- a/tensorflow_mri/python/activations/complex_activations_test.py +++ b/tensorflow_mri/python/activations/complex_activations_test.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/callbacks/__init__.py b/tensorflow_mri/python/callbacks/__init__.py index d77bc844..16291601 100644 --- a/tensorflow_mri/python/callbacks/__init__.py +++ b/tensorflow_mri/python/callbacks/__init__.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/callbacks/tensorboard_callbacks.py b/tensorflow_mri/python/callbacks/tensorboard_callbacks.py index 7b641957..a006fbb6 100644 --- a/tensorflow_mri/python/callbacks/tensorboard_callbacks.py +++ b/tensorflow_mri/python/callbacks/tensorboard_callbacks.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/callbacks/tensorboard_callbacks_test.py b/tensorflow_mri/python/callbacks/tensorboard_callbacks_test.py index 98c7aa43..f9cea818 100644 --- a/tensorflow_mri/python/callbacks/tensorboard_callbacks_test.py +++ b/tensorflow_mri/python/callbacks/tensorboard_callbacks_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/coils/coil_compression_test.py b/tensorflow_mri/python/coils/coil_compression_test.py index 972bc721..9a2dd256 100644 --- a/tensorflow_mri/python/coils/coil_compression_test.py +++ b/tensorflow_mri/python/coils/coil_compression_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/experimental/__init__.py b/tensorflow_mri/python/experimental/__init__.py index 9ed687ab..c49d30fa 100644 --- a/tensorflow_mri/python/experimental/__init__.py +++ b/tensorflow_mri/python/experimental/__init__.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/experimental/layers.py b/tensorflow_mri/python/experimental/layers.py index e0943fd9..368ef2f3 100644 --- a/tensorflow_mri/python/experimental/layers.py +++ b/tensorflow_mri/python/experimental/layers.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/initializers/__init__.py b/tensorflow_mri/python/initializers/__init__.py index 057794ec..599b4b60 100644 --- a/tensorflow_mri/python/initializers/__init__.py +++ b/tensorflow_mri/python/initializers/__init__.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/initializers/initializers.py b/tensorflow_mri/python/initializers/initializers.py index e8216f3c..0f18f2df 100644 --- a/tensorflow_mri/python/initializers/initializers.py +++ b/tensorflow_mri/python/initializers/initializers.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/initializers/initializers_test.py b/tensorflow_mri/python/initializers/initializers_test.py index 511c7280..cefe1a8c 100644 --- a/tensorflow_mri/python/initializers/initializers_test.py +++ b/tensorflow_mri/python/initializers/initializers_test.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/io/__init__.py b/tensorflow_mri/python/io/__init__.py index 44032b6c..3b19357b 100644 --- a/tensorflow_mri/python/io/__init__.py +++ b/tensorflow_mri/python/io/__init__.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/io/image_io.py b/tensorflow_mri/python/io/image_io.py index 885214e6..eff8451c 100644 --- a/tensorflow_mri/python/io/image_io.py +++ b/tensorflow_mri/python/io/image_io.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/io/image_io_test.py b/tensorflow_mri/python/io/image_io_test.py index a4d16783..f8c62568 100644 --- a/tensorflow_mri/python/io/image_io_test.py +++ b/tensorflow_mri/python/io/image_io_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/io/twix_io.py b/tensorflow_mri/python/io/twix_io.py index f8eeacf6..553b4498 100644 --- a/tensorflow_mri/python/io/twix_io.py +++ b/tensorflow_mri/python/io/twix_io.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/io/twix_io_test.py b/tensorflow_mri/python/io/twix_io_test.py index a3e850db..4adb9270 100644 --- a/tensorflow_mri/python/io/twix_io_test.py +++ b/tensorflow_mri/python/io/twix_io_test.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/layers/convolutional.py b/tensorflow_mri/python/layers/convolutional.py index 2121ca0b..207ab35f 100644 --- a/tensorflow_mri/python/layers/convolutional.py +++ b/tensorflow_mri/python/layers/convolutional.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/layers/convolutional_test.py b/tensorflow_mri/python/layers/convolutional_test.py index ed0c1e79..091c7976 100644 --- a/tensorflow_mri/python/layers/convolutional_test.py +++ b/tensorflow_mri/python/layers/convolutional_test.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/layers/data_consistency.py b/tensorflow_mri/python/layers/data_consistency.py index 62d0224f..965f115d 100644 --- a/tensorflow_mri/python/layers/data_consistency.py +++ b/tensorflow_mri/python/layers/data_consistency.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/layers/padding.py b/tensorflow_mri/python/layers/padding.py index 8fe5aebc..a5cce20b 100644 --- a/tensorflow_mri/python/layers/padding.py +++ b/tensorflow_mri/python/layers/padding.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/layers/pooling.py b/tensorflow_mri/python/layers/pooling.py index e876953b..83b9b5e1 100644 --- a/tensorflow_mri/python/layers/pooling.py +++ b/tensorflow_mri/python/layers/pooling.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/layers/pooling_test.py b/tensorflow_mri/python/layers/pooling_test.py index 2ddf4001..590c6070 100644 --- a/tensorflow_mri/python/layers/pooling_test.py +++ b/tensorflow_mri/python/layers/pooling_test.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/layers/preproc_layers.py b/tensorflow_mri/python/layers/preproc_layers.py index de96d79b..6be42b67 100644 --- a/tensorflow_mri/python/layers/preproc_layers.py +++ b/tensorflow_mri/python/layers/preproc_layers.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/layers/preproc_layers_test.py b/tensorflow_mri/python/layers/preproc_layers_test.py index e90ce215..1d89725d 100644 --- a/tensorflow_mri/python/layers/preproc_layers_test.py +++ b/tensorflow_mri/python/layers/preproc_layers_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/layers/reshaping.py b/tensorflow_mri/python/layers/reshaping.py index 99452dd1..2548fa48 100644 --- a/tensorflow_mri/python/layers/reshaping.py +++ b/tensorflow_mri/python/layers/reshaping.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/layers/reshaping_test.py b/tensorflow_mri/python/layers/reshaping_test.py index 42b188d0..35a7ce75 100644 --- a/tensorflow_mri/python/layers/reshaping_test.py +++ b/tensorflow_mri/python/layers/reshaping_test.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/layers/signal_layers.py b/tensorflow_mri/python/layers/signal_layers.py index 95317912..eba871ca 100644 --- a/tensorflow_mri/python/layers/signal_layers.py +++ b/tensorflow_mri/python/layers/signal_layers.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/layers/signal_layers_test.py b/tensorflow_mri/python/layers/signal_layers_test.py index cf281358..ec59fde7 100644 --- a/tensorflow_mri/python/layers/signal_layers_test.py +++ b/tensorflow_mri/python/layers/signal_layers_test.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/__init__.py b/tensorflow_mri/python/linalg/__init__.py index 81eeafaa..8954c374 100644 --- a/tensorflow_mri/python/linalg/__init__.py +++ b/tensorflow_mri/python/linalg/__init__.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/conjugate_gradient.py b/tensorflow_mri/python/linalg/conjugate_gradient.py index 7917d374..25f2069a 100644 --- a/tensorflow_mri/python/linalg/conjugate_gradient.py +++ b/tensorflow_mri/python/linalg/conjugate_gradient.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/conjugate_gradient_test.py b/tensorflow_mri/python/linalg/conjugate_gradient_test.py index a653ac21..c1604758 100755 --- a/tensorflow_mri/python/linalg/conjugate_gradient_test.py +++ b/tensorflow_mri/python/linalg/conjugate_gradient_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator.py b/tensorflow_mri/python/linalg/linear_operator.py index 7ca2c860..08fc6b92 100644 --- a/tensorflow_mri/python/linalg/linear_operator.py +++ b/tensorflow_mri/python/linalg/linear_operator.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_addition.py b/tensorflow_mri/python/linalg/linear_operator_addition.py index 332799e4..81db6b75 100644 --- a/tensorflow_mri/python/linalg/linear_operator_addition.py +++ b/tensorflow_mri/python/linalg/linear_operator_addition.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_addition_test.py b/tensorflow_mri/python/linalg/linear_operator_addition_test.py index 5eb4ac3d..24dda3c1 100644 --- a/tensorflow_mri/python/linalg/linear_operator_addition_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_addition_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_adjoint.py b/tensorflow_mri/python/linalg/linear_operator_adjoint.py index e5c53928..9ebd6828 100644 --- a/tensorflow_mri/python/linalg/linear_operator_adjoint.py +++ b/tensorflow_mri/python/linalg/linear_operator_adjoint.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_adjoint_test.py b/tensorflow_mri/python/linalg/linear_operator_adjoint_test.py index 529158d7..894aac5e 100644 --- a/tensorflow_mri/python/linalg/linear_operator_adjoint_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_adjoint_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_composition.py b/tensorflow_mri/python/linalg/linear_operator_composition.py index c6d268b9..0659f904 100644 --- a/tensorflow_mri/python/linalg/linear_operator_composition.py +++ b/tensorflow_mri/python/linalg/linear_operator_composition.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_composition_test.py b/tensorflow_mri/python/linalg/linear_operator_composition_test.py index 304fbac1..55d48a34 100644 --- a/tensorflow_mri/python/linalg/linear_operator_composition_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_composition_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_diag.py b/tensorflow_mri/python/linalg/linear_operator_diag.py index 6d8f3295..e89ee47a 100644 --- a/tensorflow_mri/python/linalg/linear_operator_diag.py +++ b/tensorflow_mri/python/linalg/linear_operator_diag.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_diag_test.py b/tensorflow_mri/python/linalg/linear_operator_diag_test.py index d5018221..b46fc955 100644 --- a/tensorflow_mri/python/linalg/linear_operator_diag_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_diag_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_finite_difference.py b/tensorflow_mri/python/linalg/linear_operator_finite_difference.py index b0cda807..66833b67 100644 --- a/tensorflow_mri/python/linalg/linear_operator_finite_difference.py +++ b/tensorflow_mri/python/linalg/linear_operator_finite_difference.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_finite_difference_test.py b/tensorflow_mri/python/linalg/linear_operator_finite_difference_test.py index 730a9cf7..6586b991 100755 --- a/tensorflow_mri/python/linalg/linear_operator_finite_difference_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_finite_difference_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_gram_matrix.py b/tensorflow_mri/python/linalg/linear_operator_gram_matrix.py index 78df3c19..69e01e45 100644 --- a/tensorflow_mri/python/linalg/linear_operator_gram_matrix.py +++ b/tensorflow_mri/python/linalg/linear_operator_gram_matrix.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_gram_matrix_test.py b/tensorflow_mri/python/linalg/linear_operator_gram_matrix_test.py index d03f5ef6..2cbc2c93 100644 --- a/tensorflow_mri/python/linalg/linear_operator_gram_matrix_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_gram_matrix_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_identity.py b/tensorflow_mri/python/linalg/linear_operator_identity.py index 5250e0c7..df136e6b 100644 --- a/tensorflow_mri/python/linalg/linear_operator_identity.py +++ b/tensorflow_mri/python/linalg/linear_operator_identity.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_mri_test.py b/tensorflow_mri/python/linalg/linear_operator_mri_test.py index 0d5d1d76..7cc12a28 100755 --- a/tensorflow_mri/python/linalg/linear_operator_mri_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_mri_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_nufft.py b/tensorflow_mri/python/linalg/linear_operator_nufft.py index 39a1940e..0875eab3 100644 --- a/tensorflow_mri/python/linalg/linear_operator_nufft.py +++ b/tensorflow_mri/python/linalg/linear_operator_nufft.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_nufft_test.py b/tensorflow_mri/python/linalg/linear_operator_nufft_test.py index e74cae39..8f50d9e4 100755 --- a/tensorflow_mri/python/linalg/linear_operator_nufft_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_nufft_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_scaled_identity_test.py b/tensorflow_mri/python/linalg/linear_operator_scaled_identity_test.py index 04955e3b..333f904b 100644 --- a/tensorflow_mri/python/linalg/linear_operator_scaled_identity_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_scaled_identity_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_test.py b/tensorflow_mri/python/linalg/linear_operator_test.py index 8318fca2..6627206a 100644 --- a/tensorflow_mri/python/linalg/linear_operator_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_wavelet.py b/tensorflow_mri/python/linalg/linear_operator_wavelet.py index 1773d075..57d81092 100644 --- a/tensorflow_mri/python/linalg/linear_operator_wavelet.py +++ b/tensorflow_mri/python/linalg/linear_operator_wavelet.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/linalg/linear_operator_wavelet_test.py b/tensorflow_mri/python/linalg/linear_operator_wavelet_test.py index d80a0665..a0ecee87 100755 --- a/tensorflow_mri/python/linalg/linear_operator_wavelet_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_wavelet_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/losses/__init__.py b/tensorflow_mri/python/losses/__init__.py index d8986663..9629f708 100644 --- a/tensorflow_mri/python/losses/__init__.py +++ b/tensorflow_mri/python/losses/__init__.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/losses/confusion_losses.py b/tensorflow_mri/python/losses/confusion_losses.py index 8ecacb4a..6c3a24ac 100644 --- a/tensorflow_mri/python/losses/confusion_losses.py +++ b/tensorflow_mri/python/losses/confusion_losses.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/losses/confusion_losses_test.py b/tensorflow_mri/python/losses/confusion_losses_test.py index 4673df90..4a9fbd51 100755 --- a/tensorflow_mri/python/losses/confusion_losses_test.py +++ b/tensorflow_mri/python/losses/confusion_losses_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/losses/iqa_losses.py b/tensorflow_mri/python/losses/iqa_losses.py index 629d53be..af4a2bf0 100644 --- a/tensorflow_mri/python/losses/iqa_losses.py +++ b/tensorflow_mri/python/losses/iqa_losses.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/losses/iqa_losses_test.py b/tensorflow_mri/python/losses/iqa_losses_test.py index ab2e530e..968a81e0 100755 --- a/tensorflow_mri/python/losses/iqa_losses_test.py +++ b/tensorflow_mri/python/losses/iqa_losses_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/metrics/__init__.py b/tensorflow_mri/python/metrics/__init__.py index c25c648e..896aaed3 100644 --- a/tensorflow_mri/python/metrics/__init__.py +++ b/tensorflow_mri/python/metrics/__init__.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/metrics/confusion_metrics.py b/tensorflow_mri/python/metrics/confusion_metrics.py index d20cf70e..680858d3 100644 --- a/tensorflow_mri/python/metrics/confusion_metrics.py +++ b/tensorflow_mri/python/metrics/confusion_metrics.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI Authors. All Rights Reserved. # Copyright 2019 The TensorFlow Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/tensorflow_mri/python/metrics/confusion_metrics_test.py b/tensorflow_mri/python/metrics/confusion_metrics_test.py index 37fd5972..c5b8dd0b 100644 --- a/tensorflow_mri/python/metrics/confusion_metrics_test.py +++ b/tensorflow_mri/python/metrics/confusion_metrics_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/metrics/iqa_metrics.py b/tensorflow_mri/python/metrics/iqa_metrics.py index 1ed1e72e..6ec4ff5d 100755 --- a/tensorflow_mri/python/metrics/iqa_metrics.py +++ b/tensorflow_mri/python/metrics/iqa_metrics.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/metrics/iqa_metrics_test.py b/tensorflow_mri/python/metrics/iqa_metrics_test.py index 85175dc8..9965d110 100755 --- a/tensorflow_mri/python/metrics/iqa_metrics_test.py +++ b/tensorflow_mri/python/metrics/iqa_metrics_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/models/__init__.py b/tensorflow_mri/python/models/__init__.py index 3134681d..71f191c5 100644 --- a/tensorflow_mri/python/models/__init__.py +++ b/tensorflow_mri/python/models/__init__.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/models/conv_blocks.py b/tensorflow_mri/python/models/conv_blocks.py index d5c1a32c..0744fcb0 100644 --- a/tensorflow_mri/python/models/conv_blocks.py +++ b/tensorflow_mri/python/models/conv_blocks.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/models/conv_blocks_test.py b/tensorflow_mri/python/models/conv_blocks_test.py index 77ae6564..b97b2b26 100644 --- a/tensorflow_mri/python/models/conv_blocks_test.py +++ b/tensorflow_mri/python/models/conv_blocks_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/models/conv_endec_test.py b/tensorflow_mri/python/models/conv_endec_test.py index 905eee56..069c5bfa 100644 --- a/tensorflow_mri/python/models/conv_endec_test.py +++ b/tensorflow_mri/python/models/conv_endec_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/__init__.py b/tensorflow_mri/python/ops/__init__.py index 461a64f6..7adf607e 100644 --- a/tensorflow_mri/python/ops/__init__.py +++ b/tensorflow_mri/python/ops/__init__.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/array_ops.py b/tensorflow_mri/python/ops/array_ops.py index c0d2f28e..8efeb812 100644 --- a/tensorflow_mri/python/ops/array_ops.py +++ b/tensorflow_mri/python/ops/array_ops.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/array_ops_test.py b/tensorflow_mri/python/ops/array_ops_test.py index dc4d6034..56588e6a 100755 --- a/tensorflow_mri/python/ops/array_ops_test.py +++ b/tensorflow_mri/python/ops/array_ops_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/convex_ops.py b/tensorflow_mri/python/ops/convex_ops.py index b9dd61fc..02c1517f 100644 --- a/tensorflow_mri/python/ops/convex_ops.py +++ b/tensorflow_mri/python/ops/convex_ops.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/convex_ops_test.py b/tensorflow_mri/python/ops/convex_ops_test.py index dbdb99df..9e1f9c3a 100644 --- a/tensorflow_mri/python/ops/convex_ops_test.py +++ b/tensorflow_mri/python/ops/convex_ops_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/fft_ops.py b/tensorflow_mri/python/ops/fft_ops.py index 61bec979..ebc46d87 100644 --- a/tensorflow_mri/python/ops/fft_ops.py +++ b/tensorflow_mri/python/ops/fft_ops.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/fft_ops_test.py b/tensorflow_mri/python/ops/fft_ops_test.py index 45e7b020..2b024036 100644 --- a/tensorflow_mri/python/ops/fft_ops_test.py +++ b/tensorflow_mri/python/ops/fft_ops_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/image_ops.py b/tensorflow_mri/python/ops/image_ops.py index 5c41851f..9e3a0324 100644 --- a/tensorflow_mri/python/ops/image_ops.py +++ b/tensorflow_mri/python/ops/image_ops.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI Authors. All Rights Reserved. # Copyright 2015 The TensorFlow Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/tensorflow_mri/python/ops/image_ops_test.py b/tensorflow_mri/python/ops/image_ops_test.py index 1d5ccc25..883ca081 100644 --- a/tensorflow_mri/python/ops/image_ops_test.py +++ b/tensorflow_mri/python/ops/image_ops_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/math_ops.py b/tensorflow_mri/python/ops/math_ops.py index 35bf3ba2..db6235ed 100644 --- a/tensorflow_mri/python/ops/math_ops.py +++ b/tensorflow_mri/python/ops/math_ops.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/math_ops_test.py b/tensorflow_mri/python/ops/math_ops_test.py index ffcf6aa7..421350e8 100644 --- a/tensorflow_mri/python/ops/math_ops_test.py +++ b/tensorflow_mri/python/ops/math_ops_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/optimizer_ops.py b/tensorflow_mri/python/ops/optimizer_ops.py index fcd31bc3..8b1fc3a6 100644 --- a/tensorflow_mri/python/ops/optimizer_ops.py +++ b/tensorflow_mri/python/ops/optimizer_ops.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/optimizer_ops_test.py b/tensorflow_mri/python/ops/optimizer_ops_test.py index 859be9e7..af04890a 100755 --- a/tensorflow_mri/python/ops/optimizer_ops_test.py +++ b/tensorflow_mri/python/ops/optimizer_ops_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/recon_ops.py b/tensorflow_mri/python/ops/recon_ops.py index ca1c7e71..9c9c66d8 100644 --- a/tensorflow_mri/python/ops/recon_ops.py +++ b/tensorflow_mri/python/ops/recon_ops.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/recon_ops_test.py b/tensorflow_mri/python/ops/recon_ops_test.py index 8533bcf9..6fb182f8 100755 --- a/tensorflow_mri/python/ops/recon_ops_test.py +++ b/tensorflow_mri/python/ops/recon_ops_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/signal_ops.py b/tensorflow_mri/python/ops/signal_ops.py index 694ee555..dc109c0a 100644 --- a/tensorflow_mri/python/ops/signal_ops.py +++ b/tensorflow_mri/python/ops/signal_ops.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/signal_ops_test.py b/tensorflow_mri/python/ops/signal_ops_test.py index b609306d..8fa12929 100755 --- a/tensorflow_mri/python/ops/signal_ops_test.py +++ b/tensorflow_mri/python/ops/signal_ops_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/traj_ops.py b/tensorflow_mri/python/ops/traj_ops.py index 511d6c3e..591b2593 100755 --- a/tensorflow_mri/python/ops/traj_ops.py +++ b/tensorflow_mri/python/ops/traj_ops.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/traj_ops_test.py b/tensorflow_mri/python/ops/traj_ops_test.py index ad0cb748..476f38f2 100755 --- a/tensorflow_mri/python/ops/traj_ops_test.py +++ b/tensorflow_mri/python/ops/traj_ops_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/wavelet_ops.py b/tensorflow_mri/python/ops/wavelet_ops.py index 14e0db4f..dd41d318 100644 --- a/tensorflow_mri/python/ops/wavelet_ops.py +++ b/tensorflow_mri/python/ops/wavelet_ops.py @@ -1,5 +1,5 @@ # ============================================================================== -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/ops/wavelet_ops_test.py b/tensorflow_mri/python/ops/wavelet_ops_test.py index 08d5eaf1..f222afd8 100644 --- a/tensorflow_mri/python/ops/wavelet_ops_test.py +++ b/tensorflow_mri/python/ops/wavelet_ops_test.py @@ -1,5 +1,5 @@ # ============================================================================== -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/summary/__init__.py b/tensorflow_mri/python/summary/__init__.py index d7030a38..5066ae9f 100644 --- a/tensorflow_mri/python/summary/__init__.py +++ b/tensorflow_mri/python/summary/__init__.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/summary/image_summary.py b/tensorflow_mri/python/summary/image_summary.py index faad713a..3f391209 100644 --- a/tensorflow_mri/python/summary/image_summary.py +++ b/tensorflow_mri/python/summary/image_summary.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/__init__.py b/tensorflow_mri/python/util/__init__.py index 4586b2dd..fe408a42 100644 --- a/tensorflow_mri/python/util/__init__.py +++ b/tensorflow_mri/python/util/__init__.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/api_util.py b/tensorflow_mri/python/util/api_util.py index ad3fc49b..f382feb3 100644 --- a/tensorflow_mri/python/util/api_util.py +++ b/tensorflow_mri/python/util/api_util.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/check_util.py b/tensorflow_mri/python/util/check_util.py index 0885f3db..3c861dd7 100755 --- a/tensorflow_mri/python/util/check_util.py +++ b/tensorflow_mri/python/util/check_util.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/check_util_test.py b/tensorflow_mri/python/util/check_util_test.py index 6b410005..3feda02d 100644 --- a/tensorflow_mri/python/util/check_util_test.py +++ b/tensorflow_mri/python/util/check_util_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/data_util.py b/tensorflow_mri/python/util/data_util.py index b639a372..d3ececeb 100644 --- a/tensorflow_mri/python/util/data_util.py +++ b/tensorflow_mri/python/util/data_util.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/deprecation.py b/tensorflow_mri/python/util/deprecation.py index 7003bb12..2adb0573 100755 --- a/tensorflow_mri/python/util/deprecation.py +++ b/tensorflow_mri/python/util/deprecation.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/import_util.py b/tensorflow_mri/python/util/import_util.py index 16b2d2a1..ef0fd82d 100644 --- a/tensorflow_mri/python/util/import_util.py +++ b/tensorflow_mri/python/util/import_util.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/import_util_test.py b/tensorflow_mri/python/util/import_util_test.py index 53e5419a..30e9d3b0 100644 --- a/tensorflow_mri/python/util/import_util_test.py +++ b/tensorflow_mri/python/util/import_util_test.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/io_util.py b/tensorflow_mri/python/util/io_util.py index 953f4365..4391014d 100755 --- a/tensorflow_mri/python/util/io_util.py +++ b/tensorflow_mri/python/util/io_util.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/keras_util.py b/tensorflow_mri/python/util/keras_util.py index eafacf8a..59a4f4ef 100644 --- a/tensorflow_mri/python/util/keras_util.py +++ b/tensorflow_mri/python/util/keras_util.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/keras_util_test.py b/tensorflow_mri/python/util/keras_util_test.py index 5d0da724..209adb8c 100644 --- a/tensorflow_mri/python/util/keras_util_test.py +++ b/tensorflow_mri/python/util/keras_util_test.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/layer_util.py b/tensorflow_mri/python/util/layer_util.py index 0df7c1da..8b0d4992 100644 --- a/tensorflow_mri/python/util/layer_util.py +++ b/tensorflow_mri/python/util/layer_util.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/linalg_ext.py b/tensorflow_mri/python/util/linalg_ext.py index a5aca2ad..9798c4bc 100644 --- a/tensorflow_mri/python/util/linalg_ext.py +++ b/tensorflow_mri/python/util/linalg_ext.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/linalg_ext_test.py b/tensorflow_mri/python/util/linalg_ext_test.py index f8135f63..0732e5c9 100644 --- a/tensorflow_mri/python/util/linalg_ext_test.py +++ b/tensorflow_mri/python/util/linalg_ext_test.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/math_util.py b/tensorflow_mri/python/util/math_util.py index 367f9619..3dfc07e6 100644 --- a/tensorflow_mri/python/util/math_util.py +++ b/tensorflow_mri/python/util/math_util.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/model_util.py b/tensorflow_mri/python/util/model_util.py index 2114dfc2..01becf9c 100644 --- a/tensorflow_mri/python/util/model_util.py +++ b/tensorflow_mri/python/util/model_util.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/nest_util.py b/tensorflow_mri/python/util/nest_util.py index e4e86e36..cb56b9e4 100644 --- a/tensorflow_mri/python/util/nest_util.py +++ b/tensorflow_mri/python/util/nest_util.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/plot_util.py b/tensorflow_mri/python/util/plot_util.py index 8cecff66..bae540cf 100644 --- a/tensorflow_mri/python/util/plot_util.py +++ b/tensorflow_mri/python/util/plot_util.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/plot_util_test.py b/tensorflow_mri/python/util/plot_util_test.py index aa5ec18c..ed3ed695 100644 --- a/tensorflow_mri/python/util/plot_util_test.py +++ b/tensorflow_mri/python/util/plot_util_test.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/prefer_static.py b/tensorflow_mri/python/util/prefer_static.py index b79a619d..48dc4be9 100644 --- a/tensorflow_mri/python/util/prefer_static.py +++ b/tensorflow_mri/python/util/prefer_static.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/sys_util.py b/tensorflow_mri/python/util/sys_util.py index b2651d14..6a2750f8 100644 --- a/tensorflow_mri/python/util/sys_util.py +++ b/tensorflow_mri/python/util/sys_util.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/tensor_util.py b/tensorflow_mri/python/util/tensor_util.py index 0d2dfbf7..dfeec070 100644 --- a/tensorflow_mri/python/util/tensor_util.py +++ b/tensorflow_mri/python/util/tensor_util.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/test_util.py b/tensorflow_mri/python/util/test_util.py index 88b982ed..8a11a8b6 100644 --- a/tensorflow_mri/python/util/test_util.py +++ b/tensorflow_mri/python/util/test_util.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tensorflow_mri/python/util/types_util.py b/tensorflow_mri/python/util/types_util.py index 113237a3..8ca424f3 100644 --- a/tensorflow_mri/python/util/types_util.py +++ b/tensorflow_mri/python/util/types_util.py @@ -1,4 +1,4 @@ -# Copyright 2021 University College London. All Rights Reserved. +# Copyright 2021 The TensorFlow MRI 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. diff --git a/tools/docs/conf.py b/tools/docs/conf.py index c564fd45..1e2aa5f4 100644 --- a/tools/docs/conf.py +++ b/tools/docs/conf.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tools/docs/create_documents.py b/tools/docs/create_documents.py index 01335628..f04026cb 100644 --- a/tools/docs/create_documents.py +++ b/tools/docs/create_documents.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tools/docs/create_templates.py b/tools/docs/create_templates.py index b9ead5df..f8217928 100644 --- a/tools/docs/create_templates.py +++ b/tools/docs/create_templates.py @@ -1,4 +1,4 @@ -# Copyright 2022 University College London. All Rights Reserved. +# Copyright 2022 The TensorFlow MRI 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. diff --git a/tools/docs/tutorials/recon/cg_sense.ipynb b/tools/docs/tutorials/recon/cg_sense.ipynb index 32242d78..874c497c 100644 --- a/tools/docs/tutorials/recon/cg_sense.ipynb +++ b/tools/docs/tutorials/recon/cg_sense.ipynb @@ -1001,7 +1001,7 @@ "metadata": {}, "outputs": [], "source": [ - "# Copyright 2022 University College London. All rights reserved.\n", + "# Copyright 2022 The TensorFlow MRI Authors. All rights reserved.\n", "#\n", "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", "# you may not use this file except in compliance with the License.\n", From 51b40a4d2bfd82b8b69ab1aeadd07c9aa4b7eeb0 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 7 Sep 2022 12:36:48 +0100 Subject: [PATCH 088/101] Remove universal coil compression --- .../python/coils/coil_compression.py | 52 ------------------- 1 file changed, 52 deletions(-) diff --git a/tensorflow_mri/python/coils/coil_compression.py b/tensorflow_mri/python/coils/coil_compression.py index 47ce5468..e6e470c1 100644 --- a/tensorflow_mri/python/coils/coil_compression.py +++ b/tensorflow_mri/python/coils/coil_compression.py @@ -279,55 +279,3 @@ def make_coil_compressor(method, **kwargs): if method == 'svd': return CoilCompressorSVD(**kwargs) raise NotImplementedError(f"Method {method} not implemented.") - - -@api_util.export("coils.compress_coils_universal") -def compress_coils_universal( - meas_data, - operator, - calib_data=None, - calib_fn=None, - method='svd', - **kwargs): - # For convenience. - rank = operator.rank - - if calib_data is None: - # Calibration data was not provided. Get calibration data by low-pass - # filtering the input k-space. - calib_data = signal_ops.filter_kspace( - kspace, - trajectory=operator.trajectory, - filter_fn=calib_window, - filter_rank=rank, - separable=True) - - # Reshape to single batch dimension. - coil_axis = -2 if operator.is_non_cartesian else -(rank + 1) - batch_shape_static = calib_data.shape[:coil_axis] - batch_shape = tf.shape(calib_data)[:coil_axis] - calib_shape = tf.shape(calib_data)[coil_axis:] - calib_data = tf.reshape(calib_data, tf.concat([[-1], calib_shape], 0)) - kspace_shape = tf.shape(kspace)[coil_axis:] - kspace = tf.reshape(kspace, tf.concat([[-1], kspace_shape], 0)) - - # Apply compression for each element in batch. - def compress_coils_fn(inputs): - ksp, cal = inputs - return get_coil_compressor(method, - coil_axis=coil_axis, - **kwargs).fit(cal).transform(ksp) - output_shape = [kwargs.get('out_coils')] + kspace.shape[2:].as_list() - fn_output_signature = tf.TensorSpec(shape=output_shape, dtype=kspace.dtype) - kspace = tf.map_fn(compress_coils_fn, (kspace, calib_data), - fn_output_signature=fn_output_signature) - - # Restore batch shape. - output_shape = tf.shape(kspace)[1:] - output_shape_static = kspace.shape[1:] - kspace = tf.reshape(kspace, - tf.concat([batch_shape, output_shape], 0)) - kspace = tf.ensure_shape( - kspace, batch_shape_static.concatenate(output_shape_static)) - - return kspace From 4112958b287252f8b7cf802caebb9deb869be41b Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 7 Sep 2022 12:49:38 +0100 Subject: [PATCH 089/101] Replaced note and warning directives with MyST syntax --- tensorflow_mri/cc/ops/traj_ops.cc | 2 +- .../python/coils/coil_compression.py | 2 +- .../python/initializers/initializers.py | 13 +++++----- tensorflow_mri/python/io/twix_io.py | 3 ++- tensorflow_mri/python/layers/pooling.py | 7 +++-- tensorflow_mri/python/layers/reshaping.py | 7 +++-- .../python/linalg/conjugate_gradient.py | 2 +- .../python/linalg/linear_operator.py | 2 +- tensorflow_mri/python/losses/iqa_losses.py | 8 +++--- .../python/metrics/confusion_metrics.py | 2 +- tensorflow_mri/python/metrics/iqa_metrics.py | 4 +-- tensorflow_mri/python/ops/array_ops.py | 15 +++++++---- tensorflow_mri/python/ops/convex_ops.py | 12 ++++----- tensorflow_mri/python/ops/fft_ops.py | 6 +++-- tensorflow_mri/python/ops/image_ops.py | 26 +++++++++---------- tensorflow_mri/python/ops/math_ops.py | 6 ++--- tensorflow_mri/python/ops/optimizer_ops.py | 2 +- tensorflow_mri/python/ops/recon_ops.py | 18 ++++++------- tensorflow_mri/python/ops/signal_ops.py | 2 +- tensorflow_mri/python/util/test_util.py | 3 ++- 20 files changed, 74 insertions(+), 68 deletions(-) diff --git a/tensorflow_mri/cc/ops/traj_ops.cc b/tensorflow_mri/cc/ops/traj_ops.cc index 76a916bc..75b7131f 100644 --- a/tensorflow_mri/cc/ops/traj_ops.cc +++ b/tensorflow_mri/cc/ops/traj_ops.cc @@ -126,7 +126,7 @@ as follows: * A fixed-density portion between `vd_outer_cutoff` and 1.0, sampled at `vd_outer_density` times the Nyquist rate. -.. [1] Pipe, J.G. and Zwart, N.R. (2014), Spiral trajectory design: A flexible +1. Pipe, J.G. and Zwart, N.R. (2014), Spiral trajectory design: A flexible numerical algorithm and base analytical equations. Magn. Reson. Med, 71: 278-285. https://doi.org/10.1002/mrm.24675 diff --git a/tensorflow_mri/python/coils/coil_compression.py b/tensorflow_mri/python/coils/coil_compression.py index e6e470c1..235c8d37 100644 --- a/tensorflow_mri/python/coils/coil_compression.py +++ b/tensorflow_mri/python/coils/coil_compression.py @@ -131,7 +131,7 @@ class CoilCompressorSVD(CoilCompressor): together with `out_coils`. References: - .. [1] Huang, F., Vijayakumar, S., Li, Y., Hertel, S. and Duensing, G.R. + 1. Huang, F., Vijayakumar, S., Li, Y., Hertel, S. and Duensing, G.R. (2008). A software channel compression technique for faster reconstruction with many channels. Magn Reson Imaging, 26(1): 133-141. """ diff --git a/tensorflow_mri/python/initializers/initializers.py b/tensorflow_mri/python/initializers/initializers.py index 0f18f2df..6b3ff6c1 100644 --- a/tensorflow_mri/python/initializers/initializers.py +++ b/tensorflow_mri/python/initializers/initializers.py @@ -48,13 +48,12 @@ EXTENSION_NOTE = string.Template(""" - .. note:: - This initializer can be used as a drop-in replacement for - `tf.keras.initializers.${name}`_. However, this one also supports - initialization of complex-valued weights. Simply pass `dtype='complex64'` - or `dtype='complex128'` to its `__call__` method. - - .. _tf.keras.initializers.${name}: https://www.tensorflow.org/api_docs/python/tf/keras/initializers/${name} + ```{note} + This initializer can be used as a drop-in replacement for + `tf.keras.initializers.${name}`. However, this one also supports + initialization of complex-valued weights. Simply pass `dtype='complex64'` + or `dtype='complex128'` to its `__call__` method. + ``` """) diff --git a/tensorflow_mri/python/io/twix_io.py b/tensorflow_mri/python/io/twix_io.py index 553b4498..936f508c 100644 --- a/tensorflow_mri/python/io/twix_io.py +++ b/tensorflow_mri/python/io/twix_io.py @@ -39,8 +39,9 @@ def parse_twix(contents): """Parses the contents of a TWIX RAID file (Siemens raw data). - .. warning:: + ```{warning} This function does not support graph execution. + ``` Example: >>> # Read bytes from file. diff --git a/tensorflow_mri/python/layers/pooling.py b/tensorflow_mri/python/layers/pooling.py index 83b9b5e1..5c070db2 100644 --- a/tensorflow_mri/python/layers/pooling.py +++ b/tensorflow_mri/python/layers/pooling.py @@ -23,13 +23,12 @@ EXTENSION_NOTE = string.Template(""" - .. note:: + ```{note} This layer can be used as a drop-in replacement for - `tf.keras.layers.${name}`_. However, this one also supports complex-valued + `tf.keras.layers.${name}`. However, this one also supports complex-valued pooling. Simply pass `dtype='complex64'` or `dtype='complex128'` to the layer constructor. - - .. _tf.keras.layers.${name}: https://www.tensorflow.org/api_docs/python/tf/keras/layers/${name} + ``` """) diff --git a/tensorflow_mri/python/layers/reshaping.py b/tensorflow_mri/python/layers/reshaping.py index 2548fa48..d20decef 100644 --- a/tensorflow_mri/python/layers/reshaping.py +++ b/tensorflow_mri/python/layers/reshaping.py @@ -23,13 +23,12 @@ EXTENSION_NOTE = string.Template(""" - .. note:: + ```{note} This layer can be used as a drop-in replacement for - `tf.keras.layers.${name}`_. However, this one also supports complex-valued + `tf.keras.layers.${name}`. However, this one also supports complex-valued operations. Simply pass `dtype='complex64'` or `dtype='complex128'` to the layer constructor. - - .. _tf.keras.layers.${name}: https://www.tensorflow.org/api_docs/python/tf/keras/layers/${name} + ``` """) diff --git a/tensorflow_mri/python/linalg/conjugate_gradient.py b/tensorflow_mri/python/linalg/conjugate_gradient.py index 25f2069a..fb31c732 100644 --- a/tensorflow_mri/python/linalg/conjugate_gradient.py +++ b/tensorflow_mri/python/linalg/conjugate_gradient.py @@ -99,7 +99,7 @@ def conjugate_gradient(operator, ValueError: If `operator` is not self-adjoint and positive definite. References: - .. [1] Aggarwal, H. K., Mani, M. P., & Jacob, M. (2018). MoDL: Model-based + 1. Aggarwal, H. K., Mani, M. P., & Jacob, M. (2018). MoDL: Model-based deep learning architecture for inverse problems. IEEE transactions on medical imaging, 38(2), 394-405. """ diff --git a/tensorflow_mri/python/linalg/linear_operator.py b/tensorflow_mri/python/linalg/linear_operator.py index 08fc6b92..a4e79c14 100644 --- a/tensorflow_mri/python/linalg/linear_operator.py +++ b/tensorflow_mri/python/linalg/linear_operator.py @@ -430,7 +430,7 @@ class LinearOperator(LinearOperatorMixin, tf.linalg.LinearOperator): # pylint: name: A name for this `LinearOperator`. References: - .. [1] https://onlinelibrary.wiley.com/doi/full/10.1002/mrm.1241 + 1. https://onlinelibrary.wiley.com/doi/full/10.1002/mrm.1241 .. _tf.linalg.LinearOperator: https://www.tensorflow.org/api_docs/python/tf/linalg/LinearOperator .. _tf.linalg.matvec: https://www.tensorflow.org/api_docs/python/tf/linalg/matvec diff --git a/tensorflow_mri/python/losses/iqa_losses.py b/tensorflow_mri/python/losses/iqa_losses.py index af4a2bf0..d50764b0 100644 --- a/tensorflow_mri/python/losses/iqa_losses.py +++ b/tensorflow_mri/python/losses/iqa_losses.py @@ -125,7 +125,7 @@ class SSIMLoss(LossFunctionWrapperIQA): name: String name of the loss instance. References: - .. [1] Zhao, H., Gallo, O., Frosio, I., & Kautz, J. (2016). Loss functions + 1. Zhao, H., Gallo, O., Frosio, I., & Kautz, J. (2016). Loss functions for image restoration with neural networks. IEEE Transactions on computational imaging, 3(1), 47-57. """ @@ -204,7 +204,7 @@ class SSIMMultiscaleLoss(LossFunctionWrapperIQA): name: String name of the loss instance. References: - .. [1] Zhao, H., Gallo, O., Frosio, I., & Kautz, J. (2016). Loss functions + 1. Zhao, H., Gallo, O., Frosio, I., & Kautz, J. (2016). Loss functions for image restoration with neural networks. IEEE Transactions on computational imaging, 3(1), 47-57. """ @@ -285,7 +285,7 @@ def ssim_loss(y_true, y_pred, max_val=None, value for each image in the batch. References: - .. [1] Zhao, H., Gallo, O., Frosio, I., & Kautz, J. (2016). Loss functions + 1. Zhao, H., Gallo, O., Frosio, I., & Kautz, J. (2016). Loss functions for image restoration with neural networks. IEEE Transactions on computational imaging, 3(1), 47-57. """ @@ -357,7 +357,7 @@ def ssim_multiscale_loss(y_true, y_pred, max_val=None, value for each image in the batch. References: - .. [1] Zhao, H., Gallo, O., Frosio, I., & Kautz, J. (2016). Loss functions + 1. Zhao, H., Gallo, O., Frosio, I., & Kautz, J. (2016). Loss functions for image restoration with neural networks. IEEE Transactions on computational imaging, 3(1), 47-57. """ diff --git a/tensorflow_mri/python/metrics/confusion_metrics.py b/tensorflow_mri/python/metrics/confusion_metrics.py index 680858d3..0aa0c59a 100644 --- a/tensorflow_mri/python/metrics/confusion_metrics.py +++ b/tensorflow_mri/python/metrics/confusion_metrics.py @@ -492,7 +492,7 @@ class TverskyIndex(ConfusionMetric): dtype: Data type of the metric result. References: - .. [1] Tversky, A. (1977). Features of similarity. Psychological review, + 1. Tversky, A. (1977). Features of similarity. Psychological review, 84(4), 327. """ # pylint: disable=line-too-long def __init__(self, diff --git a/tensorflow_mri/python/metrics/iqa_metrics.py b/tensorflow_mri/python/metrics/iqa_metrics.py index 6ec4ff5d..7e8182fb 100755 --- a/tensorflow_mri/python/metrics/iqa_metrics.py +++ b/tensorflow_mri/python/metrics/iqa_metrics.py @@ -194,7 +194,7 @@ class SSIM(MeanMetricWrapperIQA): dtype: Data type of the metric result. References: - .. [1] Wang, Z., Bovik, A. C., Sheikh, H. R., & Simoncelli, E. P. (2004). + 1. Wang, Z., Bovik, A. C., Sheikh, H. R., & Simoncelli, E. P. (2004). Image quality assessment: from error visibility to structural similarity. IEEE transactions on image processing, 13(4), 600-612. """ @@ -276,7 +276,7 @@ class SSIMMultiscale(MeanMetricWrapperIQA): dtype: Data type of the metric result. References: - .. [1] Wang, Z., Simoncelli, E. P., & Bovik, A. C. (2003, November). + 1. Wang, Z., Simoncelli, E. P., & Bovik, A. C. (2003, November). Multiscale structural similarity for image quality assessment. In The Thrity-Seventh Asilomar Conference on Signals, Systems & Computers, 2003 (Vol. 2, pp. 1398-1402). Ieee. diff --git a/tensorflow_mri/python/ops/array_ops.py b/tensorflow_mri/python/ops/array_ops.py index 8efeb812..99f4fc1a 100644 --- a/tensorflow_mri/python/ops/array_ops.py +++ b/tensorflow_mri/python/ops/array_ops.py @@ -76,9 +76,10 @@ def meshgrid(*args): fields over N-D grids, given one-dimensional coordinate arrays `x1, x2, ..., xn`. - .. note:: + ```{note} Similar to `tf.meshgrid`, but uses matrix indexing and returns a stacked tensor (along axis -1) instead of a list of tensors. + ``` Args: *args: `Tensors` with rank 1. @@ -98,10 +99,11 @@ def dynamic_meshgrid(vecs): fields over N-D grids, given one-dimensional coordinate arrays `x1, x2, ..., xn`. - .. note:: + ```{note} Similar to `tf.meshgrid`, but uses matrix indexing, supports dynamic tensor arrays and returns a stacked tensor (along axis -1) instead of a list of tensors. + ``` Args: vecs: A `tf.TensorArray` containing the coordinate vectors. @@ -347,13 +349,15 @@ def update_tensor(tensor, slices, value): This operator performs slice assignment. - .. note:: + ```{note} Equivalent to `tensor[slices] = value`. + ``` - .. warning:: + ```{warning} TensorFlow does not support slice assignment because tensors are immutable. This operator works around this limitation by creating a new tensor, which may have performance implications. + ``` Args: tensor: A `tf.Tensor`. @@ -388,9 +392,10 @@ def _with_index_update_helper(update_method, a, slice_spec, updates): # pylint: def map_fn(fn, elems, batch_dims=1, **kwargs): """Transforms `elems` by applying `fn` to each element. - .. note:: + ```{note} Similar to `tf.map_fn`, but it supports unstacking along multiple batch dimensions. + ``` For the parameters, see `tf.map_fn`. The only difference is that there is an additional `batch_dims` keyword argument which allows specifying the number diff --git a/tensorflow_mri/python/ops/convex_ops.py b/tensorflow_mri/python/ops/convex_ops.py index 02c1517f..20b11961 100644 --- a/tensorflow_mri/python/ops/convex_ops.py +++ b/tensorflow_mri/python/ops/convex_ops.py @@ -435,7 +435,7 @@ class ConvexFunctionIndicatorL1Ball(ConvexFunctionIndicatorBall): # pylint: dis name: A name for this `ConvexFunction`. References: - .. [1] Parikh, N., & Boyd, S. (2014). Proximal algorithms. Foundations and + 1. Parikh, N., & Boyd, S. (2014). Proximal algorithms. Foundations and Trends in optimization, 1(3), 127-239. """ def __init__(self, @@ -459,7 +459,7 @@ class ConvexFunctionIndicatorL2Ball(ConvexFunctionIndicatorBall): # pylint: dis name: A name for this `ConvexFunction`. References: - .. [1] Parikh, N., & Boyd, S. (2014). Proximal algorithms. Foundations and + 1. Parikh, N., & Boyd, S. (2014). Proximal algorithms. Foundations and Trends in optimization, 1(3), 127-239. """ def __init__(self, @@ -485,7 +485,7 @@ class ConvexFunctionNorm(ConvexFunction): # pylint: disable=abstract-method name: A name for this `ConvexFunction`. References: - .. [1] Parikh, N., & Boyd, S. (2014). Proximal algorithms. Foundations and + 1. Parikh, N., & Boyd, S. (2014). Proximal algorithms. Foundations and Trends in optimization, 1(3), 127-239. """ def __init__(self, @@ -545,7 +545,7 @@ class ConvexFunctionL1Norm(ConvexFunctionNorm): # pylint: disable=abstract-meth name: A name for this `ConvexFunction`. References: - .. [1] Parikh, N., & Boyd, S. (2014). Proximal algorithms. Foundations and + 1. Parikh, N., & Boyd, S. (2014). Proximal algorithms. Foundations and Trends in optimization, 1(3), 127-239. """ def __init__(self, @@ -569,7 +569,7 @@ class ConvexFunctionL2Norm(ConvexFunctionNorm): # pylint: disable=abstract-meth name: A name for this `ConvexFunction`. References: - .. [1] Parikh, N., & Boyd, S. (2014). Proximal algorithms. Foundations and + 1. Parikh, N., & Boyd, S. (2014). Proximal algorithms. Foundations and Trends in optimization, 1(3), 127-239. """ def __init__(self, @@ -593,7 +593,7 @@ class ConvexFunctionL2NormSquared(ConvexFunction): # pylint: disable=abstract-m name: A name for this `ConvexFunction`. References: - .. [1] Parikh, N., & Boyd, S. (2014). Proximal algorithms. Foundations and + 1. Parikh, N., & Boyd, S. (2014). Proximal algorithms. Foundations and Trends in optimization, 1(3), 127-239. """ def __init__(self, diff --git a/tensorflow_mri/python/ops/fft_ops.py b/tensorflow_mri/python/ops/fft_ops.py index ebc46d87..b30c27b7 100644 --- a/tensorflow_mri/python/ops/fft_ops.py +++ b/tensorflow_mri/python/ops/fft_ops.py @@ -37,8 +37,9 @@ def fftn(x, shape=None, axes=None, norm='backward', shift=False): number of axes in an `M`-dimensional array by means of the Fast Fourier Transform (FFT). - .. note:: + ```{note} `N` must be 1, 2 or 3. + ``` Args: x: A `Tensor`. Must be one of the following types: `complex64`, @@ -87,8 +88,9 @@ def ifftn(x, shape=None, axes=None, norm='backward', shift=False): Transform over any number of axes in an M-dimensional array by means of the Fast Fourier Transform (FFT). - .. note:: + ```{note} `N` must be 1, 2 or 3. + ``` Args: x: A `Tensor`. Must be one of the following types: `complex64`, diff --git a/tensorflow_mri/python/ops/image_ops.py b/tensorflow_mri/python/ops/image_ops.py index 9e3a0324..c269825b 100644 --- a/tensorflow_mri/python/ops/image_ops.py +++ b/tensorflow_mri/python/ops/image_ops.py @@ -218,7 +218,7 @@ def ssim(img1, value for each image in the batch. References: - .. [1] Zhou Wang, A. C. Bovik, H. R. Sheikh and E. P. Simoncelli, "Image + 1. Zhou Wang, A. C. Bovik, H. R. Sheikh and E. P. Simoncelli, "Image quality assessment: from error visibility to structural similarity," in IEEE Transactions on Image Processing, vol. 13, no. 4, pp. 600-612, April 2004, doi: 10.1109/TIP.2003.819861. @@ -293,7 +293,7 @@ def ssim2d(img1, value for each image in the batch. References: - .. [1] Zhou Wang, A. C. Bovik, H. R. Sheikh and E. P. Simoncelli, "Image + 1. Zhou Wang, A. C. Bovik, H. R. Sheikh and E. P. Simoncelli, "Image quality assessment: from error visibility to structural similarity," in IEEE Transactions on Image Processing, vol. 13, no. 4, pp. 600-612, April 2004, doi: 10.1109/TIP.2003.819861. @@ -350,7 +350,7 @@ def ssim3d(img1, value for each image in the batch. References: - .. [1] Zhou Wang, A. C. Bovik, H. R. Sheikh and E. P. Simoncelli, "Image + 1. Zhou Wang, A. C. Bovik, H. R. Sheikh and E. P. Simoncelli, "Image quality assessment: from error visibility to structural similarity," in IEEE Transactions on Image Processing, vol. 13, no. 4, pp. 600-612, April 2004, doi: 10.1109/TIP.2003.819861. @@ -435,7 +435,7 @@ def ssim_multiscale(img1, value for each image in the batch. References: - .. [1] Z. Wang, E. P. Simoncelli and A. C. Bovik, "Multiscale structural + 1. Z. Wang, E. P. Simoncelli and A. C. Bovik, "Multiscale structural similarity for image quality assessment," The Thrity-Seventh Asilomar Conference on Signals, Systems & Computers, 2003, 2003, pp. 1398-1402 Vol.2, doi: 10.1109/ACSSC.2003.1292216. @@ -598,7 +598,7 @@ def ssim2d_multiscale(img1, value for each image in the batch. References: - .. [1] Z. Wang, E. P. Simoncelli and A. C. Bovik, "Multiscale structural + 1. Z. Wang, E. P. Simoncelli and A. C. Bovik, "Multiscale structural similarity for image quality assessment," The Thrity-Seventh Asilomar Conference on Signals, Systems & Computers, 2003, 2003, pp. 1398-1402 Vol.2, doi: 10.1109/ACSSC.2003.1292216. @@ -664,7 +664,7 @@ def ssim3d_multiscale(img1, value for each image in the batch. References: - .. [1] Z. Wang, E. P. Simoncelli and A. C. Bovik, "Multiscale structural + 1. Z. Wang, E. P. Simoncelli and A. C. Bovik, "Multiscale structural similarity for image quality assessment," The Thrity-Seventh Asilomar Conference on Signals, Systems & Computers, 2003, 2003, pp. 1398-1402 Vol.2, doi: 10.1109/ACSSC.2003.1292216. @@ -1104,7 +1104,7 @@ def gmsd(img1, returned tensor has type `tf.float32` and shape `batch_shape`. References: - .. [1] W. Xue, L. Zhang, X. Mou and A. C. Bovik, "Gradient Magnitude + 1. W. Xue, L. Zhang, X. Mou and A. C. Bovik, "Gradient Magnitude Similarity Deviation: A Highly Efficient Perceptual Image Quality Index," in IEEE Transactions on Image Processing, vol. 23, no. 2, pp. 684-695, Feb. 2014, doi: 10.1109/TIP.2013.2293423. @@ -1175,7 +1175,7 @@ def gmsd2d(img1, img2, max_val=1.0, name=None): returned tensor has type `tf.float32` and shape `batch_shape`. References: - .. [1] W. Xue, L. Zhang, X. Mou and A. C. Bovik, "Gradient Magnitude + 1. W. Xue, L. Zhang, X. Mou and A. C. Bovik, "Gradient Magnitude Similarity Deviation: A Highly Efficient Perceptual Image Quality Index," in IEEE Transactions on Image Processing, vol. 23, no. 2, pp. 684-695, Feb. 2014, doi: 10.1109/TIP.2013.2293423. @@ -1205,7 +1205,7 @@ def gmsd3d(img1, img2, max_val=1.0, name=None): returned tensor has type `tf.float32` and shape `batch_shape`. References: - .. [1] W. Xue, L. Zhang, X. Mou and A. C. Bovik, "Gradient Magnitude + 1. W. Xue, L. Zhang, X. Mou and A. C. Bovik, "Gradient Magnitude Similarity Deviation: A Highly Efficient Perceptual Image Quality Index," in IEEE Transactions on Image Processing, vol. 23, no. 2, pp. 684-695, Feb. 2014, doi: 10.1109/TIP.2013.2293423. @@ -1642,13 +1642,13 @@ def phantom(phantom_type='modified_shepp_logan', # pylint: disable=dangerous-de ValueError: If the requested ND phantom is not defined. References: - .. [1] Shepp, L. A., & Logan, B. F. (1974). The Fourier reconstruction of a + 1. Shepp, L. A., & Logan, B. F. (1974). The Fourier reconstruction of a head section. IEEE Transactions on nuclear science, 21(3), 21-43. - .. [2] Toft, P. (1996). The radon transform. Theory and Implementation + 2. Toft, P. (1996). The radon transform. Theory and Implementation (Ph. D. Dissertation)(Copenhagen: Technical University of Denmark). - .. [3] Kak, A. C., & Slaney, M. (2001). Principles of computerized + 3. Kak, A. C., & Slaney, M. (2001). Principles of computerized tomographic imaging. Society for Industrial and Applied Mathematics. - .. [4] Koay, C. G., Sarlls, J. E., & Özarslan, E. (2007). Three‐dimensional + 4. Koay, C. G., Sarlls, J. E., & Özarslan, E. (2007). Three‐dimensional analytical magnetic resonance imaging phantom in the Fourier domain. Magnetic Resonance in Medicine, 58(2), 430-436. """ diff --git a/tensorflow_mri/python/ops/math_ops.py b/tensorflow_mri/python/ops/math_ops.py index db6235ed..e939e8e8 100644 --- a/tensorflow_mri/python/ops/math_ops.py +++ b/tensorflow_mri/python/ops/math_ops.py @@ -501,7 +501,7 @@ def project_onto_simplex(x, radius=1.0, name=None): ValueError: If inputs are invalid. References: - .. [1] Duchi, J., Shalev-Shwartz, S., Singer, Y., & Chandra, T. (2008). + 1. Duchi, J., Shalev-Shwartz, S., Singer, Y., & Chandra, T. (2008). Efficient projections onto the l1-ball for learning in high dimensions. In Proceedings of the 25th International Conference on Machine Learning (pp. 272-279). @@ -556,10 +556,10 @@ def project_onto_ball(x, order=2, radius=1.0, name=None): ValueError: If inputs are invalid. References: - .. [1] Parikh, N., & Boyd, S. (2014). Proximal algorithms. Foundations and + 1. Parikh, N., & Boyd, S. (2014). Proximal algorithms. Foundations and Trends in optimization, 1(3), 127-239. - .. [2] Duchi, J., Shalev-Shwartz, S., Singer, Y., & Chandra, T. (2008). + 2. Duchi, J., Shalev-Shwartz, S., Singer, Y., & Chandra, T. (2008). Efficient projections onto the l1-ball for learning in high dimensions. In Proceedings of the 25th International Conference on Machine Learning (pp. 272-279). diff --git a/tensorflow_mri/python/ops/optimizer_ops.py b/tensorflow_mri/python/ops/optimizer_ops.py index 8b1fc3a6..9cc9a79a 100644 --- a/tensorflow_mri/python/ops/optimizer_ops.py +++ b/tensorflow_mri/python/ops/optimizer_ops.py @@ -255,7 +255,7 @@ def admm_minimize(function_f, during the search. References: - .. [1] Boyd, S., Parikh, N., & Chu, E. (2011). Distributed optimization and + 1. Boyd, S., Parikh, N., & Chu, E. (2011). Distributed optimization and statistical learning via the alternating direction method of multipliers. Now Publishers Inc. diff --git a/tensorflow_mri/python/ops/recon_ops.py b/tensorflow_mri/python/ops/recon_ops.py index 9c9c66d8..f3bc96bb 100644 --- a/tensorflow_mri/python/ops/recon_ops.py +++ b/tensorflow_mri/python/ops/recon_ops.py @@ -169,28 +169,28 @@ def reconstruct_lstsq(kspace, it may be time-consuming, depending on the characteristics of the problem. References: - .. [1] Pruessmann, K.P., Weiger, M., Börnert, P. and Boesiger, P. (2001), + 1. Pruessmann, K.P., Weiger, M., Börnert, P. and Boesiger, P. (2001), Advances in sensitivity encoding with arbitrary k-space trajectories. Magn. Reson. Med., 46: 638-651. https://doi.org/10.1002/mrm.1241 - .. [2] Block, K.T., Uecker, M. and Frahm, J. (2007), Undersampled radial MRI + 2. Block, K.T., Uecker, M. and Frahm, J. (2007), Undersampled radial MRI with multiple coils. Iterative image reconstruction using a total variation constraint. Magn. Reson. Med., 57: 1086-1098. https://doi.org/10.1002/mrm.21236 - .. [3] Feng, L., Grimm, R., Block, K.T., Chandarana, H., Kim, S., Xu, J., + 3. Feng, L., Grimm, R., Block, K.T., Chandarana, H., Kim, S., Xu, J., Axel, L., Sodickson, D.K. and Otazo, R. (2014), Golden-angle radial sparse parallel MRI: Combination of compressed sensing, parallel imaging, and golden-angle radial sampling for fast and flexible dynamic volumetric MRI. Magn. Reson. Med., 72: 707-717. https://doi.org/10.1002/mrm.24980 - .. [4] Tsao, J., Boesiger, P., & Pruessmann, K. P. (2003). k-t BLAST and + 4. Tsao, J., Boesiger, P., & Pruessmann, K. P. (2003). k-t BLAST and k-t SENSE: dynamic MRI with high frame rate exploiting spatiotemporal correlations. Magnetic Resonance in Medicine: An Official Journal of the International Society for Magnetic Resonance in Medicine, 50(5), 1031-1042. - .. [5] Fessler, J. A., Lee, S., Olafsson, V. T., Shi, H. R., & Noll, D. C. + 5. Fessler, J. A., Lee, S., Olafsson, V. T., Shi, H. R., & Noll, D. C. (2005). Toeplitz-based iterative image reconstruction for MRI with correction for magnetic field inhomogeneity. IEEE Transactions on Signal Processing, 53(9), 3393-3402. @@ -405,7 +405,7 @@ def reconstruct_sense(kspace, ValueError: If `kspace` and `sensitivities` have incompatible batch shapes. References: - .. [1] Pruessmann, K.P., Weiger, M., Scheidegger, M.B. and Boesiger, P. + 1. Pruessmann, K.P., Weiger, M., Scheidegger, M.B. and Boesiger, P. (1999), SENSE: Sensitivity encoding for fast MRI. Magn. Reson. Med., 42: 952-962. https://doi.org/10.1002/(SICI)1522-2594(199911)42:5<952::AID-MRM16>3.0.CO;2-S @@ -586,7 +586,7 @@ def reconstruct_grappa(kspace, the spatial shape. References: - .. [1] Griswold, M.A., Jakob, P.M., Heidemann, R.M., Nittka, M., Jellus, V., + 1. Griswold, M.A., Jakob, P.M., Heidemann, R.M., Nittka, M., Jellus, V., Wang, J., Kiefer, B. and Haase, A. (2002), Generalized autocalibrating partially parallel acquisitions (GRAPPA). Magn. Reson. Med., 47: 1202-1210. https://doi.org/10.1002/mrm.10171 @@ -887,10 +887,10 @@ def reconstruct_pf(kspace, POCS algorithm. Defaults to `10`. References: - .. [1] Noll, D. C., Nishimura, D. G., & Macovski, A. (1991). Homodyne + 1. Noll, D. C., Nishimura, D. G., & Macovski, A. (1991). Homodyne detection in magnetic resonance imaging. IEEE transactions on medical imaging, 10(2), 154-163. - .. [2] Haacke, E. M., Lindskogj, E. D., & Lin, W. (1991). A fast, iterative, + 2. Haacke, E. M., Lindskogj, E. D., & Lin, W. (1991). A fast, iterative, partial-Fourier technique capable of local phase recovery. Journal of Magnetic Resonance (1969), 92(1), 126-145. """ diff --git a/tensorflow_mri/python/ops/signal_ops.py b/tensorflow_mri/python/ops/signal_ops.py index dc109c0a..58f810d7 100644 --- a/tensorflow_mri/python/ops/signal_ops.py +++ b/tensorflow_mri/python/ops/signal_ops.py @@ -90,7 +90,7 @@ def atanfilt(arg, cutoff=np.pi, beta=100.0, name=None): A `Tensor` of shape `arg.shape`. References: - .. [1] Pruessmann, K.P., Weiger, M., Börnert, P. and Boesiger, P. (2001), + 1. Pruessmann, K.P., Weiger, M., Börnert, P. and Boesiger, P. (2001), Advances in sensitivity encoding with arbitrary k-space trajectories. Magn. Reson. Med., 46: 638-651. https://doi.org/10.1002/mrm.1241 """ diff --git a/tensorflow_mri/python/util/test_util.py b/tensorflow_mri/python/util/test_util.py index 8a11a8b6..60673fbd 100644 --- a/tensorflow_mri/python/util/test_util.py +++ b/tensorflow_mri/python/util/test_util.py @@ -117,8 +117,9 @@ def run_in_graph_and_eager_modes(func=None, config=None, use_gpu=True): execution enabled. This allows unittests to confirm the equivalence between eager and graph execution. - .. note:: + ```{note} This decorator can only be used when executing eagerly in the outer scope. + ``` Args: func: function to be annotated. If `func` is None, this method returns a From 0c2483dc6f9e512f7f43b37a21812249bf54517a Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 7 Sep 2022 12:51:58 +0100 Subject: [PATCH 090/101] Removed custom Sphinx extensions in favour of TF manylinux image --- .../docs/extensions/myst_autodoc/__init__.py | 415 ----- .../extensions/myst_autosummary/__init__.py | 198 --- .../extensions/myst_autosummary/generate.py | 657 -------- .../docs/extensions/myst_napoleon/__init__.py | 479 ------ .../extensions/myst_napoleon/docstring.py | 1357 ----------------- .../extensions/myst_napoleon/iterators.py | 235 --- 6 files changed, 3341 deletions(-) delete mode 100644 tools/docs/extensions/myst_autodoc/__init__.py delete mode 100644 tools/docs/extensions/myst_autosummary/__init__.py delete mode 100644 tools/docs/extensions/myst_autosummary/generate.py delete mode 100644 tools/docs/extensions/myst_napoleon/__init__.py delete mode 100644 tools/docs/extensions/myst_napoleon/docstring.py delete mode 100644 tools/docs/extensions/myst_napoleon/iterators.py diff --git a/tools/docs/extensions/myst_autodoc/__init__.py b/tools/docs/extensions/myst_autodoc/__init__.py deleted file mode 100644 index f14e4ecd..00000000 --- a/tools/docs/extensions/myst_autodoc/__init__.py +++ /dev/null @@ -1,415 +0,0 @@ -"""MyST-compatible drop-in replacement for Sphinx's Autodoc extension.""" -__version__ = '0.1.0' - -# This extension essentially overrides all content creation done by -# Autodoc so that the output is Markdown to be parsed by MyST, instead -# of the original reStructuredText parsed by Sphinx directly. It is -# therefore prone to breakage when there are upstream changes. -# -# Namely, the overridden methods are `add_line`, `add_directive_header`, -# and `generate` of Autodoc's `Documenter` class, as well as of all -# classes derived from it, implementing the various directives for -# modules, functions, etc. Code comments here only pertain to changes -# made to the original code for reST, the original comments from the -# Autodoc source were removed so as to not be a distraction. Type hints -# were also removed, but could easily be put back in. String interpolation -# was changed to f-strings. We use our own logger name, but could have -# kept using Autodoc's. Some variable names were shortened, like `source` -# instead of `sourcename`, to keep lines under 80 characters. - - -import sphinx -from sphinx.ext import autodoc -from sphinx.util import inspect -from sphinx.pycode import ModuleAnalyzer, PycodeError -from sphinx.ext.autodoc.mock import ismock -from sphinx.util.typing import get_type_hints, stringify, restify -import re - -logger = sphinx.util.logging.getLogger(__name__) - - -class Documenter(autodoc.Documenter): - """ - Mix-in to override content generation by `Documenter` class. - - All of Autodoc's documenter classes (for modules, functions, etc.) - derive from the `Documenter` base. Methods that generate reST will - have to be rewritten to output Markdown instead. They are defined - here to be mixed into the the various documenter classes. - """ - - def fence(self): - """ - Returns back-ticks fence corresponding to indentation level. - - The indentation level in the reST output corresponds to the scope - of the directive block in Markdown, which is delimited by back-ticks. - The further out the scope, the more back-ticks we have to put. This - helper function returns a string with the correct number of ticks - based on the indentation level in the original reStructuredText. - The indentation level is determined by the current indentation and - the length of indentation that would be used to nest content. - """ - unit = self.content_indent or ' ' - (scope, remainder) = divmod(len(self.indent), len(unit)) - if remainder: - raise RuntimeError(f'Indentation not a multiple of {len(unit)}.') - if scope > 1: - raise NotImplementedError('More than one nested scope in Autodoc ' - 'directive.') - backticks = '```' + '`'*(2 - scope) - return backticks - - def add_line(self, line, source, *lineno): - """Appends one line to the generated output.""" - # Add content, but without the original indentation. - self.directive.result.append(line, source, *lineno) - - def add_directive_header(self, signature): - """Adds directive header and options to the generated content.""" - domain = getattr(self, 'domain', 'py') - directive = getattr(self, 'directivetype', self.objtype) - name = self.format_name() - source = self.get_sourcename() - prefix = self.fence() + '{' + f'{domain}:{directive}' + '} ' - # This code dealing with multi-line signature was rewritten, for - # brevity, but is entirely untested. - (first, *rest) = signature.split('\n') - self.add_line(f'{prefix}{name}{first}', source) - for line in rest: - indent = ' '*len(prefix) - self.add_line(f'{indent}{name}{first}', source) - # Add field-list options, but drop the original indentation. - if self.options.noindex: - self.add_line(':noindex:', source) - if self.objpath: - self.add_line(f':module: {self.modname}', source) - - def generate(self, more_content=None, real_modname=None, - check_module=False, all_members=False): - """ - Generates the Markdown content replacing an Autodoc directive. - - We don't call the corresponding method from the parent class, - but rather rewrite it with Markdown output. This is done to - avoid parsing the generated reStructuredText, which is possible, - but might be error-prone. - """ - - # Until noted otherwise, code is the same as in the parent class. - # See source code comments there for clarification. - - if not self.parse_name(): - # Have parent class log the corresponding warning. - super().generate(more_content, real_modname, check_module, - all_members) - return - - if not self.import_object(): - return - - guess_modname = self.get_real_modname() - self.real_modname: str = real_modname or guess_modname - - try: - self.analyzer = ModuleAnalyzer.for_module(self.real_modname) - self.analyzer.find_attr_docs() - except PycodeError as exc: - logger.debug(f'[myst-docstring] module analyzer failed: {exc}') - self.analyzer = None - if hasattr(self.module, '__file__') and self.module.__file__: - self.directive.record_dependencies.add(self.module.__file__) - else: - self.directive.record_dependencies.add(self.analyzer.srcname) - - if self.real_modname != guess_modname: - try: - analyzer = ModuleAnalyzer.for_module(guess_modname) - self.directive.record_dependencies.add(analyzer.srcname) - except PycodeError: - pass - - docstrings = sum(self.get_doc() or [], []) - if ismock(self.object) and not docstrings: - logger.warning( - sphinx.locale.__(f'A mocked object is detected: {self.name}'), - type='myst-docstring') - if check_module: - if not self.check_module(): - return - - source = self.get_sourcename() - self.add_line('', source) - try: - signature = self.format_signature() - except Exception as exc: - logger.warning( - sphinx.locale.__('Error while formatting signature for ' - f'{self.fullname}: {exc}'), - type='myst-docstring') - return - - # From here on, we make changes to accommodate the Markdown syntax. - - # Generate the directive header and options. - self.add_directive_header(signature) - self.add_line('', source) - - # Some directives don't have body content, namely modules. Then - # there is nothing to indent in reST and the `content_indent` - # attribute of the corresponding Autodoc class will be an empty - # string. In Markdown, we have to close these directives right - # after the signature. The actual content, think members of a - # module, still follows, but is not syntactically part of the - # directive block. - fence = self.fence() - if not self.content_indent: - self.add_line(fence, source) - - # Document this object and its members. - save_indent = self.indent - self.indent += self.content_indent - self.add_content(more_content) - self.document_members(all_members) - self.indent = save_indent - - # Close directive block, unless closed previously. - if self.content_indent: - self.add_line(fence, source) - - -def mystify(cls): - """Convert Python class to a MyST reference.""" - # This helper function is entirely untested. - return re.sub(r':py:(\w+?):`(.+?)`', r'{py:\1}`\2`', restify(cls)) - - -# Mix the modified Documenter class back in with each directive defined -# by Autodoc, so that they all use the methods overridden above. Unless -# these classes override the same methods themselves, in which case we -# have to redefine them as well, since super() would otherwise resolve -# them incorrectly. (It may be possible to override the method resolution -# order by means of a meta class, but that's a lot of black magic.) - -class ModuleDocumenter(Documenter, autodoc.ModuleDocumenter): - - def add_directive_header(self, signature): - # Add field-list options, but drop the original indentation. - super().add_directive_header(signature) - source = self.get_sourcename() - if self.options.synopsis: - self.add_line(f':synopsis: {self.options.synopsis}', source) - if self.options.platform: - self.add_line(f':platform: {self.options.platform}', source) - if self.options.deprecated: - self.add_line(':deprecated:', source) - - -class FunctionDocumenter(Documenter, autodoc.FunctionDocumenter): - - def add_directive_header(self, signature): - # Add field-list options, but drop the original indentation. - source = self.get_sourcename() - super().add_directive_header(signature) - if (inspect.iscoroutinefunction(self.object) - or inspect.isasyncgenfunction(self.object)): - self.add_line(':async:', source) - - -class DecoratorDocumenter(Documenter, autodoc.DecoratorDocumenter): - pass - - -class ClassDocumenter(Documenter, autodoc.ClassDocumenter): - - def add_directive_header(self, signature): - # Add field-list options, but drop the original indentation. - source = self.get_sourcename() - if self.doc_as_attr: - self.directivetype = 'attribute' - super().add_directive_header(signature) - if self.analyzer and '.'.join(self.objpath) in self.analyzer.finals: - self.add_line(':final:', source) - canonical_fullname = self.get_canonical_fullname() - if (not self.doc_as_attr - and canonical_fullname - and self.fullname != canonical_fullname): - self.add_line(f':canonical: {canonical_fullname}', source) - if not self.doc_as_attr and self.options.show_inheritance: - if inspect.getorigbases(self.object): - bases = list(self.object.__orig_bases__) - elif (hasattr(self.object, '__bases__') - and len(self.object.__bases__)): - bases = list(self.object.__bases__) - else: - bases = [] - self.env.events.emit('autodoc-process-bases', self.fullname, - self.object, self.options, bases) - # Replaced `restify` with `mystify`. - base_classes = [mystify(cls) for cls in bases] - source = self.get_sourcename() - self.add_line('', source) - self.add_line( - sphinx.locale._(f'Bases: {", ".join(base_classes)}'), - source) - - def generate(self, more_content=None, real_modname=None, - check_module=False, all_members=False): - # Unchanged. See original source-code comment for clarification. - return super().generate(more_content=more_content, - check_module=check_module, - all_members=all_members) - - -class MethodDocumenter(Documenter, autodoc.MethodDocumenter): - - def add_directive_header(self, signature): - # Add field-list options, but drop the original indentation. - super().add_directive_header(signature) - source = self.get_sourcename() - obj = self.parent.__dict__.get(self.object_name, self.object) - if inspect.isabstractmethod(obj): - self.add_line(':abstractmethod:', source) - if inspect.iscoroutinefunction(obj) or inspect.isasyncgenfunction(obj): - self.add_line(':async:', source) - if inspect.isclassmethod(obj): - self.add_line(':classmethod:', source) - if inspect.isstaticmethod(obj, cls=self.parent, name=self.object_name): - self.add_line(':staticmethod:', source) - if self.analyzer and '.'.join(self.objpath) in self.analyzer.finals: - self.add_line(':final:', source) - - -class AttributeDocumenter(Documenter, autodoc.AttributeDocumenter): - - def add_directive_header(self, signature): - # Add field-list options, but drop the original indentation. - super().add_directive_header(signature) - source = self.get_sourcename() - if (self.options.annotation is autodoc.SUPPRESS - or self.should_suppress_directive_header()): - pass - elif self.options.annotation: - self.add_line(f':annotation: {self.options.annotation}', source) - else: - if self.config.autodoc_typehints != 'none': - annotations = get_type_hints(self.parent, None, - self.config.autodoc_type_aliases) - if self.objpath[-1] in annotations: - objrepr = stringify(annotations.get(self.objpath[-1])) - self.add_line(f':type: {objrepr}', source) - try: - if (self.options.no_value - or self.should_suppress_value_header() - or ismock(self.object)): - pass - else: - objrepr = inspect.object_description(self.object) - self.add_line(f':value: {objrepr}', source) - except ValueError: - pass - - -class NewTypeAttributeDocumenter(Documenter, - autodoc.NewTypeAttributeDocumenter): - pass - - -class PropertyDocumenter(Documenter, autodoc.PropertyDocumenter): - - def add_directive_header(self, signature): - # Add field-list options, but drop the original indentation. - super().add_directive_header(signature) - source = self.get_sourcename() - if inspect.isabstractmethod(self.object): - self.add_line(':abstractmethod:', source) - if self.isclassmethod: - self.add_line(':classmethod:', source) - if inspect.safe_getattr(self.object, 'fget', None): - func = self.object.fget - elif inspect.safe_getattr(self.object, 'func', None): - func = self.object.func - else: - func = None - if func and self.config.autodoc_typehints != 'none': - try: - signature = inspect.signature(func, - type_aliases=self.config.autodoc_type_aliases) - if signature.return_annotation is not inspect.Parameter.empty: - objrepr = stringify(signature.return_annotation) - self.add_line(f':type: {objrepr}', source) - except TypeError as exc: - logger.warning( - sphinx.locale.__('Failed to get a function signature for ' - f'{self.fullname}:{exc}'), - type='myst-docstring') - return None - except ValueError: - return None - - -class ExceptionDocumenter(Documenter, autodoc.ExceptionDocumenter): - pass - - -class DataDocumenter(Documenter, autodoc.DataDocumenter): - - def add_directive_header(self, signature): - # Add field-list options, but drop the original indentation. - super().add_directive_header(signature) - source = self.get_sourcename() - if (self.options.annotation is autodoc.SUPPRESS - or self.should_suppress_directive_header()): - pass - elif self.options.annotation: - self.add_line(f':annotation: {self.options.annotation}', source) - else: - if self.config.autodoc_typehints != 'none': - annotations = get_type_hints(self.parent, None, - self.config.autodoc_type_aliases) - if self.objpath[-1] in annotations: - objrepr = stringify(annotations.get(self.objpath[-1])) - self.add_line(f':type: {objrepr}', source) - try: - if (self.options.no_value - or self.should_suppress_value_header() - or ismock(self.object)): - pass - else: - objrepr = inspect.object_description(self.object) - # Added quotation marks to avoid errors with values - # that happen to contain curly braces. This does not - # seem to be necessary in reST, but apparently is - # in Markdown. - self.add_line(f':value: "{objrepr}"', source) - except ValueError: - pass - - -class NewTypeDataDocumenter(Documenter, autodoc.NewTypeDataDocumenter): - pass - - -def setup(app): - """ - Sets up the extension. - - Sphinx calls this function if the user named the extension in `conf.py`. - It then sets up the Autodoc extension that ships with Sphinx and - overrides whatever necessary to produce Markdown to be parsed by MyST - instead of reStructuredText parsed by Sphinx/Docutils. - """ - app.setup_extension('sphinx.ext.autodoc') - app.add_autodocumenter(ModuleDocumenter, override=True) - app.add_autodocumenter(FunctionDocumenter, override=True) - app.add_autodocumenter(DecoratorDocumenter, override=True) - app.add_autodocumenter(ClassDocumenter, override=True) - app.add_autodocumenter(MethodDocumenter, override=True) - app.add_autodocumenter(AttributeDocumenter, override=True) - app.add_autodocumenter(NewTypeAttributeDocumenter, override=True) - app.add_autodocumenter(PropertyDocumenter, override=True) - app.add_autodocumenter(ExceptionDocumenter, override=True) - app.add_autodocumenter(DataDocumenter, override=True) - app.add_autodocumenter(NewTypeDataDocumenter, override=True) - return {'version': __version__, 'parallel_read_safe': True} diff --git a/tools/docs/extensions/myst_autosummary/__init__.py b/tools/docs/extensions/myst_autosummary/__init__.py deleted file mode 100644 index 774f6dba..00000000 --- a/tools/docs/extensions/myst_autosummary/__init__.py +++ /dev/null @@ -1,198 +0,0 @@ -"""MyST-compatible drop-in replacement for Sphinx's Autosummary extension.""" -__version__ = '0.1.0' - -# This extension only overrides the Autosummary method that creates the -# summary table. The changes relative to the original code are minimal. -# Though it is possible some reST-specific content generation was -# overlooked elsewhere in Autosummary's code base. The stub generation -# was ignored. We would have to create .md files instead of .rst. - -import os -import posixpath -import re - -import docutils -from docutils import nodes - -import sphinx -from sphinx import addnodes -from sphinx.ext.autodoc.directive import DocumenterBridge, Options -from sphinx.ext import autosummary -from sphinx.ext.autodoc.mock import mock -from sphinx.locale import __ -from sphinx.util.matching import Matcher - -logger = sphinx.util.logging.getLogger(__name__) - - -class autosummary_toc(nodes.comment): - pass - - -class Autosummary(autosummary.Autosummary): - """Extends the `autosummary` directive provided by Autosummary.""" - - def run(self): - """Reimplements the run method of the parent class. - - Only one line has been changed with respect to the parent class, - indicated below. - """ - self.bridge = DocumenterBridge(self.env, self.state.document.reporter, - Options(), self.lineno, self.state) - - names = [x.strip().split()[0] for x in self.content - if x.strip() and re.search(r'^[~a-zA-Z_]', x.strip()[0])] - items = self.get_items(names) - nodes = self.get_table(items) - - if 'toctree' in self.options: - dirname = posixpath.dirname(self.env.docname) - - tree_prefix = self.options['toctree'].strip() - docnames = [] - excluded = Matcher(self.config.exclude_patterns) - filename_map = self.config.autosummary_filename_map - for _name, _sig, _summary, real_name in items: - real_name = filename_map.get(real_name, real_name) - docname = posixpath.join(tree_prefix, real_name) - docname = posixpath.normpath(posixpath.join(dirname, docname)) - if docname not in self.env.found_docs: - if excluded(self.env.doc2path(docname, False)): - msg = __('autosummary references excluded document %r. Ignored.') - else: - msg = __('autosummary: stub file not found %r. ' - 'Check your autosummary_generate setting.') - - logger.warning(msg, real_name, location=self.get_location()) - continue - - docnames.append(docname) - - if docnames: - tocnode = addnodes.toctree() - tocnode['includefiles'] = docnames - # This is the only line that is different from the parent class. - # This makes for cleaner TOC entries. - tocnode['entries'] = [(docn.split('/')[-1], docn) for docn in docnames] - tocnode['maxdepth'] = -1 - tocnode['glob'] = None - tocnode['caption'] = self.options.get('caption') - - nodes.append(autosummary_toc('', '', tocnode)) - - if 'toctree' not in self.options and 'caption' in self.options: - logger.warning(__('A captioned autosummary requires :toctree: option. ignored.'), - location=nodes[-1]) - - return nodes - - - def get_table(self, items): - """ - Reimplements the generation of the summary table. - - This new method returns Docutils nodes containing MyST-style - object references instead of standard Sphinx roles. It simply - regenerates the content. (It may also be possible to call the - method of the parent class and convert the syntax with a - regular expression after it's been generated.) - """ - table_spec = sphinx.addnodes.tabular_col_spec() - table_spec['spec'] = r'\X{1}{2}\X{1}{2}' - - table = autosummary.autosummary_table('') - real_table = docutils.nodes.table('', classes=['longtable']) - table.append(real_table) - group = docutils.nodes.tgroup('', cols=2) - real_table.append(group) - group.append(docutils.nodes.colspec('', colwidth=10)) - group.append(docutils.nodes.colspec('', colwidth=90)) - body = docutils.nodes.tbody('') - group.append(body) - - def append_row(*column_texts: str) -> None: - row = docutils.nodes.row('') - (source, line) = self.state_machine.get_source_and_line() - for text in column_texts: - node = docutils.nodes.paragraph('') - vl = docutils.statemachine.StringList() - vl.append(text, f'{source}:{line:d}:') - with sphinx.util.docutils.switch_source_input(self.state, vl): - self.state.nested_parse(vl, 0, node) - try: - if isinstance(node[0], docutils.nodes.paragraph): - node = node[0] - except IndexError: - pass - row.append(docutils.nodes.entry('', node)) - body.append(row) - - for (name, sig, summary, real_name) in items: - if 'nosignatures' not in self.options: - item = ('{py:obj}' + f'`{name} <{real_name}>`\\ ' + - sphinx.util.rst.escape(sig)) - else: - item = '{py:obj}' + f'`{name} <{real_name}>`' - append_row(item, summary) - - return [table_spec, table] - - -def get_md_suffix(app): - """Replaces `get_rst_suffix` in original `autosummary` extension.""" - return '.md' - - -def process_generate_options(app): - genfiles = app.config.autosummary_generate - - if genfiles is True: - env = app.builder.env - genfiles = [env.doc2path(x, base=None) for x in env.found_docs - if os.path.isfile(env.doc2path(x))] - elif genfiles is False: - pass - else: - ext = list(app.config.source_suffix) - genfiles = [genfile + (ext[0] if not genfile.endswith(tuple(ext)) else '') - for genfile in genfiles] - - for entry in genfiles[:]: - if not os.path.isfile(os.path.join(app.srcdir, entry)): - logger.warning(__('autosummary_generate: file not found: %s'), entry) - genfiles.remove(entry) - - if not genfiles: - return - - suffix = get_md_suffix(app) - - if suffix is None: - logger.warning(__('autosummary generats .rst files internally. ' - 'But your source_suffix does not contain .rst. Skipped.')) - return - - from extensions.myst_autosummary.generate import generate_autosummary_docs - - imported_members = app.config.autosummary_imported_members - with mock(app.config.autosummary_mock_imports): - generate_autosummary_docs(genfiles, suffix=suffix, base_path=app.srcdir, - app=app, imported_members=imported_members, - overwrite=app.config.autosummary_generate_overwrite, - encoding=app.config.source_encoding) - - -def setup(app): - """ - Sets up the extension. - - Sphinx calls this function if the user named the extension in `conf.py`. - It then sets up the Autosummary extension that ships with Sphinx and - overrides whatever necessary to produce Markdown to be parsed by MyST - instead of reStructuredText parsed by Sphinx/Docutils. - """ - app.setup_extension('sphinx.ext.autosummary') - app.add_directive('autosummary', Autosummary, override=True) - app.connect('builder-inited', process_generate_options) - return {'version': __version__, 'parallel_read_safe': True} diff --git a/tools/docs/extensions/myst_autosummary/generate.py b/tools/docs/extensions/myst_autosummary/generate.py deleted file mode 100644 index 1ac32010..00000000 --- a/tools/docs/extensions/myst_autosummary/generate.py +++ /dev/null @@ -1,657 +0,0 @@ -"""Generates reST source files for autosummary. - -Usable as a library or script to generate automatic RST source files for -items referred to in autosummary:: directives. - -Each generated RST file contains a single auto*:: directive which -extracts the docstring of the referred item. - -Example Makefile rule:: - - generate: - sphinx-autogen -o source/generated source/*.rst -""" - -import argparse -import inspect -import locale -import os -import pkgutil -import pydoc -import re -import sys -from gettext import NullTranslations -from os import path -from typing import Any, Dict, List, NamedTuple, Sequence, Set, Tuple, Type - -from jinja2 import TemplateNotFound -from jinja2.sandbox import SandboxedEnvironment - -import sphinx.locale -from sphinx import __display_version__, package_dir -from sphinx.application import Sphinx -from sphinx.builders import Builder -from sphinx.config import Config -from sphinx.ext.autodoc import Documenter -from sphinx.ext.autodoc.importer import import_module -from sphinx.ext.autosummary import (ImportExceptionGroup, get_documenter, import_by_name, - import_ivar_by_name) -from sphinx.locale import __ -from sphinx.pycode import ModuleAnalyzer, PycodeError -from sphinx.registry import SphinxComponentRegistry -from sphinx.util import logging, rst, split_full_qualified_name -from sphinx.util.inspect import getall, safe_getattr -from sphinx.util.osutil import ensuredir -from sphinx.util.template import SphinxTemplateLoader - -logger = logging.getLogger(__name__) - - -class DummyApplication: - """Dummy Application class for sphinx-autogen command.""" - - def __init__(self, translator: NullTranslations) -> None: - self.config = Config() - self.registry = SphinxComponentRegistry() - self.messagelog: List[str] = [] - self.srcdir = "/" - self.translator = translator - self.verbosity = 0 - self._warncount = 0 - self.warningiserror = False - - self.config.add('autosummary_context', {}, True, None) - self.config.add('autosummary_filename_map', {}, True, None) - self.config.add('autosummary_ignore_module_all', True, 'env', bool) - self.config.init_values() - - def emit_firstresult(self, *args: Any) -> None: - pass - - -class AutosummaryEntry(NamedTuple): - name: str - path: str - template: str - recursive: bool - - -def setup_documenters(app: Any) -> None: - from sphinx.ext.autodoc import (AttributeDocumenter, ClassDocumenter, DataDocumenter, - DecoratorDocumenter, ExceptionDocumenter, - FunctionDocumenter, MethodDocumenter, ModuleDocumenter, - NewTypeAttributeDocumenter, NewTypeDataDocumenter, - PropertyDocumenter) - documenters: List[Type[Documenter]] = [ - ModuleDocumenter, ClassDocumenter, ExceptionDocumenter, DataDocumenter, - FunctionDocumenter, MethodDocumenter, NewTypeAttributeDocumenter, - NewTypeDataDocumenter, AttributeDocumenter, DecoratorDocumenter, PropertyDocumenter, - ] - for documenter in documenters: - app.registry.add_documenter(documenter.objtype, documenter) - - -def _underline(title: str, line: str = '=') -> str: - if '\n' in title: - raise ValueError('Can only underline single lines') - return title + '\n' + line * len(title) - - -class AutosummaryRenderer: - """A helper class for rendering.""" - - def __init__(self, app: Sphinx) -> None: - if isinstance(app, Builder): - raise ValueError('Expected a Sphinx application object!') - - system_templates_path = [os.path.join(package_dir, 'ext', 'autosummary', 'templates')] - loader = SphinxTemplateLoader(app.srcdir, app.config.templates_path, - system_templates_path) - - self.env = SandboxedEnvironment(loader=loader) - self.env.filters['escape'] = rst.escape - self.env.filters['e'] = rst.escape - self.env.filters['underline'] = _underline - - if app.translator: - self.env.add_extension("jinja2.ext.i18n") - self.env.install_gettext_translations(app.translator) - - def render(self, template_name: str, context: Dict) -> str: - """Render a template file.""" - try: - template = self.env.get_template(template_name) - except TemplateNotFound: - try: - # objtype is given as template_name - template = self.env.get_template('autosummary/%s.rst' % template_name) - except TemplateNotFound: - # fallback to base.rst - template = self.env.get_template('autosummary/base.rst') - - return template.render(context) - - -# -- Generating output --------------------------------------------------------- - - -class ModuleScanner: - def __init__(self, app: Any, obj: Any) -> None: - self.app = app - self.object = obj - - def get_object_type(self, name: str, value: Any) -> str: - return get_documenter(self.app, value, self.object).objtype - - def is_skipped(self, name: str, value: Any, objtype: str) -> bool: - try: - return self.app.emit_firstresult('autodoc-skip-member', objtype, - name, value, False, {}) - except Exception as exc: - logger.warning(__('autosummary: failed to determine %r to be documented, ' - 'the following exception was raised:\n%s'), - name, exc, type='autosummary') - return False - - def scan(self, imported_members: bool) -> List[str]: - members = [] - try: - analyzer = ModuleAnalyzer.for_module(self.object.__name__) - attr_docs = analyzer.find_attr_docs() - except PycodeError: - attr_docs = {} - - for name in members_of(self.object, self.app.config): - try: - value = safe_getattr(self.object, name) - except AttributeError: - value = None - - objtype = self.get_object_type(name, value) - if self.is_skipped(name, value, objtype): - continue - - try: - if ('', name) in attr_docs: - imported = False - elif inspect.ismodule(value): - imported = True - elif safe_getattr(value, '__module__') != self.object.__name__: - imported = True - else: - imported = False - except AttributeError: - imported = False - - respect_module_all = not self.app.config.autosummary_ignore_module_all - if imported_members: - # list all members up - members.append(name) - elif imported is False: - # list not-imported members - members.append(name) - elif '__all__' in dir(self.object) and respect_module_all: - # list members that have __all__ set - members.append(name) - - return members - - -def members_of(obj: Any, conf: Config) -> Sequence[str]: - """Get the members of ``obj``, possibly ignoring the ``__all__`` module attribute - - Follows the ``conf.autosummary_ignore_module_all`` setting.""" - - if conf.autosummary_ignore_module_all: - return dir(obj) - else: - return getall(obj) or dir(obj) - - -def generate_autosummary_content(name: str, obj: Any, parent: Any, - template: AutosummaryRenderer, template_name: str, - imported_members: bool, app: Any, - recursive: bool, context: Dict, - modname: str = None, qualname: str = None) -> str: - doc = get_documenter(app, obj, parent) - - def skip_member(obj: Any, name: str, objtype: str) -> bool: - try: - return app.emit_firstresult('autodoc-skip-member', objtype, name, - obj, False, {}) - except Exception as exc: - logger.warning(__('autosummary: failed to determine %r to be documented, ' - 'the following exception was raised:\n%s'), - name, exc, type='autosummary') - return False - - def get_class_members(obj: Any) -> Dict[str, Any]: - members = sphinx.ext.autodoc.get_class_members(obj, [qualname], safe_getattr) - return {name: member.object for name, member in members.items()} - - def get_module_members(obj: Any) -> Dict[str, Any]: - members = {} - for name in members_of(obj, app.config): - try: - members[name] = safe_getattr(obj, name) - except AttributeError: - continue - return members - - def get_all_members(obj: Any) -> Dict[str, Any]: - if doc.objtype == "module": - return get_module_members(obj) - elif doc.objtype == "class": - return get_class_members(obj) - return {} - - def get_members(obj: Any, types: Set[str], include_public: List[str] = [], - imported: bool = True) -> Tuple[List[str], List[str]]: - items: List[str] = [] - public: List[str] = [] - - all_members = get_all_members(obj) - for name, value in all_members.items(): - documenter = get_documenter(app, value, obj) - if documenter.objtype in types: - # skip imported members if expected - if imported or getattr(value, '__module__', None) == obj.__name__: - skipped = skip_member(value, name, documenter.objtype) - if skipped is True: - pass - elif skipped is False: - # show the member forcedly - items.append(name) - public.append(name) - else: - items.append(name) - if name in include_public or not name.startswith('_'): - # considers member as public - public.append(name) - return public, items - - def get_module_attrs(members: Any) -> Tuple[List[str], List[str]]: - """Find module attributes with docstrings.""" - attrs, public = [], [] - try: - analyzer = ModuleAnalyzer.for_module(name) - attr_docs = analyzer.find_attr_docs() - for namespace, attr_name in attr_docs: - if namespace == '' and attr_name in members: - attrs.append(attr_name) - if not attr_name.startswith('_'): - public.append(attr_name) - except PycodeError: - pass # give up if ModuleAnalyzer fails to parse code - return public, attrs - - def get_modules(obj: Any) -> Tuple[List[str], List[str]]: - items: List[str] = [] - for _, modname, _ispkg in pkgutil.iter_modules(obj.__path__): - fullname = name + '.' + modname - try: - module = import_module(fullname) - if module and hasattr(module, '__sphinx_mock__'): - continue - except ImportError: - pass - - items.append(fullname) - public = [x for x in items if not x.split('.')[-1].startswith('_')] - return public, items - - ns: Dict[str, Any] = {} - ns.update(context) - - if doc.objtype == 'module': - scanner = ModuleScanner(app, obj) - ns['members'] = scanner.scan(imported_members) - ns['functions'], ns['all_functions'] = \ - get_members(obj, {'function'}, imported=imported_members) - ns['classes'], ns['all_classes'] = \ - get_members(obj, {'class'}, imported=imported_members) - ns['exceptions'], ns['all_exceptions'] = \ - get_members(obj, {'exception'}, imported=imported_members) - ns['attributes'], ns['all_attributes'] = \ - get_module_attrs(ns['members']) - ispackage = hasattr(obj, '__path__') - if ispackage and recursive: - ns['modules'], ns['all_modules'] = get_modules(obj) - elif doc.objtype == 'class': - ns['members'] = dir(obj) - ns['inherited_members'] = \ - set(dir(obj)) - set(obj.__dict__.keys()) - ns['methods'], ns['all_methods'] = \ - get_members(obj, {'method'}, ['__init__']) - ns['attributes'], ns['all_attributes'] = \ - get_members(obj, {'attribute', 'property'}) - - if modname is None or qualname is None: - modname, qualname = split_full_qualified_name(name) - - if doc.objtype in ('method', 'attribute', 'property'): - ns['class'] = qualname.rsplit(".", 1)[0] - - if doc.objtype in ('class',): - shortname = qualname - else: - shortname = qualname.rsplit(".", 1)[-1] - - ns['fullname'] = name - ns['module'] = modname - ns['objname'] = qualname - ns['name'] = shortname - - ns['objtype'] = doc.objtype - ns['underline'] = len(name) * '=' - - if template_name: - return template.render(template_name, ns) - else: - return template.render(doc.objtype, ns) - - -def generate_autosummary_docs(sources: List[str], output_dir: str = None, - suffix: str = '.rst', base_path: str = None, - imported_members: bool = False, app: Any = None, - overwrite: bool = True, encoding: str = 'utf-8') -> None: - showed_sources = sorted(sources) - if len(showed_sources) > 20: - showed_sources = showed_sources[:10] + ['...'] + showed_sources[-10:] - logger.info(__('[autosummary] generating autosummary for: %s') % - ', '.join(showed_sources)) - - if output_dir: - logger.info(__('[autosummary] writing to %s') % output_dir) - - if base_path is not None: - sources = [os.path.join(base_path, filename) for filename in sources] - - template = AutosummaryRenderer(app) - - # read - items = find_autosummary_in_files(sources) - - # keep track of new files - new_files = [] - - if app: - filename_map = app.config.autosummary_filename_map - else: - filename_map = {} - - # write - for entry in sorted(set(items), key=str): - if entry.path is None: - # The corresponding autosummary:: directive did not have - # a :toctree: option - continue - - path = output_dir or os.path.abspath(entry.path) - ensuredir(path) - - try: - name, obj, parent, modname = import_by_name(entry.name) - qualname = name.replace(modname + ".", "") - except ImportExceptionGroup as exc: - try: - # try to import as an instance attribute - name, obj, parent, modname = import_ivar_by_name(entry.name) - qualname = name.replace(modname + ".", "") - except ImportError as exc2: - if exc2.__cause__: - exceptions: List[BaseException] = exc.exceptions + [exc2.__cause__] - else: - exceptions = exc.exceptions + [exc2] - - errors = list({"* %s: %s" % (type(e).__name__, e) for e in exceptions}) - logger.warning(__('[autosummary] failed to import %s.\nPossible hints:\n%s'), - entry.name, '\n'.join(errors)) - continue - - context: Dict[str, Any] = {} - if app: - context.update(app.config.autosummary_context) - - content = generate_autosummary_content(name, obj, parent, template, entry.template, - imported_members, app, entry.recursive, context, - modname, qualname) - - filename = os.path.join(path, filename_map.get(name, name) + suffix) - if os.path.isfile(filename): - with open(filename, encoding=encoding) as f: - old_content = f.read() - - if content == old_content: - continue - elif overwrite: # content has changed - with open(filename, 'w', encoding=encoding) as f: - f.write(content) - new_files.append(filename) - else: - with open(filename, 'w', encoding=encoding) as f: - f.write(content) - new_files.append(filename) - - # descend recursively to new files - if new_files: - generate_autosummary_docs(new_files, output_dir=output_dir, - suffix=suffix, base_path=base_path, - imported_members=imported_members, app=app, - overwrite=overwrite) - - -# -- Finding documented entries in files --------------------------------------- - -def find_autosummary_in_files(filenames: List[str]) -> List[AutosummaryEntry]: - """Find out what items are documented in source/*.rst. - - See `find_autosummary_in_lines`. - """ - documented: List[AutosummaryEntry] = [] - for filename in filenames: - with open(filename, encoding='utf-8', errors='ignore') as f: - lines = f.read().splitlines() - documented.extend(find_autosummary_in_lines(lines, filename=filename)) - return documented - - -def find_autosummary_in_docstring(name: str, filename: str = None) -> List[AutosummaryEntry]: - """Find out what items are documented in the given object's docstring. - - See `find_autosummary_in_lines`. - """ - try: - real_name, obj, parent, modname = import_by_name(name) - lines = pydoc.getdoc(obj).splitlines() - return find_autosummary_in_lines(lines, module=name, filename=filename) - except AttributeError: - pass - except ImportExceptionGroup as exc: - errors = list({"* %s: %s" % (type(e).__name__, e) for e in exc.exceptions}) - print('Failed to import %s.\nPossible hints:\n%s' % (name, '\n'.join(errors))) - except SystemExit: - print("Failed to import '%s'; the module executes module level " - "statement and it might call sys.exit()." % name) - return [] - - -def find_autosummary_in_lines(lines: List[str], module: str = None, filename: str = None - ) -> List[AutosummaryEntry]: - """Find out what items appear in autosummary:: directives in the - given lines. - - Returns a list of (name, toctree, template) where *name* is a name - of an object and *toctree* the :toctree: path of the corresponding - autosummary directive (relative to the root of the file name), and - *template* the value of the :template: option. *toctree* and - *template* ``None`` if the directive does not have the - corresponding options set. - """ - # jmontalt: Changed regexes to support MyST syntax. - autosummary_re = re.compile(r'^(\s*)```{autosummary}\s*') - automodule_re = re.compile( - r'^\s*```{automodule}\s*([A-Za-z0-9_.]+)\s*$') - module_re = re.compile( - r'^\s*```{(current)?module}\s*([a-zA-Z0-9_.]+)\s*$') - autosummary_item_re = re.compile(r'^\s*(~?[_a-zA-Z][a-zA-Z0-9_.]*)\s*.*?') - recursive_arg_re = re.compile(r'^\s*recursive:\s*$') - toctree_arg_re = re.compile(r'^\s*toctree:\s*(.*?)\s*$') - template_arg_re = re.compile(r'^\s*template:\s*(.*?)\s*$') - topmatter_re = re.compile(r'^\s*-{3,}\s*$') - - documented: List[AutosummaryEntry] = [] - - recursive = False - toctree: str = None - template = None - current_module = module - in_autosummary = False - in_topmatter = False - base_indent = "" - - for line in lines: - if in_autosummary: - # jmontalt: Added topmatter processing for MyST syntax. - if in_topmatter: - # jmontalt: Added topmatter processing for MyST syntax. - m = topmatter_re.match(line) - if m: - in_topmatter = False - continue - - m = recursive_arg_re.match(line) - if m: - recursive = True - continue - - m = toctree_arg_re.match(line) - if m: - toctree = m.group(1) - if filename: - toctree = os.path.join(os.path.dirname(filename), - toctree) - continue - - m = template_arg_re.match(line) - if m: - template = m.group(1).strip() - continue - - continue # skip options - - # jmontalt: Added topmatter processing for MyST syntax. - m = topmatter_re.match(line) - if m: - in_topmatter = True - continue - - m = autosummary_item_re.match(line) - if m: - name = m.group(1).strip() - if name.startswith('~'): - name = name[1:] - if current_module and \ - not name.startswith(current_module + '.'): - name = "%s.%s" % (current_module, name) - documented.append(AutosummaryEntry(name, toctree, template, recursive)) - continue - - if not line.strip() or line.startswith(base_indent + " "): - continue - - in_autosummary = False - - m = autosummary_re.match(line) - if m: - in_autosummary = True - base_indent = m.group(1) - recursive = False - toctree = None - template = None - continue - - m = automodule_re.search(line) - if m: - current_module = m.group(1).strip() - # recurse into the automodule docstring - documented.extend(find_autosummary_in_docstring( - current_module, filename=filename)) - continue - - m = module_re.match(line) - if m: - current_module = m.group(2) - continue - - return documented - - -def get_parser() -> argparse.ArgumentParser: - parser = argparse.ArgumentParser( - usage='%(prog)s [OPTIONS] ...', - epilog=__('For more information, visit .'), - description=__(""" -Generate ReStructuredText using autosummary directives. - -sphinx-autogen is a frontend to sphinx.ext.autosummary.generate. It generates -the reStructuredText files from the autosummary directives contained in the -given input files. - -The format of the autosummary directive is documented in the -``sphinx.ext.autosummary`` Python module and can be read using:: - - pydoc sphinx.ext.autosummary -""")) - - parser.add_argument('--version', action='version', dest='show_version', - version='%%(prog)s %s' % __display_version__) - - parser.add_argument('source_file', nargs='+', - help=__('source files to generate rST files for')) - - parser.add_argument('-o', '--output-dir', action='store', - dest='output_dir', - help=__('directory to place all output in')) - parser.add_argument('-s', '--suffix', action='store', dest='suffix', - default='rst', - help=__('default suffix for files (default: ' - '%(default)s)')) - parser.add_argument('-t', '--templates', action='store', dest='templates', - default=None, - help=__('custom template directory (default: ' - '%(default)s)')) - parser.add_argument('-i', '--imported-members', action='store_true', - dest='imported_members', default=False, - help=__('document imported members (default: ' - '%(default)s)')) - parser.add_argument('-a', '--respect-module-all', action='store_true', - dest='respect_module_all', default=False, - help=__('document exactly the members in module __all__ attribute. ' - '(default: %(default)s)')) - - return parser - - -def main(argv: List[str] = sys.argv[1:]) -> None: - sphinx.locale.setlocale(locale.LC_ALL, '') - sphinx.locale.init_console(os.path.join(package_dir, 'locale'), 'sphinx') - translator, _ = sphinx.locale.init([], None) - - app = DummyApplication(translator) - logging.setup(app, sys.stdout, sys.stderr) # type: ignore - setup_documenters(app) - args = get_parser().parse_args(argv) - - if args.templates: - app.config.templates_path.append(path.abspath(args.templates)) - app.config.autosummary_ignore_module_all = not args.respect_module_all # type: ignore - - generate_autosummary_docs(args.source_file, args.output_dir, - '.' + args.suffix, - imported_members=args.imported_members, - app=app) - - -if __name__ == '__main__': - main() diff --git a/tools/docs/extensions/myst_napoleon/__init__.py b/tools/docs/extensions/myst_napoleon/__init__.py deleted file mode 100644 index f3dd770a..00000000 --- a/tools/docs/extensions/myst_napoleon/__init__.py +++ /dev/null @@ -1,479 +0,0 @@ -"""Support for NumPy and Google style docstrings.""" -# This code is copied from `sphinx.ext.napoleon` v5.1.1. Any changes have -# been labelled with `jmontalt`. - -from typing import Any, Dict, List - -from sphinx import __display_version__ as __version__ -from sphinx.application import Sphinx -from myst_napoleon.docstring import GoogleDocstring, NumpyDocstring -from sphinx.util import inspect - - -class Config: - """Sphinx napoleon extension settings in `conf.py`. - - Listed below are all the settings used by napoleon and their default - values. These settings can be changed in the Sphinx `conf.py` file. Make - sure that "myst_napoleon" is enabled in `conf.py`:: - - # conf.py - - # Add any Sphinx extension module names here, as strings - extensions = ['myst_napoleon'] - - # Napoleon settings - napoleon_google_docstring = True - napoleon_numpy_docstring = True - napoleon_include_init_with_doc = False - napoleon_include_private_with_doc = False - napoleon_include_special_with_doc = False - napoleon_use_admonition_for_examples = False - napoleon_use_admonition_for_notes = False - napoleon_use_admonition_for_references = False - napoleon_use_ivar = False - napoleon_use_param = True - napoleon_use_rtype = True - napoleon_use_keyword = True - napoleon_preprocess_types = False - napoleon_type_aliases = None - napoleon_custom_sections = None - napoleon_attr_annotations = True - - .. _Google style: - https://google.github.io/styleguide/pyguide.html - .. _NumPy style: - https://numpydoc.readthedocs.io/en/latest/format.html#docstring-standard - - Attributes - ---------- - napoleon_google_docstring : :obj:`bool` (Defaults to True) - True to parse `Google style`_ docstrings. False to disable support - for Google style docstrings. - napoleon_numpy_docstring : :obj:`bool` (Defaults to True) - True to parse `NumPy style`_ docstrings. False to disable support - for NumPy style docstrings. - napoleon_include_init_with_doc : :obj:`bool` (Defaults to False) - True to list ``__init___`` docstrings separately from the class - docstring. False to fall back to Sphinx's default behavior, which - considers the ``__init___`` docstring as part of the class - documentation. - - **If True**:: - - def __init__(self): - \"\"\" - This will be included in the docs because it has a docstring - \"\"\" - - def __init__(self): - # This will NOT be included in the docs - - napoleon_include_private_with_doc : :obj:`bool` (Defaults to False) - True to include private members (like ``_membername``) with docstrings - in the documentation. False to fall back to Sphinx's default behavior. - - **If True**:: - - def _included(self): - \"\"\" - This will be included in the docs because it has a docstring - \"\"\" - pass - - def _skipped(self): - # This will NOT be included in the docs - pass - - napoleon_include_special_with_doc : :obj:`bool` (Defaults to False) - True to include special members (like ``__membername__``) with - docstrings in the documentation. False to fall back to Sphinx's - default behavior. - - **If True**:: - - def __str__(self): - \"\"\" - This will be included in the docs because it has a docstring - \"\"\" - return unicode(self).encode('utf-8') - - def __unicode__(self): - # This will NOT be included in the docs - return unicode(self.__class__.__name__) - - napoleon_use_admonition_for_examples : :obj:`bool` (Defaults to False) - True to use the ``.. admonition::`` directive for the **Example** and - **Examples** sections. False to use the ``.. rubric::`` directive - instead. One may look better than the other depending on what HTML - theme is used. - - This `NumPy style`_ snippet will be converted as follows:: - - Example - ------- - This is just a quick example - - **If True**:: - - .. admonition:: Example - - This is just a quick example - - **If False**:: - - .. rubric:: Example - - This is just a quick example - - napoleon_use_admonition_for_notes : :obj:`bool` (Defaults to False) - True to use the ``.. admonition::`` directive for **Notes** sections. - False to use the ``.. rubric::`` directive instead. - - Note - ---- - The singular **Note** section will always be converted to a - ``.. note::`` directive. - - See Also - -------- - :attr:`napoleon_use_admonition_for_examples` - - napoleon_use_admonition_for_references : :obj:`bool` (Defaults to False) - True to use the ``.. admonition::`` directive for **References** - sections. False to use the ``.. rubric::`` directive instead. - - See Also - -------- - :attr:`napoleon_use_admonition_for_examples` - - napoleon_use_ivar : :obj:`bool` (Defaults to False) - True to use the ``:ivar:`` role for instance variables. False to use - the ``.. attribute::`` directive instead. - - This `NumPy style`_ snippet will be converted as follows:: - - Attributes - ---------- - attr1 : int - Description of `attr1` - - **If True**:: - - :ivar attr1: Description of `attr1` - :vartype attr1: int - - **If False**:: - - .. attribute:: attr1 - - Description of `attr1` - - :type: int - - napoleon_use_param : :obj:`bool` (Defaults to True) - True to use a ``:param:`` role for each function parameter. False to - use a single ``:parameters:`` role for all the parameters. - - This `NumPy style`_ snippet will be converted as follows:: - - Parameters - ---------- - arg1 : str - Description of `arg1` - arg2 : int, optional - Description of `arg2`, defaults to 0 - - **If True**:: - - :param arg1: Description of `arg1` - :type arg1: str - :param arg2: Description of `arg2`, defaults to 0 - :type arg2: int, optional - - **If False**:: - - :parameters: * **arg1** (*str*) -- - Description of `arg1` - * **arg2** (*int, optional*) -- - Description of `arg2`, defaults to 0 - - napoleon_use_keyword : :obj:`bool` (Defaults to True) - True to use a ``:keyword:`` role for each function keyword argument. - False to use a single ``:keyword arguments:`` role for all the - keywords. - - This behaves similarly to :attr:`napoleon_use_param`. Note unlike - docutils, ``:keyword:`` and ``:param:`` will not be treated the same - way - there will be a separate "Keyword Arguments" section, rendered - in the same fashion as "Parameters" section (type links created if - possible) - - See Also - -------- - :attr:`napoleon_use_param` - - napoleon_use_rtype : :obj:`bool` (Defaults to True) - True to use the ``:rtype:`` role for the return type. False to output - the return type inline with the description. - - This `NumPy style`_ snippet will be converted as follows:: - - Returns - ------- - bool - True if successful, False otherwise - - **If True**:: - - :returns: True if successful, False otherwise - :rtype: bool - - **If False**:: - - :returns: *bool* -- True if successful, False otherwise - - napoleon_preprocess_types : :obj:`bool` (Defaults to False) - Enable the type preprocessor. - - napoleon_type_aliases : :obj:`dict` (Defaults to None) - Add a mapping of strings to string, translating types in numpy - style docstrings. Only works if ``napoleon_preprocess_types = True``. - - napoleon_custom_sections : :obj:`list` (Defaults to None) - Add a list of custom sections to include, expanding the list of parsed sections. - - The entries can either be strings or tuples, depending on the intention: - * To create a custom "generic" section, just pass a string. - * To create an alias for an existing section, pass a tuple containing the - alias name and the original, in that order. - * To create a custom section that displays like the parameters or returns - section, pass a tuple containing the custom section name and a string - value, "params_style" or "returns_style". - - If an entry is just a string, it is interpreted as a header for a generic - section. If the entry is a tuple/list/indexed container, the first entry - is the name of the section, the second is the section key to emulate. If the - second entry value is "params_style" or "returns_style", the custom section - will be displayed like the parameters section or returns section. - - napoleon_attr_annotations : :obj:`bool` (Defaults to True) - Use the type annotations of class attributes that are documented in the docstring - but do not have a type in the docstring. - - """ - _config_values = { - 'napoleon_google_docstring': (True, 'env'), - 'napoleon_numpy_docstring': (True, 'env'), - 'napoleon_include_init_with_doc': (False, 'env'), - 'napoleon_include_private_with_doc': (False, 'env'), - 'napoleon_include_special_with_doc': (False, 'env'), - 'napoleon_use_admonition_for_examples': (False, 'env'), - 'napoleon_use_admonition_for_notes': (False, 'env'), - 'napoleon_use_admonition_for_references': (False, 'env'), - 'napoleon_use_ivar': (False, 'env'), - 'napoleon_use_param': (True, 'env'), - 'napoleon_use_rtype': (True, 'env'), - 'napoleon_use_keyword': (True, 'env'), - 'napoleon_preprocess_types': (False, 'env'), - 'napoleon_type_aliases': (None, 'env'), - 'napoleon_custom_sections': (None, 'env'), - 'napoleon_attr_annotations': (True, 'env'), - } - - def __init__(self, **settings: Any) -> None: - for name, (default, _rebuild) in self._config_values.items(): - setattr(self, name, default) - for name, value in settings.items(): - setattr(self, name, value) - - -def setup(app: Sphinx) -> Dict[str, Any]: - """Sphinx extension setup function. - - When the extension is loaded, Sphinx imports this module and executes - the ``setup()`` function, which in turn notifies Sphinx of everything - the extension offers. - - Parameters - ---------- - app : sphinx.application.Sphinx - Application object representing the Sphinx process - - See Also - -------- - `The Sphinx documentation on Extensions - `_ - - `The Extension Tutorial `_ - - `The Extension API `_ - - """ - if not isinstance(app, Sphinx): - # probably called by tests - return {'version': __version__, 'parallel_read_safe': True} - - _patch_python_domain() - - app.setup_extension('sphinx.ext.autodoc') - app.connect('autodoc-process-docstring', _process_docstring) - app.connect('autodoc-skip-member', _skip_member) - - for name, (default, rebuild) in Config._config_values.items(): - app.add_config_value(name, default, rebuild) - return {'version': __version__, 'parallel_read_safe': True} - - -def _patch_python_domain() -> None: - try: - from sphinx.domains.python import PyTypedField - except ImportError: - pass - else: - import sphinx.domains.python - from sphinx.locale import _ - for doc_field in sphinx.domains.python.PyObject.doc_field_types: - if doc_field.name == 'parameter': - doc_field.names = ('param', 'parameter', 'arg', 'argument') - break - sphinx.domains.python.PyObject.doc_field_types.append( - PyTypedField('keyword', label=_('Keyword Arguments'), - names=('keyword', 'kwarg', 'kwparam'), - typerolename='obj', typenames=('paramtype', 'kwtype'), - can_collapse=True)) - - -def _process_docstring(app: Sphinx, what: str, name: str, obj: Any, - options: Any, lines: List[str]) -> None: - """Process the docstring for a given python object. - - Called when autodoc has read and processed a docstring. `lines` is a list - of docstring lines that `_process_docstring` modifies in place to change - what Sphinx outputs. - - The following settings in conf.py control what styles of docstrings will - be parsed: - - * ``napoleon_google_docstring`` -- parse Google style docstrings - * ``napoleon_numpy_docstring`` -- parse NumPy style docstrings - - Parameters - ---------- - app : sphinx.application.Sphinx - Application object representing the Sphinx process. - what : str - A string specifying the type of the object to which the docstring - belongs. Valid values: "module", "class", "exception", "function", - "method", "attribute". - name : str - The fully qualified name of the object. - obj : module, class, exception, function, method, or attribute - The object to which the docstring belongs. - options : sphinx.ext.autodoc.Options - The options given to the directive: an object with attributes - inherited_members, undoc_members, show_inheritance and noindex that - are True if the flag option of same name was given to the auto - directive. - lines : list of str - The lines of the docstring, see above. - - .. note:: `lines` is modified *in place* - - """ - result_lines = lines - docstring: GoogleDocstring = None - if app.config.napoleon_numpy_docstring: - docstring = NumpyDocstring(result_lines, app.config, app, what, name, - obj, options) - result_lines = docstring.lines() - if app.config.napoleon_google_docstring: - docstring = GoogleDocstring(result_lines, app.config, app, what, name, - obj, options) - result_lines = docstring.lines() - lines[:] = result_lines[:] - - -def _skip_member(app: Sphinx, what: str, name: str, obj: Any, - skip: bool, options: Any) -> bool: - """Determine if private and special class members are included in docs. - - The following settings in conf.py determine if private and special class - members or init methods are included in the generated documentation: - - * ``napoleon_include_init_with_doc`` -- - include init methods if they have docstrings - * ``napoleon_include_private_with_doc`` -- - include private members if they have docstrings - * ``napoleon_include_special_with_doc`` -- - include special members if they have docstrings - - Parameters - ---------- - app : sphinx.application.Sphinx - Application object representing the Sphinx process - what : str - A string specifying the type of the object to which the member - belongs. Valid values: "module", "class", "exception", "function", - "method", "attribute". - name : str - The name of the member. - obj : module, class, exception, function, method, or attribute. - For example, if the member is the __init__ method of class A, then - `obj` will be `A.__init__`. - skip : bool - A boolean indicating if autodoc will skip this member if `_skip_member` - does not override the decision - options : sphinx.ext.autodoc.Options - The options given to the directive: an object with attributes - inherited_members, undoc_members, show_inheritance and noindex that - are True if the flag option of same name was given to the auto - directive. - - Returns - ------- - bool - True if the member should be skipped during creation of the docs, - False if it should be included in the docs. - - """ - has_doc = getattr(obj, '__doc__', False) - is_member = what in ('class', 'exception', 'module') - if name != '__weakref__' and has_doc and is_member: - cls_is_owner = False - if what in ('class', 'exception'): - qualname = getattr(obj, '__qualname__', '') - cls_path, _, _ = qualname.rpartition('.') - if cls_path: - try: - if '.' in cls_path: - import functools - import importlib - - mod = importlib.import_module(obj.__module__) - mod_path = cls_path.split('.') - cls = functools.reduce(getattr, mod_path, mod) - else: - cls = inspect.unwrap(obj).__globals__[cls_path] - except Exception: - cls_is_owner = False - else: - cls_is_owner = (cls and hasattr(cls, name) and # type: ignore - name in cls.__dict__) - else: - cls_is_owner = False - - if what == 'module' or cls_is_owner: - is_init = (name == '__init__') - is_special = (not is_init and name.startswith('__') and - name.endswith('__')) - is_private = (not is_init and not is_special and - name.startswith('_')) - inc_init = app.config.napoleon_include_init_with_doc - inc_special = app.config.napoleon_include_special_with_doc - inc_private = app.config.napoleon_include_private_with_doc - if ((is_special and inc_special) or - (is_private and inc_private) or - (is_init and inc_init)): - return False - return None diff --git a/tools/docs/extensions/myst_napoleon/docstring.py b/tools/docs/extensions/myst_napoleon/docstring.py deleted file mode 100644 index f80b2b8c..00000000 --- a/tools/docs/extensions/myst_napoleon/docstring.py +++ /dev/null @@ -1,1357 +0,0 @@ -"""Classes for docstring parsing and formatting.""" -# This code is copied from `sphinx.ext.napoleon` v5.1.1. Any changes have -# been labelled with `jmontalt`. - -import collections -import inspect -import re -import warnings -from functools import partial -from typing import Any, Callable, Dict, List, Tuple, Type, Union - -from sphinx.application import Sphinx -from sphinx.config import Config as SphinxConfig -from sphinx.deprecation import RemovedInSphinx60Warning -from sphinx.locale import _, __ -from sphinx.util import logging -from sphinx.util.inspect import stringify_annotation -from sphinx.util.typing import get_type_hints - -logger = logging.getLogger(__name__) - -_directive_regex = re.compile(r'\.\. \S+::') -_google_section_regex = re.compile(r'^(\s|\w)+:\s*$') -_google_typed_arg_regex = re.compile(r'(.+?)\(\s*(.*[^\s]+)\s*\)') -_numpy_section_regex = re.compile(r'^[=\-`:\'"~^_*+#<>]{2,}\s*$') -_single_colon_regex = re.compile(r'(?\()?' - r'(\d+|#|[ivxlcdm]+|[IVXLCDM]+|[a-zA-Z])' - r'(?(paren)\)|\.)(\s+\S|\s*$)') -_token_regex = re.compile( - r"(,\sor\s|\sor\s|\sof\s|:\s|\sto\s|,\sand\s|\sand\s|,\s" - r"|[{]|[}]" - r'|"(?:\\"|[^"])*"' - r"|'(?:\\'|[^'])*')" -) -_default_regex = re.compile( - r"^default[^_0-9A-Za-z].*$", -) -_SINGLETONS = ("None", "True", "False", "Ellipsis") - - -class Deque(collections.deque): - """ - A subclass of deque that mimics ``pockets.iterators.modify_iter``. - - The `.Deque.get` and `.Deque.next` methods are added. - """ - - sentinel = object() - - def get(self, n: int) -> Any: - """ - Return the nth element of the stack, or ``self.sentinel`` if n is - greater than the stack size. - """ - return self[n] if n < len(self) else self.sentinel - - def next(self) -> Any: - if self: - return super().popleft() - else: - raise StopIteration - - -def _convert_type_spec(_type: str, translations: Dict[str, str] = {}) -> str: - """Convert type specification to reference in reST.""" - if _type in translations: - return translations[_type] - else: - if _type == 'None': - return ':obj:`None`' - else: - return ':class:`%s`' % _type - - return _type - - -class GoogleDocstring: - """Convert Google style docstrings to reStructuredText. - - Parameters - ---------- - docstring : :obj:`str` or :obj:`list` of :obj:`str` - The docstring to parse, given either as a string or split into - individual lines. - config: :obj:`myst_napoleon.Config` or :obj:`sphinx.config.Config` - The configuration settings to use. If not given, defaults to the - config object on `app`; or if `app` is not given defaults to the - a new :class:`myst_napoleon.Config` object. - - - Other Parameters - ---------------- - app : :class:`sphinx.application.Sphinx`, optional - Application object representing the Sphinx process. - what : :obj:`str`, optional - A string specifying the type of the object to which the docstring - belongs. Valid values: "module", "class", "exception", "function", - "method", "attribute". - name : :obj:`str`, optional - The fully qualified name of the object. - obj : module, class, exception, function, method, or attribute - The object to which the docstring belongs. - options : :class:`sphinx.ext.autodoc.Options`, optional - The options given to the directive: an object with attributes - inherited_members, undoc_members, show_inheritance and noindex that - are True if the flag option of same name was given to the auto - directive. - - - Example - ------- - >>> from myst_napoleon import Config - >>> config = Config(napoleon_use_param=True, napoleon_use_rtype=True) - >>> docstring = '''One line summary. - ... - ... Extended description. - ... - ... Args: - ... arg1(int): Description of `arg1` - ... arg2(str): Description of `arg2` - ... Returns: - ... str: Description of return value. - ... ''' - >>> print(GoogleDocstring(docstring, config)) - One line summary. - - Extended description. - - :param arg1: Description of `arg1` - :type arg1: int - :param arg2: Description of `arg2` - :type arg2: str - - :returns: Description of return value. - :rtype: str - - - """ - - _name_rgx = re.compile(r"^\s*((?::(?P\S+):)?`(?P~?[a-zA-Z0-9_.-]+)`|" - r" (?P~?[a-zA-Z0-9_.-]+))\s*", re.X) - - def __init__(self, docstring: Union[str, List[str]], config: SphinxConfig = None, - app: Sphinx = None, what: str = '', name: str = '', - obj: Any = None, options: Any = None) -> None: - self._config = config - self._app = app - - if not self._config: - from myst_napoleon import Config - self._config = self._app.config if self._app else Config() # type: ignore - - if not what: - if inspect.isclass(obj): - what = 'class' - elif inspect.ismodule(obj): - what = 'module' - elif callable(obj): - what = 'function' - else: - what = 'object' - - self._what = what - self._name = name - self._obj = obj - self._opt = options - if isinstance(docstring, str): - lines = docstring.splitlines() - else: - lines = docstring - self._lines = Deque(map(str.rstrip, lines)) - self._parsed_lines: List[str] = [] - self._is_in_section = False - self._section_indent = 0 - if not hasattr(self, '_directive_sections'): - self._directive_sections: List[str] = [] - if not hasattr(self, '_sections'): - self._sections: Dict[str, Callable] = { - 'args': self._parse_parameters_section, - 'arguments': self._parse_parameters_section, - 'attention': partial(self._parse_admonition, 'attention'), - 'attributes': self._parse_attributes_section, - 'caution': partial(self._parse_admonition, 'caution'), - 'danger': partial(self._parse_admonition, 'danger'), - 'error': partial(self._parse_admonition, 'error'), - 'example': self._parse_examples_section, - 'examples': self._parse_examples_section, - 'hint': partial(self._parse_admonition, 'hint'), - 'important': partial(self._parse_admonition, 'important'), - 'keyword args': self._parse_keyword_arguments_section, - 'keyword arguments': self._parse_keyword_arguments_section, - 'methods': self._parse_methods_section, - 'note': partial(self._parse_admonition, 'note'), - 'notes': self._parse_notes_section, - 'other parameters': self._parse_other_parameters_section, - 'parameters': self._parse_parameters_section, - 'receive': self._parse_receives_section, - 'receives': self._parse_receives_section, - 'return': self._parse_returns_section, - 'returns': self._parse_returns_section, - 'raise': self._parse_raises_section, - 'raises': self._parse_raises_section, - 'references': self._parse_references_section, - 'see also': self._parse_see_also_section, - 'tip': partial(self._parse_admonition, 'tip'), - 'todo': partial(self._parse_admonition, 'todo'), - 'warning': partial(self._parse_admonition, 'warning'), - 'warnings': partial(self._parse_admonition, 'warning'), - 'warn': self._parse_warns_section, - 'warns': self._parse_warns_section, - 'yield': self._parse_yields_section, - 'yields': self._parse_yields_section, - } - - self._load_custom_sections() - - self._parse() - - def __str__(self) -> str: - """Return the parsed docstring in reStructuredText format. - - Returns - ------- - unicode - Unicode version of the docstring. - - """ - return '\n'.join(self.lines()) - - def lines(self) -> List[str]: - """Return the parsed lines of the docstring in reStructuredText format. - - Returns - ------- - list(str) - The lines of the docstring in a list. - - """ - return self._parsed_lines - - def _consume_indented_block(self, indent: int = 1) -> List[str]: - lines = [] - line = self._lines.get(0) - while(not self._is_section_break() and - (not line or self._is_indented(line, indent))): - lines.append(self._lines.next()) - line = self._lines.get(0) - return lines - - def _consume_contiguous(self) -> List[str]: - lines = [] - while (self._lines and - self._lines.get(0) and - not self._is_section_header()): - lines.append(self._lines.next()) - return lines - - def _consume_empty(self) -> List[str]: - lines = [] - line = self._lines.get(0) - while self._lines and not line: - lines.append(self._lines.next()) - line = self._lines.get(0) - return lines - - def _consume_field(self, parse_type: bool = True, prefer_type: bool = False - ) -> Tuple[str, str, List[str]]: - line = self._lines.next() - - before, colon, after = self._partition_field_on_colon(line) - _name, _type, _desc = before, '', after - - if parse_type: - match = _google_typed_arg_regex.match(before) - if match: - _name = match.group(1).strip() - _type = match.group(2) - - _name = self._escape_args_and_kwargs(_name) - - if prefer_type and not _type: - _type, _name = _name, _type - - if _type and self._config.napoleon_preprocess_types: - _type = _convert_type_spec(_type, self._config.napoleon_type_aliases or {}) - - indent = self._get_indent(line) + 1 - _descs = [_desc] + self._dedent(self._consume_indented_block(indent)) - _descs = self.__class__(_descs, self._config).lines() - return _name, _type, _descs - - def _consume_fields(self, parse_type: bool = True, prefer_type: bool = False, - multiple: bool = False) -> List[Tuple[str, str, List[str]]]: - self._consume_empty() - fields = [] - while not self._is_section_break(): - _name, _type, _desc = self._consume_field(parse_type, prefer_type) - if multiple and _name: - for name in _name.split(","): - fields.append((name.strip(), _type, _desc)) - elif _name or _type or _desc: - fields.append((_name, _type, _desc,)) - return fields - - def _consume_inline_attribute(self) -> Tuple[str, List[str]]: - line = self._lines.next() - _type, colon, _desc = self._partition_field_on_colon(line) - if not colon or not _desc: - _type, _desc = _desc, _type - _desc += colon - _descs = [_desc] + self._dedent(self._consume_to_end()) - _descs = self.__class__(_descs, self._config).lines() - return _type, _descs - - def _consume_returns_section(self, preprocess_types: bool = False - ) -> List[Tuple[str, str, List[str]]]: - lines = self._dedent(self._consume_to_next_section()) - if lines: - before, colon, after = self._partition_field_on_colon(lines[0]) - _name, _type, _desc = '', '', lines - - if colon: - if after: - _desc = [after] + lines[1:] - else: - _desc = lines[1:] - - _type = before - - if (_type and preprocess_types and - self._config.napoleon_preprocess_types): - _type = _convert_type_spec(_type, self._config.napoleon_type_aliases or {}) - - _desc = self.__class__(_desc, self._config).lines() - return [(_name, _type, _desc,)] - else: - return [] - - def _consume_usage_section(self) -> List[str]: - lines = self._dedent(self._consume_to_next_section()) - return lines - - def _consume_section_header(self) -> str: - section = self._lines.next() - stripped_section = section.strip(':') - if stripped_section.lower() in self._sections: - section = stripped_section - return section - - def _consume_to_end(self) -> List[str]: - lines = [] - while self._lines: - lines.append(self._lines.next()) - return lines - - def _consume_to_next_section(self) -> List[str]: - self._consume_empty() - lines = [] - while not self._is_section_break(): - lines.append(self._lines.next()) - return lines + self._consume_empty() - - def _dedent(self, lines: List[str], full: bool = False) -> List[str]: - if full: - return [line.lstrip() for line in lines] - else: - min_indent = self._get_min_indent(lines) - return [line[min_indent:] for line in lines] - - def _escape_args_and_kwargs(self, name: str) -> str: - if name.endswith('_') and getattr(self._config, 'strip_signature_backslash', False): - name = name[:-1] + r'\_' - - if name[:2] == '**': - return r'\*\*' + name[2:] - elif name[:1] == '*': - return r'\*' + name[1:] - else: - return name - - def _fix_field_desc(self, desc: List[str]) -> List[str]: - if self._is_list(desc): - desc = [''] + desc - elif desc[0].endswith('::'): - desc_block = desc[1:] - indent = self._get_indent(desc[0]) - block_indent = self._get_initial_indent(desc_block) - if block_indent > indent: - desc = [''] + desc - else: - desc = ['', desc[0]] + self._indent(desc_block, 4) - return desc - - def _format_admonition(self, admonition: str, lines: List[str]) -> List[str]: - lines = self._strip_empty(lines) - if len(lines) == 1: - return ['.. %s:: %s' % (admonition, lines[0].strip()), ''] - elif lines: - lines = self._indent(self._dedent(lines), 3) - return ['.. %s::' % admonition, ''] + lines + [''] - else: - return ['.. %s::' % admonition, ''] - - def _format_block(self, prefix: str, lines: List[str], padding: str = None) -> List[str]: - if lines: - if padding is None: - padding = ' ' * len(prefix) - result_lines = [] - for i, line in enumerate(lines): - if i == 0: - result_lines.append((prefix + line).rstrip()) - elif line: - result_lines.append(padding + line) - else: - result_lines.append('') - return result_lines - else: - return [prefix] - - def _format_docutils_params(self, fields: List[Tuple[str, str, List[str]]], - field_role: str = 'param', type_role: str = 'type' - ) -> List[str]: - lines = [] - for _name, _type, _desc in fields: - _desc = self._strip_empty(_desc) - if any(_desc): - _desc = self._fix_field_desc(_desc) - field = ':%s %s: ' % (field_role, _name) - lines.extend(self._format_block(field, _desc)) - else: - lines.append(':%s %s:' % (field_role, _name)) - - if _type: - lines.append(':%s %s: %s' % (type_role, _name, _type)) - return lines + [''] - - def _format_field(self, _name: str, _type: str, _desc: List[str]) -> List[str]: - _desc = self._strip_empty(_desc) - has_desc = any(_desc) - separator = ' -- ' if has_desc else '' - if _name: - if _type: - if '`' in _type: - field = '**%s** (%s)%s' % (_name, _type, separator) - else: - field = '**%s** (*%s*)%s' % (_name, _type, separator) - else: - field = '**%s**%s' % (_name, separator) - elif _type: - if '`' in _type: - field = '%s%s' % (_type, separator) - else: - field = '*%s*%s' % (_type, separator) - else: - field = '' - - if has_desc: - _desc = self._fix_field_desc(_desc) - if _desc[0]: - return [field + _desc[0]] + _desc[1:] - else: - return [field] + _desc - else: - return [field] - - def _format_fields(self, field_type: str, fields: List[Tuple[str, str, List[str]]] - ) -> List[str]: - field_type = ':%s:' % field_type.strip() - padding = ' ' * len(field_type) - multi = len(fields) > 1 - lines: List[str] = [] - for _name, _type, _desc in fields: - field = self._format_field(_name, _type, _desc) - if multi: - if lines: - lines.extend(self._format_block(padding + ' * ', field)) - else: - lines.extend(self._format_block(field_type + ' * ', field)) - else: - lines.extend(self._format_block(field_type + ' ', field)) - if lines and lines[-1]: - lines.append('') - return lines - - def _get_current_indent(self, peek_ahead: int = 0) -> int: - line = self._lines.get(peek_ahead) - while line is not self._lines.sentinel: - if line: - return self._get_indent(line) - peek_ahead += 1 - line = self._lines.get(peek_ahead) - return 0 - - def _get_indent(self, line: str) -> int: - for i, s in enumerate(line): - if not s.isspace(): - return i - return len(line) - - def _get_initial_indent(self, lines: List[str]) -> int: - for line in lines: - if line: - return self._get_indent(line) - return 0 - - def _get_min_indent(self, lines: List[str]) -> int: - min_indent = None - for line in lines: - if line: - indent = self._get_indent(line) - if min_indent is None: - min_indent = indent - elif indent < min_indent: - min_indent = indent - return min_indent or 0 - - def _indent(self, lines: List[str], n: int = 4) -> List[str]: - return [(' ' * n) + line for line in lines] - - def _is_indented(self, line: str, indent: int = 1) -> bool: - for i, s in enumerate(line): - if i >= indent: - return True - elif not s.isspace(): - return False - return False - - def _is_list(self, lines: List[str]) -> bool: - if not lines: - return False - if _bullet_list_regex.match(lines[0]): - return True - if _enumerated_list_regex.match(lines[0]): - return True - if len(lines) < 2 or lines[0].endswith('::'): - return False - indent = self._get_indent(lines[0]) - next_indent = indent - for line in lines[1:]: - if line: - next_indent = self._get_indent(line) - break - return next_indent > indent - - def _is_section_header(self) -> bool: - section = self._lines.get(0).lower() - match = _google_section_regex.match(section) - if match and section.strip(':') in self._sections: - header_indent = self._get_indent(section) - section_indent = self._get_current_indent(peek_ahead=1) - return section_indent > header_indent - elif self._directive_sections: - if _directive_regex.match(section): - for directive_section in self._directive_sections: - if section.startswith(directive_section): - return True - return False - - def _is_section_break(self) -> bool: - line = self._lines.get(0) - return (not self._lines or - self._is_section_header() or - (self._is_in_section and - line and - not self._is_indented(line, self._section_indent))) - - def _load_custom_sections(self) -> None: - if self._config.napoleon_custom_sections is not None: - for entry in self._config.napoleon_custom_sections: - if isinstance(entry, str): - # if entry is just a label, add to sections list, - # using generic section logic. - self._sections[entry.lower()] = self._parse_custom_generic_section - else: - # otherwise, assume entry is container; - if entry[1] == "params_style": - self._sections[entry[0].lower()] = \ - self._parse_custom_params_style_section - elif entry[1] == "returns_style": - self._sections[entry[0].lower()] = \ - self._parse_custom_returns_style_section - else: - # [0] is new section, [1] is the section to alias. - # in the case of key mismatch, just handle as generic section. - self._sections[entry[0].lower()] = \ - self._sections.get(entry[1].lower(), - self._parse_custom_generic_section) - - def _parse(self) -> None: - self._parsed_lines = self._consume_empty() - - if self._name and self._what in ('attribute', 'data', 'property'): - # Implicit stop using StopIteration no longer allowed in - # Python 3.7; see PEP 479 - res: List[str] = [] - try: - res = self._parse_attribute_docstring() - except StopIteration: - pass - self._parsed_lines.extend(res) - return - - while self._lines: - if self._is_section_header(): - try: - section = self._consume_section_header() - self._is_in_section = True - self._section_indent = self._get_current_indent() - if _directive_regex.match(section): - lines = [section] + self._consume_to_next_section() - else: - lines = self._sections[section.lower()](section) - finally: - self._is_in_section = False - self._section_indent = 0 - else: - if not self._parsed_lines: - lines = self._consume_contiguous() + self._consume_empty() - else: - lines = self._consume_to_next_section() - self._parsed_lines.extend(lines) - - def _parse_admonition(self, admonition: str, section: str) -> List[str]: - # type (str, str) -> List[str] - lines = self._consume_to_next_section() - return self._format_admonition(admonition, lines) - - def _parse_attribute_docstring(self) -> List[str]: - _type, _desc = self._consume_inline_attribute() - lines = self._format_field('', '', _desc) - if _type: - lines.extend(['', ':type: %s' % _type]) - return lines - - def _parse_attributes_section(self, section: str) -> List[str]: - lines = [] - for _name, _type, _desc in self._consume_fields(): - if not _type: - _type = self._lookup_annotation(_name) - if self._config.napoleon_use_ivar: - field = ':ivar %s: ' % _name - lines.extend(self._format_block(field, _desc)) - if _type: - lines.append(':vartype %s: %s' % (_name, _type)) - else: - lines.append('.. attribute:: ' + _name) - if self._opt and 'noindex' in self._opt: - lines.append(' :noindex:') - lines.append('') - - fields = self._format_field('', '', _desc) - lines.extend(self._indent(fields, 3)) - if _type: - lines.append('') - lines.extend(self._indent([':type: %s' % _type], 3)) - lines.append('') - if self._config.napoleon_use_ivar: - lines.append('') - return lines - - def _parse_examples_section(self, section: str) -> List[str]: - labels = { - 'example': _('Example'), - 'examples': _('Examples'), - } - use_admonition = self._config.napoleon_use_admonition_for_examples - label = labels.get(section.lower(), section) - return self._parse_generic_section(label, use_admonition) - - def _parse_custom_generic_section(self, section: str) -> List[str]: - # for now, no admonition for simple custom sections - return self._parse_generic_section(section, False) - - def _parse_custom_params_style_section(self, section: str) -> List[str]: - return self._format_fields(section, self._consume_fields()) - - def _parse_custom_returns_style_section(self, section: str) -> List[str]: - fields = self._consume_returns_section(preprocess_types=True) - return self._format_fields(section, fields) - - def _parse_usage_section(self, section: str) -> List[str]: - header = ['.. rubric:: Usage:', ''] - block = ['.. code-block:: python', ''] - lines = self._consume_usage_section() - lines = self._indent(lines, 3) - return header + block + lines + [''] - - def _parse_generic_section(self, section: str, use_admonition: bool) -> List[str]: - lines = self._strip_empty(self._consume_to_next_section()) - lines = self._dedent(lines) - if use_admonition: - # jmontalt: use MyST syntax instead of RST. - header = '```{admonition} %s' % section - # lines = self._indent(lines, 3) - lines.append('```') - else: - # jmontalt: use MyST syntax instead of RST. - header = '```{rubric} %s' % section - lines = ['```'] + lines - if lines: - return [header, ''] + lines + [''] - else: - return [header, ''] - - def _parse_keyword_arguments_section(self, section: str) -> List[str]: - fields = self._consume_fields() - if self._config.napoleon_use_keyword: - return self._format_docutils_params( - fields, - field_role="keyword", - type_role="kwtype") - else: - return self._format_fields(_('Keyword Arguments'), fields) - - def _parse_methods_section(self, section: str) -> List[str]: - lines: List[str] = [] - for _name, _type, _desc in self._consume_fields(parse_type=False): - lines.append('.. method:: %s' % _name) - if self._opt and 'noindex' in self._opt: - lines.append(' :noindex:') - if _desc: - lines.extend([''] + self._indent(_desc, 3)) - lines.append('') - return lines - - def _parse_notes_section(self, section: str) -> List[str]: - use_admonition = self._config.napoleon_use_admonition_for_notes - return self._parse_generic_section(_('Notes'), use_admonition) - - def _parse_other_parameters_section(self, section: str) -> List[str]: - if self._config.napoleon_use_param: - # Allow to declare multiple parameters at once (ex: x, y: int) - fields = self._consume_fields(multiple=True) - return self._format_docutils_params(fields) - else: - fields = self._consume_fields() - return self._format_fields(_('Other Parameters'), fields) - - def _parse_parameters_section(self, section: str) -> List[str]: - if self._config.napoleon_use_param: - # Allow to declare multiple parameters at once (ex: x, y: int) - fields = self._consume_fields(multiple=True) - return self._format_docutils_params(fields) - else: - fields = self._consume_fields() - return self._format_fields(_('Parameters'), fields) - - def _parse_raises_section(self, section: str) -> List[str]: - fields = self._consume_fields(parse_type=False, prefer_type=True) - lines: List[str] = [] - for _name, _type, _desc in fields: - m = self._name_rgx.match(_type) - if m and m.group('name'): - _type = m.group('name') - elif _xref_regex.match(_type): - pos = _type.find('`') - _type = _type[pos + 1:-1] - _type = ' ' + _type if _type else '' - _desc = self._strip_empty(_desc) - _descs = ' ' + '\n '.join(_desc) if any(_desc) else '' - lines.append(':raises%s:%s' % (_type, _descs)) - if lines: - lines.append('') - return lines - - def _parse_receives_section(self, section: str) -> List[str]: - if self._config.napoleon_use_param: - # Allow to declare multiple parameters at once (ex: x, y: int) - fields = self._consume_fields(multiple=True) - return self._format_docutils_params(fields) - else: - fields = self._consume_fields() - return self._format_fields(_('Receives'), fields) - - def _parse_references_section(self, section: str) -> List[str]: - use_admonition = self._config.napoleon_use_admonition_for_references - return self._parse_generic_section(_('References'), use_admonition) - - def _parse_returns_section(self, section: str) -> List[str]: - fields = self._consume_returns_section() - multi = len(fields) > 1 - use_rtype = False if multi else self._config.napoleon_use_rtype - lines: List[str] = [] - - for _name, _type, _desc in fields: - if use_rtype: - field = self._format_field(_name, '', _desc) - else: - field = self._format_field(_name, _type, _desc) - - if multi: - if lines: - lines.extend(self._format_block(' * ', field)) - else: - lines.extend(self._format_block(':returns: * ', field)) - else: - if any(field): # only add :returns: if there's something to say - lines.extend(self._format_block(':returns: ', field)) - if _type and use_rtype: - lines.extend([':rtype: %s' % _type, '']) - if lines and lines[-1]: - lines.append('') - return lines - - def _parse_see_also_section(self, section: str) -> List[str]: - return self._parse_admonition('seealso', section) - - def _parse_warns_section(self, section: str) -> List[str]: - return self._format_fields(_('Warns'), self._consume_fields()) - - def _parse_yields_section(self, section: str) -> List[str]: - fields = self._consume_returns_section(preprocess_types=True) - return self._format_fields(_('Yields'), fields) - - def _partition_field_on_colon(self, line: str) -> Tuple[str, str, str]: - before_colon = [] - after_colon = [] - colon = '' - found_colon = False - for i, source in enumerate(_xref_or_code_regex.split(line)): - if found_colon: - after_colon.append(source) - else: - m = _single_colon_regex.search(source) - if (i % 2) == 0 and m: - found_colon = True - colon = source[m.start(): m.end()] - before_colon.append(source[:m.start()]) - after_colon.append(source[m.end():]) - else: - before_colon.append(source) - - return ("".join(before_colon).strip(), - colon, - "".join(after_colon).strip()) - - def _qualify_name(self, attr_name: str, klass: Type) -> str: - warnings.warn('%s._qualify_name() is deprecated.' % - self.__class__.__name__, RemovedInSphinx60Warning) - if klass and '.' not in attr_name: - if attr_name.startswith('~'): - attr_name = attr_name[1:] - try: - q = klass.__qualname__ - except AttributeError: - q = klass.__name__ - return '~%s.%s' % (q, attr_name) - return attr_name - - def _strip_empty(self, lines: List[str]) -> List[str]: - if lines: - start = -1 - for i, line in enumerate(lines): - if line: - start = i - break - if start == -1: - lines = [] - end = -1 - for i in reversed(range(len(lines))): - line = lines[i] - if line: - end = i - break - if start > 0 or end + 1 < len(lines): - lines = lines[start:end + 1] - return lines - - def _lookup_annotation(self, _name: str) -> str: - if self._config.napoleon_attr_annotations: - if self._what in ("module", "class", "exception") and self._obj: - # cache the class annotations - if not hasattr(self, "_annotations"): - localns = getattr(self._config, "autodoc_type_aliases", {}) - localns.update(getattr( - self._config, "napoleon_type_aliases", {} - ) or {}) - self._annotations = get_type_hints(self._obj, None, localns) - if _name in self._annotations: - return stringify_annotation(self._annotations[_name]) - # No annotation found - return "" - - -def _recombine_set_tokens(tokens: List[str]) -> List[str]: - token_queue = collections.deque(tokens) - keywords = ("optional", "default") - - def takewhile_set(tokens): - open_braces = 0 - previous_token = None - while True: - try: - token = tokens.popleft() - except IndexError: - break - - if token == ", ": - previous_token = token - continue - - if not token.strip(): - continue - - if token in keywords: - tokens.appendleft(token) - if previous_token is not None: - tokens.appendleft(previous_token) - break - - if previous_token is not None: - yield previous_token - previous_token = None - - if token == "{": - open_braces += 1 - elif token == "}": - open_braces -= 1 - - yield token - - if open_braces == 0: - break - - def combine_set(tokens): - while True: - try: - token = tokens.popleft() - except IndexError: - break - - if token == "{": - tokens.appendleft("{") - yield "".join(takewhile_set(tokens)) - else: - yield token - - return list(combine_set(token_queue)) - - -def _tokenize_type_spec(spec: str) -> List[str]: - def postprocess(item): - if _default_regex.match(item): - default = item[:7] - # can't be separated by anything other than a single space - # for now - other = item[8:] - - return [default, " ", other] - else: - return [item] - - tokens = [ - item - for raw_token in _token_regex.split(spec) - for item in postprocess(raw_token) - if item - ] - return tokens - - -def _token_type(token: str, location: str = None) -> str: - def is_numeric(token): - try: - # use complex to make sure every numeric value is detected as literal - complex(token) - except ValueError: - return False - else: - return True - - if token.startswith(" ") or token.endswith(" "): - type_ = "delimiter" - elif ( - is_numeric(token) or - (token.startswith("{") and token.endswith("}")) or - (token.startswith('"') and token.endswith('"')) or - (token.startswith("'") and token.endswith("'")) - ): - type_ = "literal" - elif token.startswith("{"): - logger.warning( - __("invalid value set (missing closing brace): %s"), - token, - location=location, - ) - type_ = "literal" - elif token.endswith("}"): - logger.warning( - __("invalid value set (missing opening brace): %s"), - token, - location=location, - ) - type_ = "literal" - elif token.startswith("'") or token.startswith('"'): - logger.warning( - __("malformed string literal (missing closing quote): %s"), - token, - location=location, - ) - type_ = "literal" - elif token.endswith("'") or token.endswith('"'): - logger.warning( - __("malformed string literal (missing opening quote): %s"), - token, - location=location, - ) - type_ = "literal" - elif token in ("optional", "default"): - # default is not a official keyword (yet) but supported by the - # reference implementation (numpydoc) and widely used - type_ = "control" - elif _xref_regex.match(token): - type_ = "reference" - else: - type_ = "obj" - - return type_ - - -def _convert_numpy_type_spec(_type: str, location: str = None, translations: dict = {}) -> str: - def convert_obj(obj, translations, default_translation): - translation = translations.get(obj, obj) - - # use :class: (the default) only if obj is not a standard singleton - if translation in _SINGLETONS and default_translation == ":class:`%s`": - default_translation = ":obj:`%s`" - elif translation == "..." and default_translation == ":class:`%s`": - # allow referencing the builtin ... - default_translation = ":obj:`%s `" - - if _xref_regex.match(translation) is None: - translation = default_translation % translation - - return translation - - tokens = _tokenize_type_spec(_type) - combined_tokens = _recombine_set_tokens(tokens) - types = [ - (token, _token_type(token, location)) - for token in combined_tokens - ] - - converters = { - "literal": lambda x: "``%s``" % x, - "obj": lambda x: convert_obj(x, translations, ":class:`%s`"), - "control": lambda x: "*%s*" % x, - "delimiter": lambda x: x, - "reference": lambda x: x, - } - - converted = "".join(converters.get(type_)(token) for token, type_ in types) - - return converted - - -class NumpyDocstring(GoogleDocstring): - """Convert NumPy style docstrings to reStructuredText. - - Parameters - ---------- - docstring : :obj:`str` or :obj:`list` of :obj:`str` - The docstring to parse, given either as a string or split into - individual lines. - config: :obj:`myst_napoleon.Config` or :obj:`sphinx.config.Config` - The configuration settings to use. If not given, defaults to the - config object on `app`; or if `app` is not given defaults to the - a new :class:`myst_napoleon.Config` object. - - - Other Parameters - ---------------- - app : :class:`sphinx.application.Sphinx`, optional - Application object representing the Sphinx process. - what : :obj:`str`, optional - A string specifying the type of the object to which the docstring - belongs. Valid values: "module", "class", "exception", "function", - "method", "attribute". - name : :obj:`str`, optional - The fully qualified name of the object. - obj : module, class, exception, function, method, or attribute - The object to which the docstring belongs. - options : :class:`sphinx.ext.autodoc.Options`, optional - The options given to the directive: an object with attributes - inherited_members, undoc_members, show_inheritance and noindex that - are True if the flag option of same name was given to the auto - directive. - - - Example - ------- - >>> from myst_napoleon import Config - >>> config = Config(napoleon_use_param=True, napoleon_use_rtype=True) - >>> docstring = '''One line summary. - ... - ... Extended description. - ... - ... Parameters - ... ---------- - ... arg1 : int - ... Description of `arg1` - ... arg2 : str - ... Description of `arg2` - ... Returns - ... ------- - ... str - ... Description of return value. - ... ''' - >>> print(NumpyDocstring(docstring, config)) - One line summary. - - Extended description. - - :param arg1: Description of `arg1` - :type arg1: int - :param arg2: Description of `arg2` - :type arg2: str - - :returns: Description of return value. - :rtype: str - - - Methods - ------- - __str__() - Return the parsed docstring in reStructuredText format. - - Returns - ------- - str - UTF-8 encoded version of the docstring. - - __unicode__() - Return the parsed docstring in reStructuredText format. - - Returns - ------- - unicode - Unicode version of the docstring. - - lines() - Return the parsed lines of the docstring in reStructuredText format. - - Returns - ------- - list(str) - The lines of the docstring in a list. - - """ - def __init__(self, docstring: Union[str, List[str]], config: SphinxConfig = None, - app: Sphinx = None, what: str = '', name: str = '', - obj: Any = None, options: Any = None) -> None: - self._directive_sections = ['.. index::'] - super().__init__(docstring, config, app, what, name, obj, options) - - def _get_location(self) -> str: - try: - filepath = inspect.getfile(self._obj) if self._obj is not None else None - except TypeError: - filepath = None - name = self._name - - if filepath is None and name is None: - return None - elif filepath is None: - filepath = "" - - return ":".join([filepath, "docstring of %s" % name]) - - def _escape_args_and_kwargs(self, name: str) -> str: - func = super()._escape_args_and_kwargs - - if ", " in name: - return ", ".join(func(param) for param in name.split(", ")) - else: - return func(name) - - def _consume_field(self, parse_type: bool = True, prefer_type: bool = False - ) -> Tuple[str, str, List[str]]: - line = self._lines.next() - if parse_type: - _name, _, _type = self._partition_field_on_colon(line) - else: - _name, _type = line, '' - _name, _type = _name.strip(), _type.strip() - _name = self._escape_args_and_kwargs(_name) - - if parse_type and not _type: - _type = self._lookup_annotation(_name) - - if prefer_type and not _type: - _type, _name = _name, _type - - if self._config.napoleon_preprocess_types: - _type = _convert_numpy_type_spec( - _type, - location=self._get_location(), - translations=self._config.napoleon_type_aliases or {}, - ) - - indent = self._get_indent(line) + 1 - _desc = self._dedent(self._consume_indented_block(indent)) - _desc = self.__class__(_desc, self._config).lines() - return _name, _type, _desc - - def _consume_returns_section(self, preprocess_types: bool = False - ) -> List[Tuple[str, str, List[str]]]: - return self._consume_fields(prefer_type=True) - - def _consume_section_header(self) -> str: - section = self._lines.next() - if not _directive_regex.match(section): - # Consume the header underline - self._lines.next() - return section - - def _is_section_break(self) -> bool: - line1, line2 = self._lines.get(0), self._lines.get(1) - return (not self._lines or - self._is_section_header() or - ['', ''] == [line1, line2] or - (self._is_in_section and - line1 and - not self._is_indented(line1, self._section_indent))) - - def _is_section_header(self) -> bool: - section, underline = self._lines.get(0), self._lines.get(1) - section = section.lower() - if section in self._sections and isinstance(underline, str): - return bool(_numpy_section_regex.match(underline)) - elif self._directive_sections: - if _directive_regex.match(section): - for directive_section in self._directive_sections: - if section.startswith(directive_section): - return True - return False - - def _parse_see_also_section(self, section: str) -> List[str]: - lines = self._consume_to_next_section() - try: - return self._parse_numpydoc_see_also_section(lines) - except ValueError: - return self._format_admonition('seealso', lines) - - def _parse_numpydoc_see_also_section(self, content: List[str]) -> List[str]: - """ - Derived from the NumpyDoc implementation of _parse_see_also. - - See Also - -------- - func_name : Descriptive text - continued text - another_func_name : Descriptive text - func_name1, func_name2, :meth:`func_name`, func_name3 - - """ - items = [] - - def parse_item_name(text: str) -> Tuple[str, str]: - """Match ':role:`name`' or 'name'""" - m = self._name_rgx.match(text) - if m: - g = m.groups() - if g[1] is None: - return g[3], None - else: - return g[2], g[1] - raise ValueError("%s is not a item name" % text) - - def push_item(name: str, rest: List[str]) -> None: - if not name: - return - name, role = parse_item_name(name) - items.append((name, list(rest), role)) - del rest[:] - - def translate(func, description, role): - translations = self._config.napoleon_type_aliases - if role is not None or not translations: - return func, description, role - - translated = translations.get(func, func) - match = self._name_rgx.match(translated) - if not match: - return translated, description, role - - groups = match.groupdict() - role = groups["role"] - new_func = groups["name"] or groups["name2"] - - return new_func, description, role - - current_func = None - rest: List[str] = [] - - for line in content: - if not line.strip(): - continue - - m = self._name_rgx.match(line) - if m and line[m.end():].strip().startswith(':'): - push_item(current_func, rest) - current_func, line = line[:m.end()], line[m.end():] - rest = [line.split(':', 1)[1].strip()] - if not rest[0]: - rest = [] - elif not line.startswith(' '): - push_item(current_func, rest) - current_func = None - if ',' in line: - for func in line.split(','): - if func.strip(): - push_item(func, []) - elif line.strip(): - current_func = line - elif current_func is not None: - rest.append(line.strip()) - push_item(current_func, rest) - - if not items: - return [] - - # apply type aliases - items = [ - translate(func, description, role) - for func, description, role in items - ] - - lines: List[str] = [] - last_had_desc = True - for name, desc, role in items: - if role: - link = ':%s:`%s`' % (role, name) - else: - link = ':obj:`%s`' % name - if desc or last_had_desc: - lines += [''] - lines += [link] - else: - lines[-1] += ", %s" % link - if desc: - lines += self._indent([' '.join(desc)]) - last_had_desc = True - else: - last_had_desc = False - lines += [''] - - return self._format_admonition('seealso', lines) diff --git a/tools/docs/extensions/myst_napoleon/iterators.py b/tools/docs/extensions/myst_napoleon/iterators.py deleted file mode 100644 index 6337ca99..00000000 --- a/tools/docs/extensions/myst_napoleon/iterators.py +++ /dev/null @@ -1,235 +0,0 @@ -"""A collection of helpful iterators.""" -# This code is copied from `sphinx.ext.napoleon` v5.1.1. Any changes have -# been labelled with `jmontalt`. - -import collections -import warnings -from typing import Any, Iterable, Optional - -from sphinx.deprecation import RemovedInSphinx70Warning - -warnings.warn('myst_napoleon.iterators is deprecated.', - RemovedInSphinx70Warning) - - -class peek_iter: - """An iterator object that supports peeking ahead. - - Parameters - ---------- - o : iterable or callable - `o` is interpreted very differently depending on the presence of - `sentinel`. - - If `sentinel` is not given, then `o` must be a collection object - which supports either the iteration protocol or the sequence protocol. - - If `sentinel` is given, then `o` must be a callable object. - - sentinel : any value, optional - If given, the iterator will call `o` with no arguments for each - call to its `next` method; if the value returned is equal to - `sentinel`, :exc:`StopIteration` will be raised, otherwise the - value will be returned. - - See Also - -------- - `peek_iter` can operate as a drop in replacement for the built-in - `iter `_ function. - - Attributes - ---------- - sentinel - The value used to indicate the iterator is exhausted. If `sentinel` - was not given when the `peek_iter` was instantiated, then it will - be set to a new object instance: ``object()``. - - """ - def __init__(self, *args: Any) -> None: - """__init__(o, sentinel=None)""" - self._iterable: Iterable = iter(*args) - self._cache: collections.deque = collections.deque() - if len(args) == 2: - self.sentinel = args[1] - else: - self.sentinel = object() - - def __iter__(self) -> "peek_iter": - return self - - def __next__(self, n: int = None) -> Any: - return self.next(n) - - def _fillcache(self, n: Optional[int]) -> None: - """Cache `n` items. If `n` is 0 or None, then 1 item is cached.""" - if not n: - n = 1 - try: - while len(self._cache) < n: - self._cache.append(next(self._iterable)) # type: ignore - except StopIteration: - while len(self._cache) < n: - self._cache.append(self.sentinel) - - def has_next(self) -> bool: - """Determine if iterator is exhausted. - - Returns - ------- - bool - True if iterator has more items, False otherwise. - - Note - ---- - Will never raise :exc:`StopIteration`. - - """ - return self.peek() != self.sentinel - - def next(self, n: int = None) -> Any: - """Get the next item or `n` items of the iterator. - - Parameters - ---------- - n : int or None - The number of items to retrieve. Defaults to None. - - Returns - ------- - item or list of items - The next item or `n` items of the iterator. If `n` is None, the - item itself is returned. If `n` is an int, the items will be - returned in a list. If `n` is 0, an empty list is returned. - - Raises - ------ - StopIteration - Raised if the iterator is exhausted, even if `n` is 0. - - """ - self._fillcache(n) - if not n: - if self._cache[0] == self.sentinel: - raise StopIteration - if n is None: - result = self._cache.popleft() - else: - result = [] - else: - if self._cache[n - 1] == self.sentinel: - raise StopIteration - result = [self._cache.popleft() for i in range(n)] - return result - - def peek(self, n: Optional[int] = None) -> Any: - """Preview the next item or `n` items of the iterator. - - The iterator is not advanced when peek is called. - - Returns - ------- - item or list of items - The next item or `n` items of the iterator. If `n` is None, the - item itself is returned. If `n` is an int, the items will be - returned in a list. If `n` is 0, an empty list is returned. - - If the iterator is exhausted, `peek_iter.sentinel` is returned, - or placed as the last item in the returned list. - - Note - ---- - Will never raise :exc:`StopIteration`. - - """ - self._fillcache(n) - if n is None: - result = self._cache[0] - else: - result = [self._cache[i] for i in range(n)] - return result - - -class modify_iter(peek_iter): - """An iterator object that supports modifying items as they are returned. - - Parameters - ---------- - o : iterable or callable - `o` is interpreted very differently depending on the presence of - `sentinel`. - - If `sentinel` is not given, then `o` must be a collection object - which supports either the iteration protocol or the sequence protocol. - - If `sentinel` is given, then `o` must be a callable object. - - sentinel : any value, optional - If given, the iterator will call `o` with no arguments for each - call to its `next` method; if the value returned is equal to - `sentinel`, :exc:`StopIteration` will be raised, otherwise the - value will be returned. - - modifier : callable, optional - The function that will be used to modify each item returned by the - iterator. `modifier` should take a single argument and return a - single value. Defaults to ``lambda x: x``. - - If `sentinel` is not given, `modifier` must be passed as a keyword - argument. - - Attributes - ---------- - modifier : callable - `modifier` is called with each item in `o` as it is iterated. The - return value of `modifier` is returned in lieu of the item. - - Values returned by `peek` as well as `next` are affected by - `modifier`. However, `modify_iter.sentinel` is never passed through - `modifier`; it will always be returned from `peek` unmodified. - - Example - ------- - >>> a = [" A list ", - ... " of strings ", - ... " with ", - ... " extra ", - ... " whitespace. "] - >>> modifier = lambda s: s.strip().replace('with', 'without') - >>> for s in modify_iter(a, modifier=modifier): - ... print('"%s"' % s) - "A list" - "of strings" - "without" - "extra" - "whitespace." - - """ - def __init__(self, *args: Any, **kwargs: Any) -> None: - """__init__(o, sentinel=None, modifier=lambda x: x)""" - if 'modifier' in kwargs: - self.modifier = kwargs['modifier'] - elif len(args) > 2: - self.modifier = args[2] - args = args[:2] - else: - self.modifier = lambda x: x - if not callable(self.modifier): - raise TypeError('modify_iter(o, modifier): ' - 'modifier must be callable') - super().__init__(*args) - - def _fillcache(self, n: Optional[int]) -> None: - """Cache `n` modified items. If `n` is 0 or None, 1 item is cached. - - Each item returned by the iterator is passed through the - `modify_iter.modified` function before being cached. - - """ - if not n: - n = 1 - try: - while len(self._cache) < n: - self._cache.append(self.modifier(next(self._iterable))) # type: ignore - except StopIteration: - while len(self._cache) < n: - self._cache.append(self.sentinel) From fcd39887a926eaa6ebe9e32c30abbb6801df75ad Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 7 Sep 2022 13:00:00 +0100 Subject: [PATCH 091/101] Replaced math directives with MyST syntax --- .../python/losses/confusion_losses.py | 12 ++++++--- .../python/metrics/confusion_metrics.py | 27 ++++++++++++------- tensorflow_mri/python/ops/math_ops.py | 9 ++++--- tensorflow_mri/python/ops/recon_ops.py | 3 ++- tensorflow_mri/python/ops/signal_ops.py | 3 ++- 5 files changed, 36 insertions(+), 18 deletions(-) diff --git a/tensorflow_mri/python/losses/confusion_losses.py b/tensorflow_mri/python/losses/confusion_losses.py index 6c3a24ac..d71227b4 100644 --- a/tensorflow_mri/python/losses/confusion_losses.py +++ b/tensorflow_mri/python/losses/confusion_losses.py @@ -228,8 +228,9 @@ class FocalTverskyLoss(ConfusionLoss): The focal Tversky loss is computed as: - .. math:: + $$ L = \left ( 1 - \frac{\mathrm{TP} + \epsilon}{\mathrm{TP} + \alpha \mathrm{FP} + \beta \mathrm{FN} + \epsilon} \right ) ^ \gamma + $$ This loss allows control over the relative importance of false positives and false negatives through the `alpha` and `beta` parameters, which may be useful @@ -301,8 +302,9 @@ class TverskyLoss(FocalTverskyLoss): The Tversky loss is computed as: - .. math:: + $$ L = \left ( 1 - \frac{\mathrm{TP} + \epsilon}{\mathrm{TP} + \alpha \mathrm{FP} + \beta \mathrm{FN} + \epsilon} \right ) + $$ Args: alpha: A `float`. Weight given to false positives. Defaults to 0.3. @@ -339,8 +341,9 @@ class F1Loss(TverskyLoss): The F1 loss is computed as: - .. math:: + $$ L = \left ( 1 - \frac{\mathrm{TP} + \epsilon}{\mathrm{TP} + \frac{1}{2} \mathrm{FP} + \frac{1}{2} \mathrm{FN} + \epsilon} \right ) + $$ Args: epsilon: A `float`. A smoothing factor. Defaults to 1e-5. @@ -373,8 +376,9 @@ class IoULoss(TverskyLoss): The IoU loss is computed as: - .. math:: + $$ L = \left ( 1 - \frac{\mathrm{TP} + \epsilon}{\mathrm{TP} + \mathrm{FP} + \mathrm{FN} + \epsilon} \right ) + $$ Args: epsilon: A `float`. A smoothing factor. Defaults to 1e-5. diff --git a/tensorflow_mri/python/metrics/confusion_metrics.py b/tensorflow_mri/python/metrics/confusion_metrics.py index 0aa0c59a..19a05ecb 100644 --- a/tensorflow_mri/python/metrics/confusion_metrics.py +++ b/tensorflow_mri/python/metrics/confusion_metrics.py @@ -299,8 +299,9 @@ class Accuracy(ConfusionMetric): Estimates how often predictions match labels. - .. math:: + $$ \textrm{accuracy} = \frac{\textrm{TP} + \textrm{TN}}{\textrm{TP} + \textrm{TN} + \textrm{FP} + \textrm{FN}} + $$ Args: name: String name of the metric instance. @@ -337,8 +338,9 @@ class TruePositiveRate(ConfusionMetric): The true positive rate (TPR), also called sensitivity or recall, is the proportion of correctly predicted positives among all positive instances. - .. math:: + $$ \textrm{TPR} = \frac{\textrm{TP}}{\textrm{TP} + \textrm{FN}} + $$ Args: name: String name of the metric instance. @@ -374,8 +376,9 @@ class TrueNegativeRate(ConfusionMetric): The true negative rate (TNR), also called specificity or selectivity, is the proportion of correctly predicted negatives among all negative instances. - .. math:: + $$ \textrm{TNR} = \frac{\textrm{TN}}{\textrm{TN} + \textrm{FP}} + $$ Args: name: String name of the metric instance. @@ -410,8 +413,9 @@ class PositivePredictiveValue(ConfusionMetric): The positive predictive value (PPV), also called precision, is the proportion of correctly predicted positives among all positive calls. - .. math:: + $$ \textrm{PPV} = \frac{\textrm{TP}}{\textrm{TP} + \textrm{FP}} + $$ Args: name: String name of the metric instance. @@ -446,8 +450,9 @@ class NegativePredictiveValue(ConfusionMetric): The negative predictive value (NPV) is the proportion of correctly predicted negatives among all negative calls. - .. math:: + $$ \textrm{NPV} = \frac{\textrm{TN}}{\textrm{TN} + \textrm{FN}} + $$ Args: name: String name of the metric instance. @@ -482,8 +487,9 @@ class TverskyIndex(ConfusionMetric): The Tversky index is an asymmetric similarity measure [1]_. It is a generalization of the F-beta family of scores and the IoU. - .. math:: + $$ \textrm{TI} = \frac{\textrm{TP}}{\textrm{TP} + \alpha * \textrm{FP} + \beta * \textrm{FN}} + $$ Args: alpha: A `float`. The weight given to false positives. Defaults to 0.5. @@ -541,8 +547,9 @@ class FBetaScore(TverskyIndex): The F-beta score is the weighted harmonic mean of precision and recall. - .. math:: + $$ F_{\beta} = (1 + \beta^2) * \frac{\textrm{precision} * \textrm{precision}}{(\beta^2 \cdot \textrm{precision}) + \textrm{recall}} + $$ Args: beta: A `float`. Determines the weight of precision and recall in harmonic @@ -587,8 +594,9 @@ class F1Score(FBetaScore): The F-1 score is the harmonic mean of precision and recall. - .. math:: + $$ F_1 = 2 \cdot \frac{\textrm{precision} \cdot \textrm{recall}}{\textrm{precision} + \textrm{recall}} + $$ Args: name: String name of the metric instance. @@ -622,8 +630,9 @@ class IoU(TverskyIndex): Also known as Jaccard index. - .. math:: + $$ \textrm{IoU} = \frac{\textrm{TP}}{\textrm{TP} + \textrm{FP} + \textrm{FN}} + $$ Args: name: String name of the metric instance. diff --git a/tensorflow_mri/python/ops/math_ops.py b/tensorflow_mri/python/ops/math_ops.py index e939e8e8..373a988b 100644 --- a/tensorflow_mri/python/ops/math_ops.py +++ b/tensorflow_mri/python/ops/math_ops.py @@ -329,8 +329,9 @@ def indicator_box(x, lower_bound=-1.0, upper_bound=1.0, name=None): The box of radius $r$ is defined as the set of points of ${R}^{n}$ whose components are within the range $[l, u]$. - .. math:: + $$ \mathcal{C} = \left\{x \in \mathbb{R}^{n} : l \leq x_i \leq u, \forall i = 1, \dots, n \right\} + $$ Args: x: A `tf.Tensor` of shape `[..., n]`. @@ -381,8 +382,9 @@ def indicator_simplex(x, radius=1.0, name=None): The simplex of radius $r$ is defined as the set of points of $\mathbb{R}^{n}$ whose elements are nonnegative and sum up to `r`. - .. math:: + $$ \Delta_r = \left\{x \in \mathbb{R}^{n} : \sum_{i=1}^{n} x_i = r \text{ and } x_i >= 0, \forall i = 1, \dots, n \right\} + $$ If $r$ is 1, the simplex is also called the unit simplex, standard simplex or probability simplex. @@ -430,8 +432,9 @@ def indicator_ball(x, order=2, radius=1.0, name=None): ${R}^{n}$ whose distance from the origin, as defined by the $L_p$ norm, is less than or equal to $r$. - .. math:: + $$ \mathcal{B}_r = \left\{x \in \mathbb{R}^{n} : \left\|x\right\|_{p} \leq r \right\} + $$ If $r$ is 1, this ball is also called the unit ball of the :math`L_p` norm. diff --git a/tensorflow_mri/python/ops/recon_ops.py b/tensorflow_mri/python/ops/recon_ops.py index f3bc96bb..be7c5d38 100644 --- a/tensorflow_mri/python/ops/recon_ops.py +++ b/tensorflow_mri/python/ops/recon_ops.py @@ -60,8 +60,9 @@ def reconstruct_lstsq(kspace, This is an iterative reconstruction method which formulates the image reconstruction problem as follows: - .. math:: + $$ \hat{x} = {\mathop{\mathrm{argmin}}_x} \left (\left\| Ax - y \right\|_2^2 + g(x) \right ) + $$ where $A$ is the MRI `LinearOperator`, $x$ is the solution, `y` is the measured *k*-space data, and $g(x)$ is an optional `ConvexFunction` diff --git a/tensorflow_mri/python/ops/signal_ops.py b/tensorflow_mri/python/ops/signal_ops.py index 58f810d7..678851a9 100644 --- a/tensorflow_mri/python/ops/signal_ops.py +++ b/tensorflow_mri/python/ops/signal_ops.py @@ -105,13 +105,14 @@ def rect(arg, cutoff=np.pi, name=None): The rectangular function is defined as: - .. math:: + $$ \operatorname{rect}(x) = \Pi(t) = \left\{\begin{array}{rl} 0, & \text{if } |x| > \pi \\ \frac{1}{2}, & \text{if } |x| = \pi \\ 1, & \text{if } |x| < \pi. \end{array}\right. + $$ Args: arg: The input `tf.Tensor`. From b008f21bf93d86ec690261718e253afc5488813a Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 7 Sep 2022 14:44:40 +0000 Subject: [PATCH 092/101] Linting --- requirements.txt | 1 + tensorflow_mri/_api/coils/__init__.py | 1 - tensorflow_mri/python/activations/__init__.py | 7 ++- .../python/activations/complex_activations.py | 23 +++++--- .../activations/complex_activations_test.py | 2 + .../python/coils/coil_combination.py | 1 + .../python/coils/coil_compression.py | 7 ++- .../python/coils/coil_sensitivities.py | 2 +- .../python/coils/coil_sensitivities_test.py | 2 + .../geometry/rotation/rotation_matrix.py | 13 ++++- .../geometry/rotation/rotation_matrix_2d.py | 6 +-- .../geometry/rotation/rotation_matrix_3d.py | 36 ++++++++++--- .../python/geometry/rotation/test_helpers.py | 13 ++--- tensorflow_mri/python/geometry/rotation_2d.py | 15 ++++-- .../python/geometry/rotation_2d_test.py | 4 +- tensorflow_mri/python/geometry/rotation_3d.py | 16 +++--- .../python/geometry/rotation_3d_test.py | 4 +- .../python/initializers/__init__.py | 9 ++-- .../python/layers/coil_sensitivities.py | 2 - tensorflow_mri/python/layers/concatenate.py | 38 +++++++++++--- .../python/layers/concatenate_test.py | 52 +++++++++++++++++++ .../python/layers/data_consistency.py | 4 +- .../python/layers/normalization_test.py | 2 + tensorflow_mri/python/layers/padding.py | 9 ++-- tensorflow_mri/python/layers/recon_adjoint.py | 2 +- .../python/layers/recon_adjoint_test.py | 3 ++ .../python/linalg/linear_operator.py | 3 +- .../linalg/linear_operator_gram_matrix.py | 2 +- .../python/linalg/linear_operator_identity.py | 8 +-- .../python/linalg/linear_operator_mri.py | 6 ++- tensorflow_mri/python/losses/iqa_losses.py | 1 - tensorflow_mri/python/metrics/iqa_metrics.py | 1 - .../python/models/conv_blocks_test.py | 22 ++++++-- tensorflow_mri/python/models/conv_endec.py | 3 +- .../python/models/conv_endec_test.py | 20 ++++--- .../python/models/graph_like_network.py | 5 +- tensorflow_mri/python/ops/array_ops.py | 12 ++--- tensorflow_mri/python/ops/fft_ops_test.py | 13 ++--- tensorflow_mri/python/ops/image_ops.py | 16 ++++-- tensorflow_mri/python/ops/image_ops_test.py | 30 +++++------ tensorflow_mri/python/ops/recon_ops.py | 1 - tensorflow_mri/python/ops/signal_ops.py | 2 +- tensorflow_mri/python/ops/traj_ops.py | 2 +- tensorflow_mri/python/ops/traj_ops_test.py | 11 +++- .../python/recon/recon_adjoint_test.py | 3 +- tensorflow_mri/python/util/layer_util.py | 12 +++-- tensorflow_mri/python/util/model_util.py | 2 - 47 files changed, 307 insertions(+), 142 deletions(-) create mode 100644 tensorflow_mri/python/layers/concatenate_test.py diff --git a/requirements.txt b/requirements.txt index 995788bd..cf36181c 100755 --- a/requirements.txt +++ b/requirements.txt @@ -7,6 +7,7 @@ PyWavelets scipy tensorboard tensorflow>=2.9.0,<2.10.0 +tensorflow-addons>=0.17.0,<0.18.0 tensorflow-io>=0.26.0 tensorflow-nufft>=0.8.0 tensorflow-probability>=0.16.0 diff --git a/tensorflow_mri/_api/coils/__init__.py b/tensorflow_mri/_api/coils/__init__.py index 3507aab3..300a3855 100644 --- a/tensorflow_mri/_api/coils/__init__.py +++ b/tensorflow_mri/_api/coils/__init__.py @@ -5,6 +5,5 @@ from tensorflow_mri.python.coils.coil_combination import combine_coils as combine_coils from tensorflow_mri.python.coils.coil_compression import compress_coils as compress_coils from tensorflow_mri.python.coils.coil_compression import CoilCompressorSVD as CoilCompressorSVD -from tensorflow_mri.python.coils.coil_compression import compress_coils_universal as compress_coils_universal from tensorflow_mri.python.coils.coil_sensitivities import estimate_sensitivities as estimate_sensitivities from tensorflow_mri.python.coils.coil_sensitivities import estimate_sensitivities_universal as estimate_sensitivities_universal diff --git a/tensorflow_mri/python/activations/__init__.py b/tensorflow_mri/python/activations/__init__.py index 7a69d45e..f7c419e7 100644 --- a/tensorflow_mri/python/activations/__init__.py +++ b/tensorflow_mri/python/activations/__init__.py @@ -137,8 +137,7 @@ def get(identifier): return keras.activations.linear if isinstance(identifier, (str, dict)): return deserialize(identifier) - elif callable(identifier): + if callable(identifier): return identifier - else: - raise ValueError( - f'Could not interpret activation function identifier: {identifier}') + raise ValueError( + f'Could not interpret activation function identifier: {identifier}') diff --git a/tensorflow_mri/python/activations/complex_activations.py b/tensorflow_mri/python/activations/complex_activations.py index 424ed9a9..b3e77711 100644 --- a/tensorflow_mri/python/activations/complex_activations.py +++ b/tensorflow_mri/python/activations/complex_activations.py @@ -21,21 +21,26 @@ from tensorflow_mri.python.util import api_util -def complexified(name, split='real_imag'): - """Returns a decorator to create complex-valued activations.""" - if split not in ('real_imag', 'abs_angle'): +def complexified(name, type_='cartesian'): + """Returns a decorator to create complex-valued activations. + + Args: + name: A `str` denoting the name of the activation function. + + """ + if type_ not in ('cartesian', 'polar'): raise ValueError( - f"split must be one of 'real_imag' or 'abs_angle', but got: {split}") + f"type_ must be one of 'cartesian' or 'polar', but got: {type_}") def decorator(func): def wrapper(x, *args, **kwargs): x = tf.convert_to_tensor(x) if x.dtype.is_complex: - if split == 'abs_angle': + if type_ == 'polar': j = tf.dtypes.complex(tf.zeros((), dtype=x.dtype.real_dtype), tf.ones((), dtype=x.dtype.real_dtype)) return (tf.cast(func(tf.math.abs(x), *args, **kwargs), x.dtype) * tf.math.exp(j * tf.cast(tf.math.angle(x), x.dtype))) - if split == 'real_imag': + if type_ == 'cartesian': return tf.dtypes.complex(func(tf.math.real(x), *args, **kwargs), func(tf.math.imag(x), *args, **kwargs)) return func(x, *args, **kwargs) @@ -47,7 +52,8 @@ def wrapper(x, *args, **kwargs): complex_relu = api_util.export("activations.complex_relu")( - complexified(name='complex_relu', split='real_imag')(tf.keras.activations.relu)) + complexified(name='complex_relu', type_='cartesian')( + tf.keras.activations.relu)) complex_relu.__doc__ = ( """Applies the rectified linear unit activation function. @@ -88,7 +94,8 @@ def wrapper(x, *args, **kwargs): mod_relu = api_util.export("activations.mod_relu")( - complexified(name='mod_relu', split='abs_angle')(tf.keras.activations.relu)) + complexified(name='mod_relu', type_='polar')( + tf.keras.activations.relu)) mod_relu.__doc__ = ( """Applies the rectified linear unit activation function. diff --git a/tensorflow_mri/python/activations/complex_activations_test.py b/tensorflow_mri/python/activations/complex_activations_test.py index 0cfac408..1279d884 100644 --- a/tensorflow_mri/python/activations/complex_activations_test.py +++ b/tensorflow_mri/python/activations/complex_activations_test.py @@ -22,6 +22,8 @@ class ReluTest(test_util.TestCase): + """Tests for ReLU-derived activations.""" + # pylint: disable=missing-function-docstring @test_util.run_all_execution_modes def test_complex_relu(self): inputs = [1.0 - 2.0j, 1.0 + 3.0j, -2.0 + 1.0j, -3.0 - 4.0j] diff --git a/tensorflow_mri/python/coils/coil_combination.py b/tensorflow_mri/python/coils/coil_combination.py index d4e93209..f83aa7ea 100644 --- a/tensorflow_mri/python/coils/coil_combination.py +++ b/tensorflow_mri/python/coils/coil_combination.py @@ -12,6 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== +"""Coil combination.""" import tensorflow as tf diff --git a/tensorflow_mri/python/coils/coil_compression.py b/tensorflow_mri/python/coils/coil_compression.py index 235c8d37..abe81cb5 100644 --- a/tensorflow_mri/python/coils/coil_compression.py +++ b/tensorflow_mri/python/coils/coil_compression.py @@ -71,8 +71,8 @@ def compress_coils(kspace, References: 1. Huang, F., Vijayakumar, S., Li, Y., Hertel, S. and Duensing, G.R. - (2008). A software channel compression technique for faster reconstruction - with many channels. Magn Reson Imaging, 26(1): 133-141. + (2008). A software channel compression technique for faster + reconstruction with many channels. Magn Reson Imaging, 26(1): 133-141. 2. Zhang, T., Pauly, J.M., Vasanawala, S.S. and Lustig, M. (2013), Coil compression for accelerated imaging with Cartesian sampling. Magn Reson Med, 69: 571-582. https://doi.org/10.1002/mrm.24267 @@ -273,6 +273,9 @@ def make_coil_compressor(method, **kwargs): Returns: A `CoilCompressor` object. + + Raises: + NotImplementedError: If the specified method is not implemented. """ method = check_util.validate_enum( method, {'svd', 'geometric', 'espirit'}, name='method') diff --git a/tensorflow_mri/python/coils/coil_sensitivities.py b/tensorflow_mri/python/coils/coil_sensitivities.py index 6d70fad8..89c0a753 100644 --- a/tensorflow_mri/python/coils/coil_sensitivities.py +++ b/tensorflow_mri/python/coils/coil_sensitivities.py @@ -536,7 +536,7 @@ def estimate_sensitivities_universal( Vasanawala, S.S. and Lustig, M. (2014), ESPIRiT—an eigenvalue approach to autocalibrating parallel MRI: Where SENSE meets GRAPPA. Magn. Reson. Med., 71: 990-1001. https://doi.org/10.1002/mrm.24751 - """ + """ # pylint: disable=line-too-long with tf.name_scope(kwargs.get('name', 'estimate_sensitivities_universal')): rank = operator.rank data = tf.convert_to_tensor(data) diff --git a/tensorflow_mri/python/coils/coil_sensitivities_test.py b/tensorflow_mri/python/coils/coil_sensitivities_test.py index 4edca41b..89a0382e 100644 --- a/tensorflow_mri/python/coils/coil_sensitivities_test.py +++ b/tensorflow_mri/python/coils/coil_sensitivities_test.py @@ -100,7 +100,9 @@ def test_walsh_3d(self): class EstimateUniversalTest(test_util.TestCase): + """Tests for `estimate_sensitivities_universal`.""" def test_estimate_sensitivities_universal(self): + """Test `estimate_sensitivities_universal`.""" image_shape = [128, 128] image = image_ops.phantom(shape=image_shape, num_coils=4, dtype=tf.complex64) diff --git a/tensorflow_mri/python/geometry/rotation/rotation_matrix.py b/tensorflow_mri/python/geometry/rotation/rotation_matrix.py index bff15b19..ebc34f2f 100644 --- a/tensorflow_mri/python/geometry/rotation/rotation_matrix.py +++ b/tensorflow_mri/python/geometry/rotation/rotation_matrix.py @@ -42,6 +42,9 @@ def rotate(n, point, matrix): Returns: A `tf.Tensor` of shape `[..., N]`. + + Raises: + ValueError: If the shape of the point or matrix is invalid. """ point = tf.convert_to_tensor(point) matrix = tf.convert_to_tensor(matrix) @@ -81,6 +84,9 @@ def inverse(n, matrix): Returns: A `tf.Tensor` of shape `[..., N, N]`. + + Raises: + ValueError: If the shape of the matrix is invalid. """ matrix = tf.convert_to_tensor(matrix) @@ -101,6 +107,9 @@ def is_valid(n, matrix, atol=1e-3): Returns: A boolean `tf.Tensor` of shape `[..., 1]`. + + Raises: + ValueError: If the shape of the matrix is invalid. """ matrix = tf.convert_to_tensor(matrix) @@ -114,8 +123,8 @@ def is_valid(n, matrix, atol=1e-3): # Computes how far the product of the transposed rotation matrix with itself # is from the identity matrix. identity = tf.eye(n, dtype=matrix.dtype) - inverse = tf.linalg.matrix_transpose(matrix) - distance_identity = tf.matmul(inverse, matrix) - identity + inverse_matrix = tf.linalg.matrix_transpose(matrix) + distance_identity = tf.matmul(inverse_matrix, matrix) - identity distance_identity = tf.norm(distance_identity, axis=[-2, -1]) # Computes the mask of entries that satisfies all conditions. diff --git a/tensorflow_mri/python/geometry/rotation/rotation_matrix_2d.py b/tensorflow_mri/python/geometry/rotation/rotation_matrix_2d.py index 1a178017..72b86655 100644 --- a/tensorflow_mri/python/geometry/rotation/rotation_matrix_2d.py +++ b/tensorflow_mri/python/geometry/rotation/rotation_matrix_2d.py @@ -54,8 +54,8 @@ def from_euler(angle): cos_angle = tf.math.cos(angle) sin_angle = tf.math.sin(angle) - matrix = tf.stack([cos_angle, -sin_angle, sin_angle, cos_angle], axis=-1) - output_shape = tf.concat([tf.shape(angle)[:-1], [2, 2]], axis=-1) + matrix = tf.stack([cos_angle, -sin_angle, sin_angle, cos_angle], axis=-1) # pylint: disable=invalid-unary-operand-type + output_shape = tf.concat([tf.shape(angle)[:-1], [2, 2]], axis=-1) # pylint: disable=unexpected-keyword-arg,no-value-for-parameter return tf.reshape(matrix, output_shape) @@ -80,7 +80,7 @@ def from_small_euler(angle): cos_angle = 1.0 - 0.5 * angle * angle sin_angle = angle matrix = tf.stack([cos_angle, -sin_angle, sin_angle, cos_angle], axis=-1) - output_shape = tf.concat([tf.shape(angle)[:-1], [2, 2]], axis=-1) + output_shape = tf.concat([tf.shape(angle)[:-1], [2, 2]], axis=-1) # pylint: disable=unexpected-keyword-arg,no-value-for-parameter return tf.reshape(matrix, output_shape) diff --git a/tensorflow_mri/python/geometry/rotation/rotation_matrix_3d.py b/tensorflow_mri/python/geometry/rotation/rotation_matrix_3d.py index ed00d534..a9adee2a 100644 --- a/tensorflow_mri/python/geometry/rotation/rotation_matrix_3d.py +++ b/tensorflow_mri/python/geometry/rotation/rotation_matrix_3d.py @@ -81,7 +81,18 @@ def from_small_euler(angles): def from_axis_angle(axis, angle): - """Converts an axis-angle to a 3D rotation matrix.""" + """Converts an axis-angle to a 3D rotation matrix. + + Args: + axis: A `tf.Tensor` of shape `[..., 3]`. + angle: A `tf.Tensor` of shape `[..., 1]`. + + Returns: + A `tf.Tensor` of shape `[..., 3, 3]`. + + Raises: + ValueError: If the shape of `axis` or `angle` is invalid. + """ axis = tf.convert_to_tensor(axis) angle = tf.convert_to_tensor(angle) @@ -93,8 +104,7 @@ def from_axis_angle(axis, angle): f"angle must have shape `[..., 1]`, but got: {angle.shape}") try: - static_batch_shape = tf.broadcast_static_shape( - axis.shape[:-1], angle.shape[:-1]) + _ = tf.broadcast_static_shape(axis.shape[:-1], angle.shape[:-1]) except ValueError as err: raise ValueError( f"The batch shapes of axis and angle do not " @@ -120,16 +130,26 @@ def from_axis_angle(axis, angle): matrix = tf.stack([diag_x, m01, m02, m10, diag_y, m12, m20, m21, diag_z], axis=-1) - output_shape = tf.concat([tf.shape(axis)[:-1], [3, 3]], axis=-1) + output_shape = tf.concat([tf.shape(axis)[:-1], [3, 3]], axis=-1) # pylint: disable=unexpected-keyword-arg,no-value-for-parameter return tf.reshape(matrix, output_shape) def from_quaternion(quaternion): - """Converts a quaternion to a 3D rotation matrix.""" + """Converts a quaternion to a 3D rotation matrix. + + Args: + quaternion: A `tf.Tensor` of shape `[..., 4]`. + + Returns: + A `tf.Tensor` of shape `[..., 3, 3]`. + + Raises: + ValueError: If the shape of `quaternion` is invalid. + """ quaternion = tf.convert_to_tensor(quaternion) if quaternion.shape[-1] != 4: - raise ValueError(f"quaternion must have shape `[..., 4]`, ", + raise ValueError(f"quaternion must have shape `[..., 4]`, " f"but got: {quaternion.shape}") x, y, z, w = tf.unstack(quaternion, axis=-1) @@ -148,7 +168,7 @@ def from_quaternion(quaternion): matrix = tf.stack([1.0 - (tyy + tzz), txy - twz, txz + twy, txy + twz, 1.0 - (txx + tzz), tyz - twx, txz - twy, tyz + twx, 1.0 - (txx + tyy)], axis=-1) - output_shape = tf.concat([tf.shape(quaternion)[:-1], [3, 3]], axis=-1) + output_shape = tf.concat([tf.shape(quaternion)[:-1], [3, 3]], axis=-1) # pylint: disable=unexpected-keyword-arg,no-value-for-parameter return tf.reshape(matrix, output_shape) @@ -182,7 +202,7 @@ def _build_matrix_from_sines_and_cosines(sin_angles, cos_angles): m10, m11, m12, m20, m21, m22], axis=-1) - output_shape = tf.concat([tf.shape(sin_angles)[:-1], [3, 3]], axis=-1) + output_shape = tf.concat([tf.shape(sin_angles)[:-1], [3, 3]], axis=-1) # pylint: disable=unexpected-keyword-arg,no-value-for-parameter return tf.reshape(matrix, output_shape) diff --git a/tensorflow_mri/python/geometry/rotation/test_helpers.py b/tensorflow_mri/python/geometry/rotation/test_helpers.py index cb26aa03..36ca83fa 100644 --- a/tensorflow_mri/python/geometry/rotation/test_helpers.py +++ b/tensorflow_mri/python/geometry/rotation/test_helpers.py @@ -56,13 +56,6 @@ def generate_preset_test_rotation_matrices_2d(): return preset_rotation_matrix -def generate_preset_test_axis_angle(): - """Generates pre-set test rotation matrices.""" - angles = generate_preset_test_euler_angles() - axis, angle = rotation_matrix_3d.from_axis_angle(angles) - return axis, angle - - def generate_preset_test_quaternions(): """Generates pre-set test quaternions.""" angles = generate_preset_test_euler_angles() @@ -83,7 +76,7 @@ def generate_preset_test_dual_quaternions(): preset_quaternion_dual = quaternion.multiply(preset_quaternion_translation, preset_quaternion_real) - preset_dual_quaternion = tf.concat( + preset_dual_quaternion = tf.concat( # pylint: disable=unexpected-keyword-arg,no-value-for-parameter (preset_quaternion_real, preset_quaternion_dual), axis=-1) return preset_dual_quaternion @@ -123,7 +116,7 @@ def generate_random_test_dual_quaternions(): random_quaternion_dual = quaternion.multiply(random_quaternion_translation, random_quaternion_real) - random_dual_quaternion = tf.concat( + random_dual_quaternion = tf.concat( # pylint: disable=unexpected-keyword-arg,no-value-for-parameter (random_quaternion_real, random_quaternion_dual), axis=-1) return random_dual_quaternion @@ -138,7 +131,7 @@ def generate_random_test_euler_angles(dimensions=3, return np.random.uniform(min_angle, max_angle, tensor_tile + [dimensions]) -def generate_random_test_quaternions(tensor_shape=None): +def generate_random_test_quaternions(tensor_shape=None): # pylint: disable=missing-param-doc """Generates random test quaternions.""" if tensor_shape is None: tensor_dimensions = np.random.randint(low=1, high=3) diff --git a/tensorflow_mri/python/geometry/rotation_2d.py b/tensorflow_mri/python/geometry/rotation_2d.py index 84d45ad3..e6a96d71 100644 --- a/tensorflow_mri/python/geometry/rotation_2d.py +++ b/tensorflow_mri/python/geometry/rotation_2d.py @@ -22,7 +22,7 @@ @api_util.export("geometry.Rotation2D") -class Rotation2D(tf.experimental.BatchableExtensionType): +class Rotation2D(tf.experimental.BatchableExtensionType): # pylint: disable=abstract-method """Represents a rotation in 2D space (or a batch thereof). A `Rotation2D` contains all the information needed to represent a rotation @@ -370,12 +370,14 @@ def dtype(self): @tf.experimental.dispatch_for_api(tf.convert_to_tensor, {'value': Rotation2D}) def convert_to_tensor(value, dtype=None, dtype_hint=None, name=None): - return value.as_matrix() + """Overrides `tf.convert_to_tensor` for `Rotation2D` objects.""" + return tf.convert_to_tensor( + value.as_matrix(), dtype=dtype, dtype_hint=dtype_hint, name=name) @tf.experimental.dispatch_for_api( tf.linalg.matmul, {'a': Rotation2D, 'b': Rotation2D}) -def matmul(a, b, +def matmul(a, b, # pylint: disable=missing-param-doc transpose_a=False, transpose_b=False, adjoint_a=False, @@ -384,6 +386,7 @@ def matmul(a, b, b_is_sparse=False, output_type=None, name=None): + """Overrides `tf.linalg.matmul` for `Rotation2D` objects.""" if a_is_sparse or b_is_sparse: raise ValueError("Rotation2D does not support sparse matmul.") return Rotation2D(_matrix=tf.linalg.matmul(a.as_matrix(), b.as_matrix(), @@ -396,12 +399,13 @@ def matmul(a, b, @tf.experimental.dispatch_for_api(tf.linalg.matvec, {'a': Rotation2D}) -def matvec(a, b, +def matvec(a, b, # pylint: disable=missing-param-doc transpose_a=False, adjoint_a=False, a_is_sparse=False, b_is_sparse=False, name=None): + """Overrides `tf.linalg.matvec` for `Rotation2D` objects.""" if a_is_sparse or b_is_sparse: raise ValueError("Rotation2D does not support sparse matvec.") return tf.linalg.matvec(a.as_matrix(), b, @@ -411,5 +415,6 @@ def matvec(a, b, @tf.experimental.dispatch_for_api(tf.shape, {'input': Rotation2D}) -def shape(input, out_type=tf.int32, name=None): +def shape(input, out_type=tf.int32, name=None): # pylint: disable=redefined-builtin + """Overrides `tf.shape` for `Rotation2D` objects.""" return tf.shape(input.as_matrix(), out_type=out_type, name=name) diff --git a/tensorflow_mri/python/geometry/rotation_2d_test.py b/tensorflow_mri/python/geometry/rotation_2d_test.py index 352e72f5..132de2e7 100644 --- a/tensorflow_mri/python/geometry/rotation_2d_test.py +++ b/tensorflow_mri/python/geometry/rotation_2d_test.py @@ -29,6 +29,7 @@ # ============================================================================== """Tests for 2D rotation.""" # This file is partly inspired by TensorFlow Graphics. +# pylint: disable=missing-param-doc from absl.testing import parameterized import numpy as np @@ -107,7 +108,8 @@ def test_convert_to_tensor(self): ("-90", [-np.pi / 2]), ("-135", [-np.pi * 3 / 4]) ) - def test_as_euler(self, angle): + def test_as_euler(self, angle): # pylint: disable=missing-param-doc + """Tests that `as_euler` returns the correct angle.""" rot = Rotation2D.from_euler(angle) self.assertAllClose(angle, rot.as_euler()) diff --git a/tensorflow_mri/python/geometry/rotation_3d.py b/tensorflow_mri/python/geometry/rotation_3d.py index 5b623ce5..b1a95850 100644 --- a/tensorflow_mri/python/geometry/rotation_3d.py +++ b/tensorflow_mri/python/geometry/rotation_3d.py @@ -17,10 +17,9 @@ import tensorflow as tf from tensorflow_mri.python.geometry.rotation import rotation_matrix_3d -from tensorflow_mri.python.util import api_util -class Rotation3D(tf.experimental.BatchableExtensionType): +class Rotation3D(tf.experimental.BatchableExtensionType): # pylint: disable=abstract-method """Represents a rotation in 3D space (or a batch thereof).""" __name__ = "tfmri.geometry.Rotation3D" _matrix: tf.Tensor @@ -253,12 +252,14 @@ def dtype(self): @tf.experimental.dispatch_for_api(tf.convert_to_tensor, {'value': Rotation3D}) def convert_to_tensor(value, dtype=None, dtype_hint=None, name=None): - return value.as_matrix() + """Overrides `tf.convert_to_tensor` for `Rotation3D` objects.""" + return tf.convert_to_tensor( + value.as_matrix(), dtype=dtype, dtype_hint=dtype_hint, name=name) @tf.experimental.dispatch_for_api( tf.linalg.matmul, {'a': Rotation3D, 'b': Rotation3D}) -def matmul(a, b, +def matmul(a, b, # pylint: disable=missing-param-doc transpose_a=False, transpose_b=False, adjoint_a=False, @@ -267,6 +268,7 @@ def matmul(a, b, b_is_sparse=False, output_type=None, name=None): + """Overrides `tf.linalg.matmul` for `Rotation3D` objects.""" if a_is_sparse or b_is_sparse: raise ValueError("Rotation3D does not support sparse matmul.") return Rotation3D(_matrix=tf.linalg.matmul(a.as_matrix(), b.as_matrix(), @@ -279,12 +281,13 @@ def matmul(a, b, @tf.experimental.dispatch_for_api(tf.linalg.matvec, {'a': Rotation3D}) -def matvec(a, b, +def matvec(a, b, # pylint: disable=missing-param-doc transpose_a=False, adjoint_a=False, a_is_sparse=False, b_is_sparse=False, name=None): + """Overrides `tf.linalg.matvec` for `Rotation3D` objects.""" if a_is_sparse or b_is_sparse: raise ValueError("Rotation3D does not support sparse matvec.") return tf.linalg.matvec(a.as_matrix(), b, @@ -294,5 +297,6 @@ def matvec(a, b, @tf.experimental.dispatch_for_api(tf.shape, {'input': Rotation3D}) -def shape(input, out_type=tf.int32, name=None): +def shape(input, out_type=tf.int32, name=None): # pylint: disable=redefined-builtin + """Overrides `tf.shape` for `Rotation3D` objects.""" return tf.shape(input.as_matrix(), out_type=out_type, name=name) diff --git a/tensorflow_mri/python/geometry/rotation_3d_test.py b/tensorflow_mri/python/geometry/rotation_3d_test.py index c212dfa1..93ce456f 100644 --- a/tensorflow_mri/python/geometry/rotation_3d_test.py +++ b/tensorflow_mri/python/geometry/rotation_3d_test.py @@ -28,6 +28,7 @@ # limitations under the License. """Tests for 3D rotation.""" # This file is partly inspired by TensorFlow Graphics. +# pylint: disable=missing-param-doc from absl.testing import parameterized import numpy as np @@ -186,7 +187,8 @@ def test_from_euler_random(self): z_rotation = Rotation3D.from_axis_angle(z_axis, z_angle) expected_matrix = z_rotation @ (y_rotation @ x_rotation) - self.assertAllClose(expected_matrix.as_matrix(), matrix.as_matrix(), rtol=1e-3) + self.assertAllClose(expected_matrix.as_matrix(), matrix.as_matrix(), + rtol=1e-3) def test_from_quaternion_normalized_random(self): """Tests that random quaternions can be converted to rotation matrices.""" diff --git a/tensorflow_mri/python/initializers/__init__.py b/tensorflow_mri/python/initializers/__init__.py index 599b4b60..ef834c19 100644 --- a/tensorflow_mri/python/initializers/__init__.py +++ b/tensorflow_mri/python/initializers/__init__.py @@ -126,13 +126,12 @@ def get(identifier): return None if isinstance(identifier, dict): return deserialize(identifier) - elif isinstance(identifier, str): + if isinstance(identifier, str): identifier = str(identifier) return deserialize(identifier) - elif callable(identifier): + if callable(identifier): if inspect.isclass(identifier): identifier = identifier() return identifier - else: - raise ValueError('Could not interpret initializer identifier: ' + - str(identifier)) + raise ValueError('Could not interpret initializer identifier: ' + + str(identifier)) diff --git a/tensorflow_mri/python/layers/coil_sensitivities.py b/tensorflow_mri/python/layers/coil_sensitivities.py index 5e7321bc..ae756021 100644 --- a/tensorflow_mri/python/layers/coil_sensitivities.py +++ b/tensorflow_mri/python/layers/coil_sensitivities.py @@ -18,9 +18,7 @@ import tensorflow as tf -from tensorflow_mri.python.activations import complex_activations from tensorflow_mri.python.coils import coil_sensitivities -from tensorflow_mri.python.linalg import linear_operator_mri from tensorflow_mri.python.ops import math_ops from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import doc_util diff --git a/tensorflow_mri/python/layers/concatenate.py b/tensorflow_mri/python/layers/concatenate.py index 91123c9f..288ae64c 100644 --- a/tensorflow_mri/python/layers/concatenate.py +++ b/tensorflow_mri/python/layers/concatenate.py @@ -12,6 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== +"""Resize and concatenate layer.""" import tensorflow as tf @@ -20,20 +21,43 @@ @tf.keras.utils.register_keras_serializable(package="MRI") class ResizeAndConcatenate(tf.keras.layers.Layer): + """Resizes and concatenates a list of inputs. + + Similar to `tf.keras.layers.Concatenate`, but if the inputs have different + shapes, they are resized to match the shape of the first input. + + Args: + axis: Axis along which to concatenate. + """ def __init__(self, axis=-1, **kwargs): super().__init__(**kwargs) self.axis = axis - def call(self, inputs): + def call(self, inputs): # pylint: disable=missing-function-docstring if not isinstance(inputs, (list, tuple)): raise ValueError( f"Layer {self.__class__.__name__} expects a list of inputs. " f"Received: {inputs}") - ref = inputs[0] - others = inputs[1:] - others = [tf.ensure_shape( - array_ops.resize_with_crop_or_pad(tensor, tf.shape(ref)), - ref.shape) for tensor in others] + rank = inputs[0].shape.rank + if rank is None: + raise ValueError( + f"Layer {self.__class__.__name__} expects inputs with known rank. " + f"Received: {inputs}") + if self.axis >= rank or self.axis < -rank: + raise ValueError( + f"Layer {self.__class__.__name__} expects `axis` to be in the range " + f"[-{rank}, {rank}) for an input of rank {rank}. " + f"Received: {self.axis}") + + axis = self.axis % rank + shape = tf.tensor_scatter_nd_update(tf.shape(inputs[0]), [[axis]], [-1]) + static_shape = inputs[0].shape.as_list() + static_shape[axis] = None + static_shape = tf.TensorShape(static_shape) + + resized = [tf.ensure_shape( + array_ops.resize_with_crop_or_pad(tensor, shape), + static_shape) for tensor in inputs[1:]] - return tf.concat([ref] + others, axis=self.axis) + return tf.concat(inputs[:1] + resized, axis=self.axis) # pylint: disable=unexpected-keyword-arg,no-value-for-parameter diff --git a/tensorflow_mri/python/layers/concatenate_test.py b/tensorflow_mri/python/layers/concatenate_test.py new file mode 100644 index 00000000..4b0e341d --- /dev/null +++ b/tensorflow_mri/python/layers/concatenate_test.py @@ -0,0 +1,52 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== +"""Tests for `ResizeAndConcatenate` layers.""" + +import tensorflow as tf + +from tensorflow_mri.python.layers import concatenate +from tensorflow_mri.python.util import test_util + + +class ResizeAndConcatenateTest(test_util.TestCase): + """Tests for layer `ResizeAndConcatenate`.""" + def test_resize_and_concatenate(self): + """Test `ResizeAndConcatenate` layer.""" + # Test data. + x1 = tf.constant([[1.0, 2.0], [3.0, 4.0]]) + x2 = tf.constant([[5.0], [6.0]]) + + # Test concatenation along axis 1. + layer = concatenate.ResizeAndConcatenate(axis=-1) + + result = layer([x1, x2]) + self.assertAllClose([[1.0, 2.0, 5.0], [3.0, 4.0, 6.0]], result) + + result = layer([x2, x1]) + self.assertAllClose([[5.0, 1.0, 2.0], [6.0, 3.0, 4.0]], result) + + # Test concatenation along axis 0. + layer = concatenate.ResizeAndConcatenate(axis=0) + + result = layer([x1, x2]) + self.assertAllClose( + [[1.0, 2.0], [3.0, 4.0], [5.0, 0.0], [6.0, 0.0]], result) + + result = layer([x2, x1]) + self.assertAllClose([[5.0], [6.0], [1.0], [3.0]], result) + + +if __name__ == '__main__': + tf.test.main() diff --git a/tensorflow_mri/python/layers/data_consistency.py b/tensorflow_mri/python/layers/data_consistency.py index 965f115d..717738db 100644 --- a/tensorflow_mri/python/layers/data_consistency.py +++ b/tensorflow_mri/python/layers/data_consistency.py @@ -51,7 +51,7 @@ def build(self, input_shape): trainable=self.trainable, constraint=tf.keras.constraints.NonNeg()) - def call(self, inputs): + def call(self, inputs): # pylint: disable=missing-function-docstring image, data, operator = parse_inputs(inputs) if self.reinterpret_complex: image = math_ops.view_as_complex(image, stacked=False) @@ -81,7 +81,7 @@ def _parse_inputs(image, data, operator): return image, data, operator if isinstance(inputs, tuple): return _parse_inputs(*inputs) - elif isinstance(inputs, dict): + if isinstance(inputs, dict): return _parse_inputs(**inputs) raise ValueError('inputs must be a tuple or dict') diff --git a/tensorflow_mri/python/layers/normalization_test.py b/tensorflow_mri/python/layers/normalization_test.py index 64ad22c8..036fbd36 100644 --- a/tensorflow_mri/python/layers/normalization_test.py +++ b/tensorflow_mri/python/layers/normalization_test.py @@ -22,8 +22,10 @@ class NormalizedTest(test_util.TestCase): + """Tests for `Normalized` layer.""" @test_util.run_all_execution_modes def test_normalized_dense(self): + """Tests `Normalized` layer wrapping a `Dense` layer.""" layer = normalization.Normalized( tf.keras.layers.Dense(2, bias_initializer='random_uniform')) layer.build((None, 4)) diff --git a/tensorflow_mri/python/layers/padding.py b/tensorflow_mri/python/layers/padding.py index a5cce20b..a33e1602 100644 --- a/tensorflow_mri/python/layers/padding.py +++ b/tensorflow_mri/python/layers/padding.py @@ -43,7 +43,7 @@ def __init__(self, rank, divisor=2, **kwargs): f'Received: {divisor}') self.input_spec = tf.keras.layers.InputSpec(ndim=rank + 2) - def call(self, inputs): + def call(self, inputs): # pylint: disable=missing-function-docstring static_input_shape = inputs.shape static_output_shape = tuple( ((s + d - 1) // d) * d if s is not None else None for s, d in zip( @@ -52,13 +52,14 @@ def call(self, inputs): static_output_shape).concatenate(static_input_shape[-1:]) input_shape = tf.shape(inputs)[1:-1] - output_shape = ((input_shape + self.divisor - 1) // self.divisor) * self.divisor + output_shape = (((input_shape + self.divisor - 1) // self.divisor) * + self.divisor) left_paddings = (output_shape - input_shape) // 2 right_paddings = (output_shape - input_shape + 1) // 2 paddings = tf.stack([left_paddings, right_paddings], axis=-1) - paddings = tf.pad(paddings, [[1, 1], [0, 0]]) + paddings = tf.pad(paddings, [[1, 1], [0, 0]]) # pylint: disable=no-value-for-parameter - return tf.ensure_shape(tf.pad(inputs, paddings), static_output_shape) + return tf.ensure_shape(tf.pad(inputs, paddings), static_output_shape) # pylint: disable=no-value-for-parameter def get_config(self): config = {'divisor': self.divisor} diff --git a/tensorflow_mri/python/layers/recon_adjoint.py b/tensorflow_mri/python/layers/recon_adjoint.py index db610fe3..5d3f18a9 100644 --- a/tensorflow_mri/python/layers/recon_adjoint.py +++ b/tensorflow_mri/python/layers/recon_adjoint.py @@ -111,7 +111,7 @@ def _parse_inputs(data, operator): return data, operator if isinstance(inputs, tuple): return _parse_inputs(*inputs) - elif isinstance(inputs, dict): + if isinstance(inputs, dict): return _parse_inputs(**inputs) raise ValueError('inputs must be a tuple or dict') diff --git a/tensorflow_mri/python/layers/recon_adjoint_test.py b/tensorflow_mri/python/layers/recon_adjoint_test.py index 2bcd62e2..5e8f170e 100644 --- a/tensorflow_mri/python/layers/recon_adjoint_test.py +++ b/tensorflow_mri/python/layers/recon_adjoint_test.py @@ -13,6 +13,7 @@ # limitations under the License. # ============================================================================== """Tests for module `recon_adjoint`.""" +# pylint: disable=missing-param-doc import os import tempfile @@ -27,8 +28,10 @@ class ReconAdjointTest(test_util.TestCase): + """Tests for `ReconAdjoint` layer.""" @parameterized.product(expand_channel_dim=[True, False]) def test_recon_adjoint(self, expand_channel_dim): + """Test `ReconAdjoint` layer.""" # Create layer. layer = recon_adjoint_layer.ReconAdjoint( expand_channel_dim=expand_channel_dim) diff --git a/tensorflow_mri/python/linalg/linear_operator.py b/tensorflow_mri/python/linalg/linear_operator.py index a4e79c14..6b783426 100644 --- a/tensorflow_mri/python/linalg/linear_operator.py +++ b/tensorflow_mri/python/linalg/linear_operator.py @@ -16,7 +16,6 @@ import abc -import numpy as np import tensorflow as tf from tensorflow.python.framework import type_spec from tensorflow.python.ops.linalg import linear_operator as tf_linear_operator @@ -495,7 +494,7 @@ def _batch_shape_tensor(self): return self.operator.batch_shape_tensor() -class _LinearOperatorSpec(type_spec.BatchableTypeSpec): +class _LinearOperatorSpec(type_spec.BatchableTypeSpec): # pylint: disable=abstract-method """A tf.TypeSpec for `LinearOperator` objects. This is very similar to `tf.linalg.LinearOperatorSpec`, but it adds a diff --git a/tensorflow_mri/python/linalg/linear_operator_gram_matrix.py b/tensorflow_mri/python/linalg/linear_operator_gram_matrix.py index 69e01e45..969dc124 100644 --- a/tensorflow_mri/python/linalg/linear_operator_gram_matrix.py +++ b/tensorflow_mri/python/linalg/linear_operator_gram_matrix.py @@ -104,7 +104,7 @@ def __init__(self, if self._reg_parameter is not None: reg_operator_gm = linear_operator_identity.LinearOperatorScaledIdentity( - shape=self._operator.domain_shape, + domain_shape=self._operator.domain_shape, multiplier=tf.cast(self._reg_parameter, self._operator.dtype)) if self._reg_operator is not None: reg_operator_gm = linear_operator_composition.LinearOperatorComposition( diff --git a/tensorflow_mri/python/linalg/linear_operator_identity.py b/tensorflow_mri/python/linalg/linear_operator_identity.py index df136e6b..6e9778ca 100644 --- a/tensorflow_mri/python/linalg/linear_operator_identity.py +++ b/tensorflow_mri/python/linalg/linear_operator_identity.py @@ -35,9 +35,9 @@ class LinearOperatorScaledIdentity(linear_operator.LinearOperatorMixin, # pylin ``` Args: - domain_shape: A 1D integer `Tensor`. The domain/range domain_shape of the operator. - multiplier: A `tf.Tensor` of arbitrary domain_shape. Its domain_shape will become the - batch domain_shape of the operator. Its dtype will determine the dtype of the + domain_shape: A 1D integer `Tensor`. The domain/range shape of the operator. + multiplier: A `tf.Tensor` of arbitrary shape. Its shape will become the + batch shape of the operator. Its dtype will determine the dtype of the operator. is_non_singular: Expect that this operator is non-singular. is_self_adjoint: Expect that this operator is equal to its hermitian @@ -49,7 +49,7 @@ class LinearOperatorScaledIdentity(linear_operator.LinearOperatorMixin, # pylin https://en.wikipedia.org/wiki/Positive-definite_matrix#Extension_for_non-symmetric_matrices is_square: Expect that this operator acts like square [batch] matrices. assert_proper_shapes: A boolean. If `False`, only perform static - checks that initialization and method arguments have proper domain_shape. + checks that initialization and method arguments have proper shape. If `True`, and static checks are inconclusive, add asserts to the graph. name: A name for this `LinearOperator`. """ diff --git a/tensorflow_mri/python/linalg/linear_operator_mri.py b/tensorflow_mri/python/linalg/linear_operator_mri.py index d9743225..6a55d976 100644 --- a/tensorflow_mri/python/linalg/linear_operator_mri.py +++ b/tensorflow_mri/python/linalg/linear_operator_mri.py @@ -271,9 +271,11 @@ def __init__(self, f"compatible with {self._image_shape_static}, but got: " f"{sensitivities.shape[-self._rank:]}") self._batch_shape_static = tf.broadcast_static_shape( - self._batch_shape_static, sensitivities.shape[:-(self._rank + 1)]) + self._batch_shape_static, + sensitivities.shape[:-(self._rank + 1)]) self._batch_shape_dynamic = tf.broadcast_dynamic_shape( - self._batch_shape_dynamic, tf.shape(sensitivities)[:-(self._rank + 1)]) + self._batch_shape_dynamic, + tf.shape(sensitivities)[:-(self._rank + 1)]) self._sensitivities = sensitivities if phase is not None: diff --git a/tensorflow_mri/python/losses/iqa_losses.py b/tensorflow_mri/python/losses/iqa_losses.py index d50764b0..0db4a349 100644 --- a/tensorflow_mri/python/losses/iqa_losses.py +++ b/tensorflow_mri/python/losses/iqa_losses.py @@ -22,7 +22,6 @@ from tensorflow_mri.python.ops import image_ops from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util -from tensorflow_mri.python.util import deprecation from tensorflow_mri.python.util import keras_util diff --git a/tensorflow_mri/python/metrics/iqa_metrics.py b/tensorflow_mri/python/metrics/iqa_metrics.py index 7e8182fb..62217ed4 100755 --- a/tensorflow_mri/python/metrics/iqa_metrics.py +++ b/tensorflow_mri/python/metrics/iqa_metrics.py @@ -22,7 +22,6 @@ from tensorflow_mri.python.ops import image_ops from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util -from tensorflow_mri.python.util import deprecation class MeanMetricWrapperIQA(tf.keras.metrics.MeanMetricWrapper): diff --git a/tensorflow_mri/python/models/conv_blocks_test.py b/tensorflow_mri/python/models/conv_blocks_test.py index b97b2b26..15c60c07 100644 --- a/tensorflow_mri/python/models/conv_blocks_test.py +++ b/tensorflow_mri/python/models/conv_blocks_test.py @@ -43,6 +43,7 @@ def test_conv_block_creation(self, rank, filters, kernel_size): # pylint: disabl self.assertAllEqual(features.shape, [1] + [128] * rank + [filters]) def test_complex_valued(self): + """Tests complex-valued conv block.""" inputs = tf.dtypes.complex( tf.random.stateless_normal(shape=(2, 32, 32, 4), seed=[12, 34]), tf.random.stateless_normal(shape=(2, 32, 32, 4), seed=[56, 78])) @@ -87,9 +88,11 @@ def test_serialize_deserialize(self): self.assertAllEqual(block2.get_config(), block.get_config()) def test_arch(self): + """Tests the architecture of the block.""" tf.keras.backend.clear_session() inputs = tf.keras.Input(shape=(32, 32, 4)) - model = conv_blocks.ConvBlock2D(filters=16, kernel_size=3).functional(inputs) + model = conv_blocks.ConvBlock2D( + filters=16, kernel_size=3).functional(inputs) expected = [ # name, type, output_shape, params @@ -100,9 +103,11 @@ def test_arch(self): self._check_layers(expected, model.layers) def test_multilayer(self): + """Tests the architecture of the block with multiple layers.""" tf.keras.backend.clear_session() inputs = tf.keras.Input(shape=(32, 32, 4)) - model = conv_blocks.ConvBlock2D(filters=[8, 16], kernel_size=3).functional(inputs) + model = conv_blocks.ConvBlock2D( + filters=[8, 16], kernel_size=3).functional(inputs) expected = [ # name, type, output_shape, params @@ -115,6 +120,7 @@ def test_multilayer(self): self._check_layers(expected, model.layers) def test_arch_activation(self): + """Tests the architecture of the block with activation.""" tf.keras.backend.clear_session() inputs = tf.keras.Input(shape=(32, 32, 4)) model = conv_blocks.ConvBlock2D( @@ -131,6 +137,7 @@ def test_arch_activation(self): self.assertEqual(tf.keras.activations.sigmoid, model.layers[-1].activation) def test_arch_output_activation(self): + """Tests the architecture of the block with output activation.""" tf.keras.backend.clear_session() inputs = tf.keras.Input(shape=(32, 32, 4)) model = conv_blocks.ConvBlock2D( @@ -153,6 +160,7 @@ def test_arch_output_activation(self): self.assertEqual(tf.keras.activations.tanh, model.layers[4].activation) def test_arch_batch_norm(self): + """Tests the architecture of the block with batch norm.""" tf.keras.backend.clear_session() inputs = tf.keras.Input(shape=(32, 32, 4)) model = conv_blocks.ConvBlock2D( @@ -162,12 +170,14 @@ def test_arch_batch_norm(self): # name, type, output_shape, params ('input_1', tf.keras.layers.InputLayer, [(None, 32, 32, 4)], 0), ('conv2d', convolutional.Conv2D, (None, 32, 32, 16), 592), - ('batch_normalization', tf.keras.layers.BatchNormalization, (None, 32, 32, 16), 64), + ('batch_normalization', + tf.keras.layers.BatchNormalization, (None, 32, 32, 16), 64), ('activation', tf.keras.layers.Activation, (None, 32, 32, 16), 0) ] self._check_layers(expected, model.layers) def test_arch_dropout(self): + """Tests the architecture of the block with dropout.""" tf.keras.backend.clear_session() inputs = tf.keras.Input(shape=(32, 32, 4)) model = conv_blocks.ConvBlock2D( @@ -183,6 +193,7 @@ def test_arch_dropout(self): self._check_layers(expected, model.layers) def test_arch_lstm(self): + """Tests the architecture of the LSTM block.""" tf.keras.backend.clear_session() inputs = tf.keras.Input(shape=(None, 32, 32, 4)) model = conv_blocks.ConvBlockLSTM2D( @@ -191,7 +202,8 @@ def test_arch_lstm(self): expected = [ # name, type, output_shape, params ('input_1', tf.keras.layers.InputLayer, [(None, None, 32, 32, 4)], 0), - ('conv_lstm2d', tf.keras.layers.ConvLSTM2D, (None, None, 32, 32, 16), 11584), + ('conv_lstm2d', + tf.keras.layers.ConvLSTM2D, (None, None, 32, 32, 16), 11584), ('activation', tf.keras.layers.Activation, (None, None, 32, 32, 16), 0), ] self._check_layers(expected, model.layers) @@ -199,6 +211,7 @@ def test_arch_lstm(self): self.assertFalse(model.layers[1].stateful) def test_arch_lstm_stateful(self): + """Tests the architecture of the stateful LSTM block.""" tf.keras.backend.clear_session() inputs = tf.keras.Input(shape=(6, 32, 32, 4), batch_size=2) model = conv_blocks.ConvBlockLSTM2D( @@ -215,6 +228,7 @@ def test_arch_lstm_stateful(self): self.assertTrue(model.layers[1].stateful) def test_reset_states(self): + """Tests the reset_states method.""" tf.keras.backend.clear_session() model = conv_blocks.ConvBlockLSTM2D( filters=16, kernel_size=3, stateful=True) diff --git a/tensorflow_mri/python/models/conv_endec.py b/tensorflow_mri/python/models/conv_endec.py index b5c8c6cb..8524dccd 100644 --- a/tensorflow_mri/python/models/conv_endec.py +++ b/tensorflow_mri/python/models/conv_endec.py @@ -448,7 +448,8 @@ def __init__(self, recurrent_regularizer=None, **kwargs): self.stateful = stateful - self.recurrent_regularizer = tf.keras.regularizers.get(recurrent_regularizer) + self.recurrent_regularizer = tf.keras.regularizers.get( + recurrent_regularizer) super().__init__(rank=rank, filters=filters, kernel_size=kernel_size, diff --git a/tensorflow_mri/python/models/conv_endec_test.py b/tensorflow_mri/python/models/conv_endec_test.py index 069c5bfa..3cb24142 100644 --- a/tensorflow_mri/python/models/conv_endec_test.py +++ b/tensorflow_mri/python/models/conv_endec_test.py @@ -18,7 +18,6 @@ from absl.testing import parameterized import tensorflow as tf -from tensorflow_mri.python.activations import complex_activations from tensorflow_mri.python.layers import convolutional from tensorflow_mri.python.layers import pooling from tensorflow_mri.python.layers import reshaping @@ -90,6 +89,7 @@ def test_use_bias(self, use_bias): self.assertEqual(use_bias, layer.use_bias) def test_complex_valued(self): + """Test complex-valued U-Net.""" inputs = tf.dtypes.complex( tf.random.stateless_normal(shape=(2, 32, 32, 4), seed=[12, 34]), tf.random.stateless_normal(shape=(2, 32, 32, 4), seed=[56, 78])) @@ -277,13 +277,19 @@ def test_arch_lstm(self): expected = [ # name, type, output_shape, params ('input_1', tf.keras.layers.InputLayer, [(1, 4, 32, 32, 1)], 0), - ('conv_block_lstm2d', conv_blocks.ConvBlockLSTM2D, (1, 4, 32, 32, 8), 7264), - ('time_distributed', tf.keras.layers.TimeDistributed, (1, 4, 16, 16, 8), 0), - ('conv_block_lstm2d_1', conv_blocks.ConvBlockLSTM2D, (1, 4, 16, 16, 16), 32384), - ('time_distributed_1', tf.keras.layers.TimeDistributed, (1, 4, 32, 32, 16), 0), - ('time_distributed_2', tf.keras.layers.TimeDistributed, (1, 4, 32, 32, 8), 1160), + ('conv_block_lstm2d', + conv_blocks.ConvBlockLSTM2D, (1, 4, 32, 32, 8), 7264), + ('time_distributed', + tf.keras.layers.TimeDistributed, (1, 4, 16, 16, 8), 0), + ('conv_block_lstm2d_1', + conv_blocks.ConvBlockLSTM2D, (1, 4, 16, 16, 16), 32384), + ('time_distributed_1', + tf.keras.layers.TimeDistributed, (1, 4, 32, 32, 16), 0), + ('time_distributed_2', + tf.keras.layers.TimeDistributed, (1, 4, 32, 32, 8), 1160), ('concatenate', tf.keras.layers.Concatenate, (1, 4, 32, 32, 16), 0), - ('conv_block_lstm2d_2', conv_blocks.ConvBlockLSTM2D, (1, 4, 32, 32, 8), 11584)] + ('conv_block_lstm2d_2', + conv_blocks.ConvBlockLSTM2D, (1, 4, 32, 32, 8), 11584)] self._check_layers(expected, model.layers) diff --git a/tensorflow_mri/python/models/graph_like_network.py b/tensorflow_mri/python/models/graph_like_network.py index e03744cf..0f37a0d7 100644 --- a/tensorflow_mri/python/models/graph_like_network.py +++ b/tensorflow_mri/python/models/graph_like_network.py @@ -12,17 +12,18 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== +"""Graph-like network.""" import tensorflow as tf class GraphLikeNetwork(tf.keras.Model): - """A model with graph-like structure. + """Base class for models with graph-like structure. Adds a method `functional` that returns a functional model with the same architecture as the current model. Functional models have some advantages over subclassing as described in https://www.tensorflow.org/guide/keras/functional#when_to_use_the_functional_api. - """ + """ # pylint: disable=line-too-long def functional(self, inputs): return tf.keras.Model(inputs, self.call(inputs)) diff --git a/tensorflow_mri/python/ops/array_ops.py b/tensorflow_mri/python/ops/array_ops.py index 99f4fc1a..1fa36927 100644 --- a/tensorflow_mri/python/ops/array_ops.py +++ b/tensorflow_mri/python/ops/array_ops.py @@ -120,22 +120,22 @@ def dynamic_meshgrid(vecs): output_shape = tf.TensorArray( dtype=tf.int32, size=vecs.size(), element_shape=()) - def _cond(i, vecs, shape): # pylint:disable=unused-argument + def _cond1(i, vecs, shape): # pylint:disable=unused-argument return i < vecs.size() - def _body(i, vecs, shape): + def _body1(i, vecs, shape): vec = vecs.read(i) shape = shape.write(i, tf.shape(vec)[0]) return i + 1, vecs, shape - _, _, output_shape = tf.while_loop(_cond, _body, [0, vecs, output_shape]) + _, _, output_shape = tf.while_loop(_cond1, _body1, [0, vecs, output_shape]) output_shape = output_shape.stack() # Compute output grid. output_grid = tf.TensorArray(dtype=vecs.dtype, size=vecs.size()) - def _cond(i, vecs, grid): # pylint:disable=unused-argument + def _cond2(i, vecs, grid): # pylint:disable=unused-argument return i < vecs.size() - def _body(i, vecs, grid): + def _body2(i, vecs, grid): vec = vecs.read(i) vec_shape = tf.ones(shape=[vecs.size()], dtype=tf.int32) vec_shape = tf.tensor_scatter_nd_update(vec_shape, [[i]], [-1]) @@ -143,7 +143,7 @@ def _body(i, vecs, grid): grid = grid.write(i, tf.broadcast_to(vec, output_shape)) return i + 1, vecs, grid - _, _, output_grid = tf.while_loop(_cond, _body, [0, vecs, output_grid]) + _, _, output_grid = tf.while_loop(_cond2, _body2, [0, vecs, output_grid]) output_grid = output_grid.stack() perm = tf.concat([tf.range(1, vecs.size() + 1), [0]], 0) diff --git a/tensorflow_mri/python/ops/fft_ops_test.py b/tensorflow_mri/python/ops/fft_ops_test.py index 2b024036..c4033ea1 100644 --- a/tensorflow_mri/python/ops/fft_ops_test.py +++ b/tensorflow_mri/python/ops/fft_ops_test.py @@ -33,26 +33,23 @@ import itertools import unittest +from absl.testing import parameterized import numpy as np import tensorflow as tf - -from tensorflow_mri.python.ops import fft_ops -from tensorflow_mri.python.util import test_util - - -from absl.testing import parameterized - from tensorflow.core.protobuf import config_pb2 from tensorflow.python.eager import context from tensorflow.python.framework import dtypes from tensorflow.python.framework import errors -# from tensorflow.python.framework import test_util from tensorflow.python.ops import array_ops from tensorflow.python.ops import gen_spectral_ops from tensorflow.python.ops import gradient_checker_v2 from tensorflow.python.ops import math_ops from tensorflow.python.platform import test +from tensorflow_mri.python.ops import fft_ops +from tensorflow_mri.python.util import test_util + + VALID_FFT_RANKS = (1, 2, 3) diff --git a/tensorflow_mri/python/ops/image_ops.py b/tensorflow_mri/python/ops/image_ops.py index c269825b..7b8f8c29 100644 --- a/tensorflow_mri/python/ops/image_ops.py +++ b/tensorflow_mri/python/ops/image_ops.py @@ -31,7 +31,6 @@ from tensorflow_mri.python.ops import array_ops from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util -from tensorflow_mri.python.util import deprecation @api_util.export("image.psnr") @@ -949,7 +948,8 @@ def _gradient_operators(method, norm=False, image_dims=2, dtype=tf.float32): method: A `str`. The gradient operator. Must be one of `'prewitt'`, `'sobel'` or `'scharr'`. norm: A `boolean`. If `True`, returns normalized kernels. - rank: An `int`. The dimensionality of the requested kernels. Defaults to 2. + image_dims: An `int`. The dimensionality of the requested kernels. + Defaults to 2. dtype: The `dtype` of the returned kernels. Defaults to `tf.float32`. Returns: @@ -1180,7 +1180,11 @@ def gmsd2d(img1, img2, max_val=1.0, name=None): in IEEE Transactions on Image Processing, vol. 23, no. 2, pp. 684-695, Feb. 2014, doi: 10.1109/TIP.2013.2293423. """ - return gmsd(img1, img2, max_val=max_val, image_dims=2, name=(name or 'gmsd2d')) + return gmsd(img1, + img2, + max_val=max_val, + image_dims=2, + name=(name or 'gmsd2d')) @api_util.export("image.gmsd3d") @@ -1210,7 +1214,11 @@ def gmsd3d(img1, img2, max_val=1.0, name=None): in IEEE Transactions on Image Processing, vol. 23, no. 2, pp. 684-695, Feb. 2014, doi: 10.1109/TIP.2013.2293423. """ - return gmsd(img1, img2, max_val=max_val, image_dims=3, name=(name or 'gmsd3d')) + return gmsd(img1, + img2, + max_val=max_val, + image_dims=3, + name=(name or 'gmsd3d')) def _validate_iqa_inputs(img1, img2, max_val, batch_dims, image_dims): diff --git a/tensorflow_mri/python/ops/image_ops_test.py b/tensorflow_mri/python/ops/image_ops_test.py index 883ca081..40564995 100644 --- a/tensorflow_mri/python/ops/image_ops_test.py +++ b/tensorflow_mri/python/ops/image_ops_test.py @@ -43,7 +43,7 @@ def test_psnr_2d_scalar(self): img1 = tf.expand_dims(img1, -1) img2 = tf.expand_dims(img2, -1) - result = image_ops.psnr(img1, img2, max_val=255, rank=2) + result = image_ops.psnr(img1, img2, max_val=255, image_dims=2) self.assertAllClose(result, 22.73803845) result = image_ops.psnr2d(img1, img2, max_val=255) @@ -60,7 +60,7 @@ def test_psnr_2d_trivial_batch(self): img1 = tf.expand_dims(img1, 0) img2 = tf.expand_dims(img2, 0) - result = image_ops.psnr(img1, img2, max_val=255, rank=2) + result = image_ops.psnr(img1, img2, max_val=255, image_dims=2) self.assertAllClose(result, [22.73803845]) @test_util.run_in_graph_and_eager_modes @@ -94,7 +94,7 @@ def test_psnr_2d_nd_batch(self): [17.80788841, 18.18428580], [18.06558658, 17.16817389]] - result = image_ops.psnr(img1, img2, max_val=255, rank=2) + result = image_ops.psnr(img1, img2, max_val=255, image_dims=2) self.assertAllClose(result, ref) @test_util.run_in_graph_and_eager_modes @@ -132,7 +132,7 @@ def test_psnr_3d_scalar(self): img1 = tf.expand_dims(img1, -1) img2 = tf.expand_dims(img2, -1) - result = image_ops.psnr(img1, img2, rank=3) + result = image_ops.psnr(img1, img2, image_dims=3) self.assertAllClose(result, 32.3355765) @test_util.run_in_graph_and_eager_modes @@ -170,7 +170,7 @@ def test_psnr_3d_mdbatch(self): img1 = tf.reshape(img1, (3, 2) + img1.shape[1:]) img2 = tf.reshape(img2, (3, 2) + img2.shape[1:]) - result = image_ops.psnr(img1, img2, max_val=255, rank=3) + result = image_ops.psnr(img1, img2, max_val=255, image_dims=3) self.assertAllClose(result, ref, rtol=1e-3, atol=1e-3) result = image_ops.psnr3d(img1, img2, max_val=255) @@ -190,7 +190,7 @@ def test_psnr_3d_multichannel(self): img1 = tf.transpose(img1, [0, 2, 3, 4, 1]) img2 = tf.transpose(img2, [0, 2, 3, 4, 1]) - result = image_ops.psnr(img1, img2, max_val=255, rank=3) + result = image_ops.psnr(img1, img2, max_val=255, image_dims=3) self.assertAllClose(result, ref, rtol=1e-4, atol=1e-4) def test_psnr_invalid_rank(self): @@ -228,7 +228,7 @@ def test_msssim_2d_scalar(self): img1 = tf.expand_dims(img1, -1) img2 = tf.expand_dims(img2, -1) - result = image_ops.ssim_multiscale(img1, img2, max_val=255, rank=2) + result = image_ops.ssim_multiscale(img1, img2, max_val=255, image_dims=2) self.assertAllClose(result, 0.8270784) result = image_ops.ssim2d_multiscale(img1, img2, max_val=255) @@ -245,7 +245,7 @@ def test_msssim_2d_trivial_batch(self): img1 = tf.expand_dims(img1, 0) img2 = tf.expand_dims(img2, 0) - result = image_ops.ssim_multiscale(img1, img2, max_val=255, rank=2) + result = image_ops.ssim_multiscale(img1, img2, max_val=255, image_dims=2) self.assertAllClose(result, [0.8270784]) @test_util.run_in_graph_and_eager_modes @@ -279,7 +279,7 @@ def test_msssim_2d_nd_batch(self): [0.71863150, 0.76113180], [0.77840980, 0.71724670]] - result = image_ops.ssim_multiscale(img1, img2, max_val=255, rank=2) + result = image_ops.ssim_multiscale(img1, img2, max_val=255, image_dims=2) self.assertAllClose(result, ref, rtol=1e-5, atol=1e-5) result = image_ops.ssim2d_multiscale(img1, img2, max_val=255) @@ -330,7 +330,7 @@ def test_msssim_3d_scalar(self): # img1 = tf.expand_dims(img1, -1) # img2 = tf.expand_dims(img2, -1) - # result = image_ops.ssim_multiscale(img1, img2, rank=3) + # result = image_ops.ssim_multiscale(img1, img2, image_dims=3) # self.assertAllClose(result, 0.96301770) @@ -579,7 +579,7 @@ def test_2d_scalar_batch(self): img1 = tf.expand_dims(img1, -1) img2 = tf.expand_dims(img2, -1) - result = self.test_fn(img1, img2, max_val=255, rank=2) + result = self.test_fn(img1, img2, max_val=255, image_dims=2) self.assertAllClose(result, self.expected[test_name], rtol=1e-5, atol=1e-5) @@ -604,7 +604,7 @@ def test_2d_trivial_batch(self): img1 = tf.expand_dims(img1, 0) img2 = tf.expand_dims(img2, 0) - result = self.test_fn(img1, img2, max_val=255, rank=2) + result = self.test_fn(img1, img2, max_val=255, image_dims=2) self.assertAllClose(result, self.expected[test_name], rtol=1e-5, atol=1e-5) @@ -648,7 +648,7 @@ def test_2d_nd_batch(self): img1 = tf.reshape(img1, (3, 2) + img1.shape[1:]) img2 = tf.reshape(img2, (3, 2) + img2.shape[1:]) - result = self.test_fn(img1, img2, max_val=255, rank=2) + result = self.test_fn(img1, img2, max_val=255, image_dims=2) self.assertAllClose(result, self.expected[test_name], rtol=1e-4, atol=1e-4) @@ -686,7 +686,7 @@ def test_3d_scalar_batch(self): img1 = tf.expand_dims(img1, -1) img2 = tf.expand_dims(img2, -1) - result = self.test_fn(img1, img2, rank=3) + result = self.test_fn(img1, img2, image_dims=3) self.assertAllClose(result, self.expected[test_name]) @test_util.run_in_graph_and_eager_modes @@ -786,7 +786,7 @@ def test_default_3d(self): result = image_ops.phantom(shape=[128, 128, 128]) self.assertAllClose(result, expected) - @parameterized.product(rank=[2, 3], + @parameterized.product(image_dims=[2, 3], dtype=[tf.float32, tf.complex64]) @test_util.run_in_graph_and_eager_modes def test_parallel_imaging(self, rank, dtype): # pylint: disable=missing-param-doc diff --git a/tensorflow_mri/python/ops/recon_ops.py b/tensorflow_mri/python/ops/recon_ops.py index be7c5d38..7655d6f1 100644 --- a/tensorflow_mri/python/ops/recon_ops.py +++ b/tensorflow_mri/python/ops/recon_ops.py @@ -35,7 +35,6 @@ from tensorflow_mri.python.ops import signal_ops from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import check_util -from tensorflow_mri.python.util import deprecation @api_util.export("recon.least_squares", "recon.lstsq") diff --git a/tensorflow_mri/python/ops/signal_ops.py b/tensorflow_mri/python/ops/signal_ops.py index 678851a9..aa36342c 100644 --- a/tensorflow_mri/python/ops/signal_ops.py +++ b/tensorflow_mri/python/ops/signal_ops.py @@ -101,7 +101,7 @@ def atanfilt(arg, cutoff=np.pi, beta=100.0, name=None): @api_util.export("signal.rect") def rect(arg, cutoff=np.pi, name=None): - """Returns the rectangular function. + r"""Returns the rectangular function. The rectangular function is defined as: diff --git a/tensorflow_mri/python/ops/traj_ops.py b/tensorflow_mri/python/ops/traj_ops.py index 591b2593..bbe6843d 100755 --- a/tensorflow_mri/python/ops/traj_ops.py +++ b/tensorflow_mri/python/ops/traj_ops.py @@ -137,7 +137,7 @@ def frequency_grid(shape, max_val=1.0): infer_shape=False, clear_after_read=False) - def _cond(i, vecs): + def _cond(i, vecs): # pylint: disable=unused-argument return tf.less(i, tf.size(shape)) def _body(i, vecs): step = (2.0 * max_val) / tf.cast(shape[i], dtype) diff --git a/tensorflow_mri/python/ops/traj_ops_test.py b/tensorflow_mri/python/ops/traj_ops_test.py index 476f38f2..64efc8bf 100755 --- a/tensorflow_mri/python/ops/traj_ops_test.py +++ b/tensorflow_mri/python/ops/traj_ops_test.py @@ -49,23 +49,28 @@ def test_density(self, transition_type): # pylint: disable=missing-function-doc class FrequencyGridTest(test_util.TestCase): + """Tests for `frequency_grid`.""" def test_frequency_grid_even(self): + """Tests `frequency_grid` with even number of points.""" result = traj_ops.frequency_grid([4]) expected = [[-1.0], [-0.5], [0], [0.5]] self.assertDTypeEqual(result, np.float32) self.assertAllClose(expected, result) def test_frequency_grid_odd(self): + """Tests `frequency_grid` with odd number of points.""" result = traj_ops.frequency_grid([5]) expected = [[-1.0], [-0.5], [0], [0.5], [1.0]] self.assertAllClose(expected, result) def test_frequency_grid_max_val(self): + """Tests `frequency_grid` with a different max value.""" result = traj_ops.frequency_grid([4], max_val=2.0) expected = [[-2.0], [-1.0], [0], [1.0]] self.assertAllClose(expected, result) def test_frequency_grid_2d(self): + """Tests 2-dimensional `frequency_grid`.""" result = traj_ops.frequency_grid([4, 8]) expected = [[[-1. , -1. ], [-1. , -0.75], @@ -102,8 +107,10 @@ def test_frequency_grid_2d(self): self.assertAllClose(expected, result) -class CentralMaskTest(test_util.TestCase): +class CenterMaskTest(test_util.TestCase): + """Tests for `center_mask`.""" def test_center_mask(self): + """Tests `center_mask`.""" result = traj_ops.center_mask([8], [4]) expected = [0, 0, 1, 1, 1, 1, 0, 0] self.assertAllClose(expected, result) @@ -140,7 +147,9 @@ def test_center_mask(self): class AccelMaskTest(test_util.TestCase): + """Tests for `accel_mask`.""" def test_accel_mask(self): + """Tests `accel_mask`.""" result = traj_ops.accel_mask([16], [4], [0]) expected = [1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0] self.assertAllClose(expected, result) diff --git a/tensorflow_mri/python/recon/recon_adjoint_test.py b/tensorflow_mri/python/recon/recon_adjoint_test.py index dfb55cf1..0bd8e1d1 100644 --- a/tensorflow_mri/python/recon/recon_adjoint_test.py +++ b/tensorflow_mri/python/recon/recon_adjoint_test.py @@ -46,7 +46,8 @@ def test_adj_fft(self): self.assertAllClose(expected, image) # Test multi-coil. - image = recon_adjoint.recon_adjoint_mri(kspace, image_shape, sensitivities=sens) + image = recon_adjoint.recon_adjoint_mri( + kspace, image_shape, sensitivities=sens) expected = fft_ops.ifftn(kspace, axes=[-2, -1], norm='ortho', shift=True) scale = tf.math.reduce_sum(sens * tf.math.conj(sens), axis=0) expected = tf.math.divide_no_nan( diff --git a/tensorflow_mri/python/util/layer_util.py b/tensorflow_mri/python/util/layer_util.py index 8b0d4992..cb323d81 100644 --- a/tensorflow_mri/python/util/layer_util.py +++ b/tensorflow_mri/python/util/layer_util.py @@ -50,8 +50,10 @@ def get_nd_layer(name, rank): ('AveragePooling', 1): pooling.AveragePooling1D, ('AveragePooling', 2): pooling.AveragePooling2D, ('AveragePooling', 3): pooling.AveragePooling3D, - ('CoilSensitivityEstimation', 2): coil_sensitivities.CoilSensitivityEstimation2D, - ('CoilSensitivityEstimation', 3): coil_sensitivities.CoilSensitivityEstimation3D, + ('CoilSensitivityEstimation', 2): + coil_sensitivities.CoilSensitivityEstimation2D, + ('CoilSensitivityEstimation', 3): + coil_sensitivities.CoilSensitivityEstimation3D, ('Conv', 1): convolutional.Conv1D, ('Conv', 2): convolutional.Conv2D, ('Conv', 3): convolutional.Conv3D, @@ -81,8 +83,10 @@ def get_nd_layer(name, rank): ('IDWT', 1): signal_layers.IDWT1D, ('IDWT', 2): signal_layers.IDWT2D, ('IDWT', 3): signal_layers.IDWT3D, - ('LeastSquaresGradientDescent', 2): data_consistency.LeastSquaresGradientDescent2D, - ('LeastSquaresGradientDescent', 3): data_consistency.LeastSquaresGradientDescent3D, + ('LeastSquaresGradientDescent', 2): + data_consistency.LeastSquaresGradientDescent2D, + ('LeastSquaresGradientDescent', 3): + data_consistency.LeastSquaresGradientDescent3D, ('LocallyConnected', 1): tf.keras.layers.LocallyConnected1D, ('LocallyConnected', 2): tf.keras.layers.LocallyConnected2D, ('MaxPool', 1): pooling.MaxPooling1D, diff --git a/tensorflow_mri/python/util/model_util.py b/tensorflow_mri/python/util/model_util.py index 01becf9c..2ea8d80d 100644 --- a/tensorflow_mri/python/util/model_util.py +++ b/tensorflow_mri/python/util/model_util.py @@ -14,8 +14,6 @@ # ============================================================================== """Model utilities.""" -import tensorflow as tf - from tensorflow_mri.python.models import conv_blocks from tensorflow_mri.python.models import conv_endec From d44076822563dad9b82487574410d1b0a0b1a900 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 7 Sep 2022 15:10:35 +0000 Subject: [PATCH 093/101] Linting --- tensorflow_mri/python/activations/complex_activations.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tensorflow_mri/python/activations/complex_activations.py b/tensorflow_mri/python/activations/complex_activations.py index b3e77711..e1ea921b 100644 --- a/tensorflow_mri/python/activations/complex_activations.py +++ b/tensorflow_mri/python/activations/complex_activations.py @@ -26,7 +26,12 @@ def complexified(name, type_='cartesian'): Args: name: A `str` denoting the name of the activation function. + type_: A `str` denoting the type of the complex-valued activation function. + Must be one of `'cartesian'` or `'polar'`. + Returns: + A decorator to convert real-valued activations to complex-valued + activations. """ if type_ not in ('cartesian', 'polar'): raise ValueError( From 0904474c2f47b11a8377c52662b896f71d65b63d Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 7 Sep 2022 17:42:38 +0000 Subject: [PATCH 094/101] Fixed lost static information in ResizeAndConcatenate layer --- tensorflow_mri/python/layers/concatenate.py | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/tensorflow_mri/python/layers/concatenate.py b/tensorflow_mri/python/layers/concatenate.py index 288ae64c..5a894631 100644 --- a/tensorflow_mri/python/layers/concatenate.py +++ b/tensorflow_mri/python/layers/concatenate.py @@ -49,15 +49,19 @@ def call(self, inputs): # pylint: disable=missing-function-docstring f"Layer {self.__class__.__name__} expects `axis` to be in the range " f"[-{rank}, {rank}) for an input of rank {rank}. " f"Received: {self.axis}") - + # Canonical axis (always positive). axis = self.axis % rank + + # Resize inputs. shape = tf.tensor_scatter_nd_update(tf.shape(inputs[0]), [[axis]], [-1]) - static_shape = inputs[0].shape.as_list() - static_shape[axis] = None - static_shape = tf.TensorShape(static_shape) + resized = [array_ops.resize_with_crop_or_pad(tensor, shape) + for tensor in inputs[1:]] - resized = [tf.ensure_shape( - array_ops.resize_with_crop_or_pad(tensor, shape), - static_shape) for tensor in inputs[1:]] + # Set the static shape for each resized tensor. + for i, tensor in enumerate(resized): + static_shape = inputs[0].shape.as_list() + static_shape[axis] = inputs[i + 1].shape.as_list()[axis] + static_shape = tf.TensorShape(static_shape) + resized[i] = tf.ensure_shape(tensor, static_shape) return tf.concat(inputs[:1] + resized, axis=self.axis) # pylint: disable=unexpected-keyword-arg,no-value-for-parameter From 3638f185e9c015a4602a6022307fd6319e8e7833 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 8 Sep 2022 10:15:22 +0000 Subject: [PATCH 095/101] Fixed problems with immutability of MRI operator --- .../python/linalg/linear_operator_mri.py | 146 ++++++++++++------ 1 file changed, 102 insertions(+), 44 deletions(-) diff --git a/tensorflow_mri/python/linalg/linear_operator_mri.py b/tensorflow_mri/python/linalg/linear_operator_mri.py index 6a55d976..e494adda 100644 --- a/tensorflow_mri/python/linalg/linear_operator_mri.py +++ b/tensorflow_mri/python/linalg/linear_operator_mri.py @@ -304,26 +304,51 @@ def __init__(self, self._batch_shape_static = self._batch_shape_static[:-extra_dims] self._batch_shape_dynamic = self._batch_shape_dynamic[:-extra_dims] + # Save some tensors for later use during computation. The `_i_` prefix + # indicates that these tensors are for internal use. We cannot modify the + # original tensors because they are components of the composite tensor that + # represents this operator, and the overall composite tensor cannot be + # mutated in certain circumstances such as in Keras models. + self._i_mask = self._mask + self._i_trajectory = self._trajectory + self._i_density = self._density + self._i_phase = self._phase + self._i_sensitivities = self._sensitivities + # If multicoil, add coil dimension to mask, trajectory and density. - if self._sensitivities is not None: - if self._mask is not None: - self._mask = tf.expand_dims(self._mask, axis=-(self._rank + 1)) - if self._trajectory is not None: - self._trajectory = tf.expand_dims(self._trajectory, axis=-3) - if self._density is not None: - self._density = tf.expand_dims(self._density, axis=-2) - if self._phase is not None: - self._phase = tf.expand_dims(self._phase, axis=-(self._rank + 1)) - - # Save some tensors for later use during computation. - if self._mask is not None: - self._mask_linop_dtype = tf.cast(self._mask, dtype) - if self._density is not None: - self._dens_weights_sqrt = tf.cast( - tf.math.sqrt(tf.math.reciprocal_no_nan(self._density)), dtype) - if self._phase is not None: - self._phase_rotator = tf.math.exp( - tf.complex(tf.constant(0.0, dtype=phase.dtype), phase)) + if self._i_sensitivities is not None: + if self._i_mask is not None: + self._i_mask = tf.expand_dims(self._i_mask, axis=-(self._rank + 1)) + if self._i_trajectory is not None: + self._i_trajectory = tf.expand_dims(self._i_trajectory, axis=-3) + if self._i_density is not None: + self._i_density = tf.expand_dims(self._i_density, axis=-2) + if self._i_phase is not None: + self._i_phase = tf.expand_dims(self._i_phase, axis=-(self._rank + 1)) + + # Select masking algorithm. Options are `multiplex` and `multiply`. + # `multiply` seems faster in most cases, but this needs better profiling. + self._masking_algorithm = 'multiply' + + if self._i_mask is not None: + if self._masking_algorithm == 'multiplex': + # Preallocate zeros tensor for multiplexing. + self._i_zeros = tf.zeros(shape=tf.shape(self._i_mask), dtype=self.dtype) + elif self._masking_algorithm == 'multiply': + # Cast the mask to operator's dtype for multiplication. + self._i_mask = tf.cast(self._i_mask, dtype) + else: + raise ValueError( + f"Unknown masking algorithm: {self._masking_algorithm}") + + # Compute the density compensation weights used internally. + if self._i_density is not None: + self._i_density = tf.cast(tf.math.sqrt( + tf.math.reciprocal_no_nan(self._i_density)), dtype) + # Compute the phase modulator used internally. + if self._i_phase is not None: + self._i_phase = tf.math.exp(tf.dtypes.complex( + tf.constant(0.0, dtype=dtype.real_dtype), self._i_phase)) # Set normalization. self._fft_norm = check_util.validate_enum( @@ -335,15 +360,16 @@ def __init__(self, # Normalize coil sensitivities. self._sens_norm = sens_norm - if self._sensitivities is not None and self._sens_norm: - self._sensitivities = math_ops.normalize_no_nan( - self._sensitivities, axis=-(self._rank + 1)) + if self._i_sensitivities is not None and self._sens_norm: + self._i_sensitivities = math_ops.normalize_no_nan( + self._i_sensitivities, axis=-(self._rank + 1)) # Intensity correction. self._intensity_correction = intensity_correction - if self._sensitivities is not None and self._intensity_correction: + if self._i_sensitivities is not None and self._intensity_correction: + # This is redundant if `sens_norm` is `True`. self._intensity_weights_sqrt = tf.math.reciprocal_no_nan( - tf.math.sqrt(tf.norm(self._sensitivities, axis=-(self._rank + 1)))) + tf.math.sqrt(tf.norm(self._i_sensitivities, axis=-(self._rank + 1)))) # Set dynamic domain. if dynamic_domain is not None and self._extra_shape.rank == 0: @@ -378,13 +404,13 @@ def _transform(self, x, adjoint=False): """ if adjoint: # Apply density compensation. - if self._density is not None and not self._skip_nufft: - x *= self._dens_weights_sqrt + if self._i_density is not None and not self._skip_nufft: + x *= self._i_density # Apply adjoint Fourier operator. if self.is_non_cartesian: # Non-Cartesian imaging, use NUFFT. if not self._skip_nufft: - x = fft_ops.nufft(x, self._trajectory, + x = fft_ops.nufft(x, self._i_trajectory, grid_shape=self._image_shape_dynamic, transform_type='type_1', fft_direction='backward') @@ -392,19 +418,26 @@ def _transform(self, x, adjoint=False): x *= self._fft_norm_factor else: # Cartesian imaging, use FFT. - if self._mask is not None: - x *= self._mask_linop_dtype # Undersampling. + if self._i_mask is not None: + # Apply undersampling. + if self._masking_algorithm == 'multiplex': + x = tf.where(self._i_mask, x, self._i_zeros) + elif self._masking_algorithm == 'multiply': + x *= self._i_mask + else: + raise ValueError( + f"Unknown masking algorithm: {self._masking_algorithm}") x = fft_ops.ifftn(x, axes=self._image_axes, norm=self._fft_norm or 'forward', shift=True) # Apply coil combination. if self.is_multicoil: - x *= tf.math.conj(self._sensitivities) + x *= tf.math.conj(self._i_sensitivities) x = tf.math.reduce_sum(x, axis=-(self._rank + 1)) # Maybe remove phase from image. if self.is_phase_constrained: - x *= tf.math.conj(self._phase_rotator) + x *= tf.math.conj(self._i_phase) x = tf.cast(tf.math.real(x), self.dtype) # Apply intensity correction. @@ -430,17 +463,17 @@ def _transform(self, x, adjoint=False): # Add phase to real-valued image if reconstruction is phase-constrained. if self.is_phase_constrained: x = tf.cast(tf.math.real(x), self.dtype) - x *= self._phase_rotator + x *= self._i_phase # Apply sensitivity modulation. if self.is_multicoil: x = tf.expand_dims(x, axis=-(self._rank + 1)) - x *= self._sensitivities + x *= self._i_sensitivities # Apply Fourier operator. if self.is_non_cartesian: # Non-Cartesian imaging, use NUFFT. if not self._skip_nufft: - x = fft_ops.nufft(x, self._trajectory, + x = fft_ops.nufft(x, self._i_trajectory, transform_type='type_2', fft_direction='forward') if self._fft_norm is not None: @@ -449,19 +482,26 @@ def _transform(self, x, adjoint=False): else: # Cartesian imaging, use FFT. x = fft_ops.fftn(x, axes=self._image_axes, norm=self._fft_norm or 'backward', shift=True) - if self._mask is not None: - x *= self._mask_linop_dtype # Undersampling. + if self._i_mask is not None: + # Apply undersampling. + if self._masking_algorithm == 'multiplex': + x = tf.where(self._i_mask, x, self._i_zeros) + elif self._masking_algorithm == 'multiply': + x *= self._i_mask + else: + raise ValueError( + f"Unknown masking algorithm: {self._masking_algorithm}") # Apply density compensation. - if self._density is not None and not self._skip_nufft: - x *= self._dens_weights_sqrt + if self._i_density is not None and not self._skip_nufft: + x *= self._i_density return x def _preprocess(self, x, adjoint=False): if adjoint: - if self._density is not None: - x *= self._dens_weights_sqrt + if self._i_density is not None: + x *= self._i_density else: raise NotImplementedError( "`_preprocess` not implemented for forward transform.") @@ -528,22 +568,40 @@ def image_shape_tensor(self): @property def rank(self): - """The number of spatial dimensions.""" + """The number of spatial dimensions. + + Returns: + An `int`, typically 2 or 3. + """ return self._rank + @property + def mask(self): + """The sampling mask. + + Returns: + A boolean `tf.Tensor` of shape `batch_shape + extra_shape + image_shape`, + or `None` if the operator is fully sampled or non-Cartesian. + """ + return self._mask + @property def trajectory(self): """The k-space trajectory. - Returns `None` for Cartesian imaging. + Returns: + A real `tf.Tensor` of shape `batch_shape + extra_shape + [samples, rank]`, + or `None` if the operator is Cartesian. """ return self._trajectory @property def density(self): - """The density compensation function. + """The sampling density. - Returns `None` for Cartesian imaging. + Returns: + A real `tf.Tensor` of shape `batch_shape + extra_shape + [samples]`, + or `None` if the operator is Cartesian or has unknown sampling density. """ return self._density From 0c5a39a45776ec147c79956d549efcd9904631fe Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 8 Sep 2022 10:40:24 +0000 Subject: [PATCH 096/101] Add dtype to LinearOperatorSpec --- .../python/linalg/linear_operator.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/tensorflow_mri/python/linalg/linear_operator.py b/tensorflow_mri/python/linalg/linear_operator.py index 6b783426..6921c58a 100644 --- a/tensorflow_mri/python/linalg/linear_operator.py +++ b/tensorflow_mri/python/linalg/linear_operator.py @@ -505,12 +505,14 @@ class _LinearOperatorSpec(type_spec.BatchableTypeSpec): # pylint: disable=abstr operators, so its easier to just store it. """ __slots__ = ("_shape", + "_dtype", "_param_specs", "_non_tensor_params", "_prefer_static_fields") def __init__(self, shape, + dtype, param_specs, non_tensor_params, prefer_static_fields): @@ -518,6 +520,7 @@ def __init__(self, Args: shape: A `tf.TensorShape`. + dtype: A `tf.dtypes.DType`. param_specs: Python `dict` of `tf.TypeSpec` instances that describe kwargs to the `LinearOperator`'s constructor that are `Tensor`-like or `CompositeTensor` subclasses. @@ -529,6 +532,7 @@ def __init__(self, or axis values. """ self._shape = shape + self._dtype = dtype self._param_specs = param_specs self._non_tensor_params = non_tensor_params self._prefer_static_fields = prefer_static_fields @@ -566,6 +570,7 @@ def from_operator(cls, operator): return cls( shape=operator.shape, + dtype=operator.dtype, param_specs=param_specs, non_tensor_params=non_tensor_params, prefer_static_fields=operator._composite_tensor_prefer_static_fields) # pylint: disable=protected-access @@ -583,13 +588,21 @@ def _component_specs(self): def _serialize(self): return (self._shape, + self._dtype, self._param_specs, self._non_tensor_params, self._prefer_static_fields) + def _to_legacy_output_shapes(self): + return self._shape + + def _to_legacy_output_types(self): + return self._dtype + def _copy(self, **overrides): kwargs = { "shape": self._shape, + "dtype": self._dtype, "param_specs": self._param_specs, "non_tensor_params": self._non_tensor_params, "prefer_static_fields": self._prefer_static_fields @@ -617,6 +630,11 @@ def shape(self): # This property is required to use linear operators with Keras. return self._shape + @property + def dtype(self): + """Returns a `tf.dtypes.DType` representing the dtype.""" + return self._dtype + def with_shape(self, shape): """Returns a new `tf.TypeSpec` with the given shape.""" # This method is required to use linear operators with Keras. From 1498605fc047c4b2623719fb5af817075930e3bf Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Thu, 8 Sep 2022 12:40:02 +0000 Subject: [PATCH 097/101] Add LinearOperatorIdentity --- .../python/linalg/linear_operator_identity.py | 133 +++- .../linalg/linear_operator_identity_test.py | 592 ++++++++++++++++++ 2 files changed, 713 insertions(+), 12 deletions(-) create mode 100644 tensorflow_mri/python/linalg/linear_operator_identity_test.py diff --git a/tensorflow_mri/python/linalg/linear_operator_identity.py b/tensorflow_mri/python/linalg/linear_operator_identity.py index 6e9778ca..91bc4700 100644 --- a/tensorflow_mri/python/linalg/linear_operator_identity.py +++ b/tensorflow_mri/python/linalg/linear_operator_identity.py @@ -21,17 +21,128 @@ from tensorflow_mri.python.util import tensor_util +@api_util.export("linalg.LinearOperatorIdentity") +@linear_operator.make_composite_tensor +class LinearOperatorIdentity(linear_operator.LinearOperatorMixin, + tf.linalg.LinearOperatorIdentity): + """Linear operator representing an identity matrix. + + This operator acts like the identity matrix $A = I$ (or a batch of identity + matrices). + + ```{note} + This operator is similar to `tf.linalg.LinearOperatorIdentity`, but + provides additional functionality. See the + [linear algebra guide](https://mrphys.github.io/tensorflow-mri/guide/linalg/) + for more details. + ``` + + ```{seealso} + The scaled identity operator `tfmri.linalg.LinearOperatorScaledIdentity`. + ``` + + Args: + domain_shape: A 1D integer `tf.Tensor`. The domain/range shape of the + operator. + batch_shape: An optional 1D integer `tf.Tensor`. The shape of the leading + batch dimensions. If `None`, this operator has no leading batch + dimensions. + dtype: A `tf.dtypes.DType`. The data type of the matrix that this operator + represents. Defaults to `float32`. + is_non_singular: Expect that this operator is non-singular. + is_self_adjoint: Expect that this operator is equal to its hermitian + transpose. + is_positive_definite: Expect that this operator is positive definite, + meaning the quadratic form $x^H A x$ has positive real part for all + nonzero $x$. Note that we do not require the operator to be + self-adjoint to be positive-definite. See: + https://en.wikipedia.org/wiki/Positive-definite_matrix#Extension_for_non-symmetric_matrices + is_square: Expect that this operator acts like square [batch] matrices. + assert_proper_shapes: A boolean. If `False`, only perform static + checks that initialization and method arguments have proper shape. + If `True`, and static checks are inconclusive, add asserts to the graph. + name: A name for this `LinearOperator`. + """ + def __init__(self, + domain_shape, + batch_shape=None, + dtype=None, + is_non_singular=None, + is_self_adjoint=None, + is_positive_definite=None, + is_square=True, + assert_proper_shapes=False, + name="LinearOperatorIdentity"): + # Initialize the base class. + super().__init__(num_rows=tf.math.reduce_prod(domain_shape), + batch_shape=batch_shape, + dtype=dtype, + is_non_singular=is_non_singular, + is_self_adjoint=is_self_adjoint, + is_positive_definite=is_positive_definite, + is_square=is_square, + assert_proper_shapes=assert_proper_shapes, + name=name) + + self._domain_shape_static, self._domain_shape_dynamic = ( + tensor_util.static_and_dynamic_shapes_from_shape(domain_shape)) + if batch_shape is not None: + self._batch_shape_static, self._batch_shape_dynamic = ( + tensor_util.static_and_dynamic_shapes_from_shape(batch_shape)) + else: + self._batch_shape_static = tf.TensorShape([]) + self._batch_shape_dynamic = tf.constant([], dtype=tf.int32) + + def _transform(self, x, adjoint=False): + output_shape = tf.concat([self.batch_shape_tensor(), + self.domain_shape_tensor()], axis=0) + return tf.broadcast_to(x, output_shape) + + def _domain_shape(self): + return self._domain_shape_static + + def _range_shape(self): + return self._domain_shape_static + + def _batch_shape(self): + return self._batch_shape_static + + def _domain_shape_tensor(self): + return self._domain_shape_dynamic + + def _range_shape_tensor(self): + return self._domain_shape_dynamic + + def _batch_shape_tensor(self): + return self._batch_shape_dynamic + + @property + def _composite_tensor_fields(self): + return ("domain_shape", "batch_shape", "dtype", "assert_proper_shapes") + + @property + def _composite_tensor_prefer_static_fields(self): + return ("domain_shape", "batch_shape") + + @api_util.export("linalg.LinearOperatorScaledIdentity") @linear_operator.make_composite_tensor class LinearOperatorScaledIdentity(linear_operator.LinearOperatorMixin, # pylint: disable=abstract-method tf.linalg.LinearOperatorScaledIdentity): """Linear operator representing a scaled identity matrix. - This operator acts like a scaled identity matrix $A = cI$. + This operator acts like a scaled identity matrix $A = cI$ (or a batch of + scaled identity matrices). ```{note} - This operator is a drop-in replacement of - `tf.linalg.LinearOperatorScaledIdentity`, with extended functionality. + This operator is similar to `tf.linalg.LinearOperatorScaledIdentity`, but + provides additional functionality. See the + [linear algebra guide](https://mrphys.github.io/tensorflow-mri/guide/linalg/) + for more details. + ``` + + ```{seealso} + The identity operator `tfmri.linalg.LinearOperatorIdentity`. ``` Args: @@ -63,11 +174,6 @@ def __init__(self, assert_proper_shapes=False, name="LinearOperatorScaledIdentity"): - self._domain_shape_tensor_value = tensor_util.convert_shape_to_tensor( - domain_shape, name="domain_shape") - self._domain_shape_value = tf.TensorShape(tf.get_static_value( - self._domain_shape_tensor_value)) - super().__init__( num_rows=tf.math.reduce_prod(domain_shape), multiplier=multiplier, @@ -78,6 +184,9 @@ def __init__(self, assert_proper_shapes=assert_proper_shapes, name=name) + self._domain_shape_static, self._domain_shape_dynamic = ( + tensor_util.static_and_dynamic_shapes_from_shape(domain_shape)) + def _transform(self, x, adjoint=False): domain_rank = tf.size(self.domain_shape_tensor()) multiplier_shape = tf.concat([ @@ -89,19 +198,19 @@ def _transform(self, x, adjoint=False): return x * multiplier_matrix def _domain_shape(self): - return self._domain_shape_value + return self._domain_shape_static def _range_shape(self): - return self._domain_shape_value + return self._domain_shape_static def _batch_shape(self): return self.multiplier.shape def _domain_shape_tensor(self): - return self._domain_shape_tensor_value + return self._domain_shape_dynamic def _range_shape_tensor(self): - return self._domain_shape_tensor_value + return self._domain_shape_dynamic def _batch_shape_tensor(self): return tf.shape(self.multiplier) diff --git a/tensorflow_mri/python/linalg/linear_operator_identity_test.py b/tensorflow_mri/python/linalg/linear_operator_identity_test.py new file mode 100644 index 00000000..a042ea96 --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_identity_test.py @@ -0,0 +1,592 @@ +# Copyright 2016 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. +# ============================================================================== + +import numpy as np + +from tensorflow.python.framework import config +from tensorflow.python.framework import dtypes +from tensorflow.python.framework import test_util +from tensorflow.python.ops import array_ops +from tensorflow.python.ops import linalg_ops +from tensorflow.python.ops import math_ops +from tensorflow.python.ops import random_ops +from tensorflow.python.ops import variables as variables_module +from tensorflow.python.ops.linalg import linalg as linalg_lib +from tensorflow.python.ops.linalg import linear_operator_test_util +from tensorflow.python.platform import test + + +rng = np.random.RandomState(2016) + + +@test_util.run_all_in_graph_and_eager_modes +class LinearOperatorIdentityTest( + linear_operator_test_util.SquareLinearOperatorDerivedClassTest): + """Most tests done in the base class LinearOperatorDerivedClassTest.""" + + def tearDown(self): + config.enable_tensor_float_32_execution(self.tf32_keep_) + + def setUp(self): + self.tf32_keep_ = config.tensor_float_32_execution_enabled() + config.enable_tensor_float_32_execution(False) + + @staticmethod + def dtypes_to_test(): + # TODO(langmore) Test tf.float16 once tf.linalg.solve works in + # 16bit. + return [dtypes.float32, dtypes.float64, dtypes.complex64, dtypes.complex128] + + @staticmethod + def optional_tests(): + """List of optional test names to run.""" + return [ + "operator_matmul_with_same_type", + "operator_solve_with_same_type", + ] + + def operator_and_matrix( + self, build_info, dtype, use_placeholder, + ensure_self_adjoint_and_pd=False): + # Identity matrix is already Hermitian Positive Definite. + del ensure_self_adjoint_and_pd + + shape = list(build_info.shape) + assert shape[-1] == shape[-2] + + batch_shape = shape[:-2] + num_rows = shape[-1] + + operator = linalg_lib.LinearOperatorIdentity( + num_rows, batch_shape=batch_shape, dtype=dtype) + mat = linalg_ops.eye(num_rows, batch_shape=batch_shape, dtype=dtype) + + return operator, mat + + def test_assert_positive_definite(self): + with self.cached_session(): + operator = linalg_lib.LinearOperatorIdentity(num_rows=2) + self.evaluate(operator.assert_positive_definite()) # Should not fail + + def test_assert_non_singular(self): + with self.cached_session(): + operator = linalg_lib.LinearOperatorIdentity(num_rows=2) + self.evaluate(operator.assert_non_singular()) # Should not fail + + def test_assert_self_adjoint(self): + with self.cached_session(): + operator = linalg_lib.LinearOperatorIdentity(num_rows=2) + self.evaluate(operator.assert_self_adjoint()) # Should not fail + + def test_float16_matmul(self): + # float16 cannot be tested by base test class because tf.linalg.solve does + # not work with float16. + with self.cached_session(): + operator = linalg_lib.LinearOperatorIdentity( + num_rows=2, dtype=dtypes.float16) + x = rng.randn(2, 3).astype(np.float16) + y = operator.matmul(x) + self.assertAllClose(x, self.evaluate(y)) + + def test_non_scalar_num_rows_raises_static(self): + with self.assertRaisesRegex(ValueError, "must be a 0-D Tensor"): + linalg_lib.LinearOperatorIdentity(num_rows=[2]) + + def test_non_integer_num_rows_raises_static(self): + with self.assertRaisesRegex(TypeError, "must be integer"): + linalg_lib.LinearOperatorIdentity(num_rows=2.) + + def test_negative_num_rows_raises_static(self): + with self.assertRaisesRegex(ValueError, "must be non-negative"): + linalg_lib.LinearOperatorIdentity(num_rows=-2) + + def test_non_1d_batch_shape_raises_static(self): + with self.assertRaisesRegex(ValueError, "must be a 1-D"): + linalg_lib.LinearOperatorIdentity(num_rows=2, batch_shape=2) + + def test_non_integer_batch_shape_raises_static(self): + with self.assertRaisesRegex(TypeError, "must be integer"): + linalg_lib.LinearOperatorIdentity(num_rows=2, batch_shape=[2.]) + + def test_negative_batch_shape_raises_static(self): + with self.assertRaisesRegex(ValueError, "must be non-negative"): + linalg_lib.LinearOperatorIdentity(num_rows=2, batch_shape=[-2]) + + def test_non_scalar_num_rows_raises_dynamic(self): + with self.cached_session(): + num_rows = array_ops.placeholder_with_default([2], shape=None) + + with self.assertRaisesError("must be a 0-D Tensor"): + operator = linalg_lib.LinearOperatorIdentity( + num_rows, assert_proper_shapes=True) + self.evaluate(operator.to_dense()) + + def test_negative_num_rows_raises_dynamic(self): + with self.cached_session(): + num_rows = array_ops.placeholder_with_default(-2, shape=None) + with self.assertRaisesError("must be non-negative"): + operator = linalg_lib.LinearOperatorIdentity( + num_rows, assert_proper_shapes=True) + self.evaluate(operator.to_dense()) + + def test_non_1d_batch_shape_raises_dynamic(self): + with self.cached_session(): + batch_shape = array_ops.placeholder_with_default(2, shape=None) + with self.assertRaisesError("must be a 1-D"): + operator = linalg_lib.LinearOperatorIdentity( + num_rows=2, batch_shape=batch_shape, assert_proper_shapes=True) + self.evaluate(operator.to_dense()) + + def test_negative_batch_shape_raises_dynamic(self): + with self.cached_session(): + batch_shape = array_ops.placeholder_with_default([-2], shape=None) + with self.assertRaisesError("must be non-negative"): + operator = linalg_lib.LinearOperatorIdentity( + num_rows=2, batch_shape=batch_shape, assert_proper_shapes=True) + self.evaluate(operator.to_dense()) + + def test_wrong_matrix_dimensions_raises_static(self): + operator = linalg_lib.LinearOperatorIdentity(num_rows=2) + x = rng.randn(3, 3).astype(np.float32) + with self.assertRaisesRegex(ValueError, "Dimensions.*not compatible"): + operator.matmul(x) + + def test_wrong_matrix_dimensions_raises_dynamic(self): + num_rows = array_ops.placeholder_with_default(2, shape=None) + x = array_ops.placeholder_with_default( + rng.rand(3, 3).astype(np.float32), shape=None) + + with self.cached_session(): + with self.assertRaisesError("Dimensions.*not.compatible"): + operator = linalg_lib.LinearOperatorIdentity( + num_rows, assert_proper_shapes=True) + self.evaluate(operator.matmul(x)) + + def test_default_batch_shape_broadcasts_with_everything_static(self): + # These cannot be done in the automated (base test class) tests since they + # test shapes that tf.batch_matmul cannot handle. + # In particular, tf.batch_matmul does not broadcast. + with self.cached_session() as sess: + x = random_ops.random_normal(shape=(1, 2, 3, 4)) + operator = linalg_lib.LinearOperatorIdentity(num_rows=3, dtype=x.dtype) + + operator_matmul = operator.matmul(x) + expected = x + + self.assertAllEqual(operator_matmul.shape, expected.shape) + self.assertAllClose(*self.evaluate([operator_matmul, expected])) + + def test_default_batch_shape_broadcasts_with_everything_dynamic(self): + # These cannot be done in the automated (base test class) tests since they + # test shapes that tf.batch_matmul cannot handle. + # In particular, tf.batch_matmul does not broadcast. + with self.cached_session(): + x = array_ops.placeholder_with_default(rng.randn(1, 2, 3, 4), shape=None) + operator = linalg_lib.LinearOperatorIdentity(num_rows=3, dtype=x.dtype) + + operator_matmul = operator.matmul(x) + expected = x + + self.assertAllClose(*self.evaluate([operator_matmul, expected])) + + def test_broadcast_matmul_static_shapes(self): + # These cannot be done in the automated (base test class) tests since they + # test shapes that tf.batch_matmul cannot handle. + # In particular, tf.batch_matmul does not broadcast. + with self.cached_session() as sess: + # Given this x and LinearOperatorIdentity shape of (2, 1, 3, 3), the + # broadcast shape of operator and 'x' is (2, 2, 3, 4) + x = random_ops.random_normal(shape=(1, 2, 3, 4)) + operator = linalg_lib.LinearOperatorIdentity( + num_rows=3, batch_shape=(2, 1), dtype=x.dtype) + + # Batch matrix of zeros with the broadcast shape of x and operator. + zeros = array_ops.zeros(shape=(2, 2, 3, 4), dtype=x.dtype) + + # Expected result of matmul and solve. + expected = x + zeros + + operator_matmul = operator.matmul(x) + self.assertAllEqual(operator_matmul.shape, expected.shape) + self.assertAllClose(*self.evaluate([operator_matmul, expected])) + + def test_broadcast_matmul_dynamic_shapes(self): + # These cannot be done in the automated (base test class) tests since they + # test shapes that tf.batch_matmul cannot handle. + # In particular, tf.batch_matmul does not broadcast. + with self.cached_session(): + # Given this x and LinearOperatorIdentity shape of (2, 1, 3, 3), the + # broadcast shape of operator and 'x' is (2, 2, 3, 4) + x = array_ops.placeholder_with_default(rng.rand(1, 2, 3, 4), shape=None) + num_rows = array_ops.placeholder_with_default(3, shape=None) + batch_shape = array_ops.placeholder_with_default((2, 1), shape=None) + + operator = linalg_lib.LinearOperatorIdentity( + num_rows, batch_shape=batch_shape, dtype=dtypes.float64) + + # Batch matrix of zeros with the broadcast shape of x and operator. + zeros = array_ops.zeros(shape=(2, 2, 3, 4), dtype=x.dtype) + + # Expected result of matmul and solve. + expected = x + zeros + + operator_matmul = operator.matmul(x) + self.assertAllClose(*self.evaluate([operator_matmul, expected])) + + def test_is_x_flags(self): + # The is_x flags are by default all True. + operator = linalg_lib.LinearOperatorIdentity(num_rows=2) + self.assertTrue(operator.is_positive_definite) + self.assertTrue(operator.is_non_singular) + self.assertTrue(operator.is_self_adjoint) + + # Any of them False raises because the identity is always self-adjoint etc.. + with self.assertRaisesRegex(ValueError, "is always non-singular"): + operator = linalg_lib.LinearOperatorIdentity( + num_rows=2, + is_non_singular=None, + ) + + def test_identity_adjoint_type(self): + operator = linalg_lib.LinearOperatorIdentity( + num_rows=2, is_non_singular=True) + self.assertIsInstance( + operator.adjoint(), linalg_lib.LinearOperatorIdentity) + + def test_identity_cholesky_type(self): + operator = linalg_lib.LinearOperatorIdentity( + num_rows=2, + is_positive_definite=True, + is_self_adjoint=True, + ) + self.assertIsInstance( + operator.cholesky(), linalg_lib.LinearOperatorIdentity) + + def test_identity_inverse_type(self): + operator = linalg_lib.LinearOperatorIdentity( + num_rows=2, is_non_singular=True) + self.assertIsInstance( + operator.inverse(), linalg_lib.LinearOperatorIdentity) + + def test_ref_type_shape_args_raises(self): + with self.assertRaisesRegex(TypeError, "num_rows.*reference"): + linalg_lib.LinearOperatorIdentity(num_rows=variables_module.Variable(2)) + + with self.assertRaisesRegex(TypeError, "batch_shape.*reference"): + linalg_lib.LinearOperatorIdentity( + num_rows=2, batch_shape=variables_module.Variable([3])) + + +@test_util.run_all_in_graph_and_eager_modes +class LinearOperatorScaledIdentityTest( + linear_operator_test_util.SquareLinearOperatorDerivedClassTest): + """Most tests done in the base class LinearOperatorDerivedClassTest.""" + + def tearDown(self): + config.enable_tensor_float_32_execution(self.tf32_keep_) + + def setUp(self): + self.tf32_keep_ = config.tensor_float_32_execution_enabled() + config.enable_tensor_float_32_execution(False) + + @staticmethod + def dtypes_to_test(): + # TODO(langmore) Test tf.float16 once tf.linalg.solve works in + # 16bit. + return [dtypes.float32, dtypes.float64, dtypes.complex64, dtypes.complex128] + + @staticmethod + def optional_tests(): + """List of optional test names to run.""" + return [ + "operator_matmul_with_same_type", + "operator_solve_with_same_type", + ] + + def operator_and_matrix( + self, build_info, dtype, use_placeholder, + ensure_self_adjoint_and_pd=False): + + shape = list(build_info.shape) + assert shape[-1] == shape[-2] + + batch_shape = shape[:-2] + num_rows = shape[-1] + + # Uniform values that are at least length 1 from the origin. Allows the + # operator to be well conditioned. + # Shape batch_shape + multiplier = linear_operator_test_util.random_sign_uniform( + shape=batch_shape, minval=1., maxval=2., dtype=dtype) + + if ensure_self_adjoint_and_pd: + # Abs on complex64 will result in a float32, so we cast back up. + multiplier = math_ops.cast(math_ops.abs(multiplier), dtype=dtype) + + # Nothing to feed since LinearOperatorScaledIdentity takes no Tensor args. + lin_op_multiplier = multiplier + + if use_placeholder: + lin_op_multiplier = array_ops.placeholder_with_default( + multiplier, shape=None) + + operator = linalg_lib.LinearOperatorScaledIdentity( + num_rows, + lin_op_multiplier, + is_self_adjoint=True if ensure_self_adjoint_and_pd else None, + is_positive_definite=True if ensure_self_adjoint_and_pd else None) + + multiplier_matrix = array_ops.expand_dims( + array_ops.expand_dims(multiplier, -1), -1) + matrix = multiplier_matrix * linalg_ops.eye( + num_rows, batch_shape=batch_shape, dtype=dtype) + + return operator, matrix + + def test_assert_positive_definite_does_not_raise_when_positive(self): + with self.cached_session(): + operator = linalg_lib.LinearOperatorScaledIdentity( + num_rows=2, multiplier=1.) + self.evaluate(operator.assert_positive_definite()) # Should not fail + + def test_assert_positive_definite_raises_when_negative(self): + with self.cached_session(): + operator = linalg_lib.LinearOperatorScaledIdentity( + num_rows=2, multiplier=-1.) + with self.assertRaisesOpError("not positive definite"): + self.evaluate(operator.assert_positive_definite()) + + def test_assert_non_singular_does_not_raise_when_non_singular(self): + with self.cached_session(): + operator = linalg_lib.LinearOperatorScaledIdentity( + num_rows=2, multiplier=[1., 2., 3.]) + self.evaluate(operator.assert_non_singular()) # Should not fail + + def test_assert_non_singular_raises_when_singular(self): + with self.cached_session(): + operator = linalg_lib.LinearOperatorScaledIdentity( + num_rows=2, multiplier=[1., 2., 0.]) + with self.assertRaisesOpError("was singular"): + self.evaluate(operator.assert_non_singular()) + + def test_assert_self_adjoint_does_not_raise_when_self_adjoint(self): + with self.cached_session(): + operator = linalg_lib.LinearOperatorScaledIdentity( + num_rows=2, multiplier=[1. + 0J]) + self.evaluate(operator.assert_self_adjoint()) # Should not fail + + def test_assert_self_adjoint_raises_when_not_self_adjoint(self): + with self.cached_session(): + operator = linalg_lib.LinearOperatorScaledIdentity( + num_rows=2, multiplier=[1. + 1J]) + with self.assertRaisesOpError("not self-adjoint"): + self.evaluate(operator.assert_self_adjoint()) + + def test_float16_matmul(self): + # float16 cannot be tested by base test class because tf.linalg.solve does + # not work with float16. + with self.cached_session(): + multiplier = rng.rand(3).astype(np.float16) + operator = linalg_lib.LinearOperatorScaledIdentity( + num_rows=2, multiplier=multiplier) + x = rng.randn(2, 3).astype(np.float16) + y = operator.matmul(x) + self.assertAllClose(multiplier[..., None, None] * x, self.evaluate(y)) + + def test_non_scalar_num_rows_raises_static(self): + # Many "test_...num_rows" tests are performed in LinearOperatorIdentity. + with self.assertRaisesRegex(ValueError, "must be a 0-D Tensor"): + linalg_lib.LinearOperatorScaledIdentity( + num_rows=[2], multiplier=123.) + + def test_wrong_matrix_dimensions_raises_static(self): + operator = linalg_lib.LinearOperatorScaledIdentity( + num_rows=2, multiplier=2.2) + x = rng.randn(3, 3).astype(np.float32) + with self.assertRaisesRegex(ValueError, "Dimensions.*not compatible"): + operator.matmul(x) + + def test_wrong_matrix_dimensions_raises_dynamic(self): + num_rows = array_ops.placeholder_with_default(2, shape=None) + x = array_ops.placeholder_with_default( + rng.rand(3, 3).astype(np.float32), shape=None) + + with self.cached_session(): + with self.assertRaisesError("Dimensions.*not.compatible"): + operator = linalg_lib.LinearOperatorScaledIdentity( + num_rows, + multiplier=[1., 2], + assert_proper_shapes=True) + self.evaluate(operator.matmul(x)) + + def test_broadcast_matmul_and_solve(self): + # These cannot be done in the automated (base test class) tests since they + # test shapes that tf.batch_matmul cannot handle. + # In particular, tf.batch_matmul does not broadcast. + with self.cached_session() as sess: + # Given this x and LinearOperatorScaledIdentity shape of (2, 1, 3, 3), the + # broadcast shape of operator and 'x' is (2, 2, 3, 4) + x = random_ops.random_normal(shape=(1, 2, 3, 4)) + + # operator is 2.2 * identity (with a batch shape). + operator = linalg_lib.LinearOperatorScaledIdentity( + num_rows=3, multiplier=2.2 * array_ops.ones((2, 1))) + + # Batch matrix of zeros with the broadcast shape of x and operator. + zeros = array_ops.zeros(shape=(2, 2, 3, 4), dtype=x.dtype) + + # Test matmul + expected = x * 2.2 + zeros + operator_matmul = operator.matmul(x) + self.assertAllEqual(operator_matmul.shape, expected.shape) + self.assertAllClose(*self.evaluate([operator_matmul, expected])) + + # Test solve + expected = x / 2.2 + zeros + operator_solve = operator.solve(x) + self.assertAllEqual(operator_solve.shape, expected.shape) + self.assertAllClose(*self.evaluate([operator_solve, expected])) + + def test_broadcast_matmul_and_solve_scalar_scale_multiplier(self): + # These cannot be done in the automated (base test class) tests since they + # test shapes that tf.batch_matmul cannot handle. + # In particular, tf.batch_matmul does not broadcast. + with self.cached_session() as sess: + # Given this x and LinearOperatorScaledIdentity shape of (3, 3), the + # broadcast shape of operator and 'x' is (1, 2, 3, 4), which is the same + # shape as x. + x = random_ops.random_normal(shape=(1, 2, 3, 4)) + + # operator is 2.2 * identity (with a batch shape). + operator = linalg_lib.LinearOperatorScaledIdentity( + num_rows=3, multiplier=2.2) + + # Test matmul + expected = x * 2.2 + operator_matmul = operator.matmul(x) + self.assertAllEqual(operator_matmul.shape, expected.shape) + self.assertAllClose(*self.evaluate([operator_matmul, expected])) + + # Test solve + expected = x / 2.2 + operator_solve = operator.solve(x) + self.assertAllEqual(operator_solve.shape, expected.shape) + self.assertAllClose(*self.evaluate([operator_solve, expected])) + + def test_is_x_flags(self): + operator = linalg_lib.LinearOperatorScaledIdentity( + num_rows=2, multiplier=1., + is_positive_definite=False, is_non_singular=True) + self.assertFalse(operator.is_positive_definite) + self.assertTrue(operator.is_non_singular) + self.assertTrue(operator.is_self_adjoint) # Auto-set due to real multiplier + + def test_identity_matmul(self): + operator1 = linalg_lib.LinearOperatorIdentity(num_rows=2) + operator2 = linalg_lib.LinearOperatorScaledIdentity( + num_rows=2, multiplier=3.) + self.assertIsInstance( + operator1.matmul(operator1), + linalg_lib.LinearOperatorIdentity) + + self.assertIsInstance( + operator1.matmul(operator1), + linalg_lib.LinearOperatorIdentity) + + self.assertIsInstance( + operator2.matmul(operator2), + linalg_lib.LinearOperatorScaledIdentity) + + operator_matmul = operator1.matmul(operator2) + self.assertIsInstance( + operator_matmul, + linalg_lib.LinearOperatorScaledIdentity) + self.assertAllClose(3., self.evaluate(operator_matmul.multiplier)) + + operator_matmul = operator2.matmul(operator1) + self.assertIsInstance( + operator_matmul, + linalg_lib.LinearOperatorScaledIdentity) + self.assertAllClose(3., self.evaluate(operator_matmul.multiplier)) + + def test_identity_solve(self): + operator1 = linalg_lib.LinearOperatorIdentity(num_rows=2) + operator2 = linalg_lib.LinearOperatorScaledIdentity( + num_rows=2, multiplier=3.) + self.assertIsInstance( + operator1.solve(operator1), + linalg_lib.LinearOperatorIdentity) + + self.assertIsInstance( + operator2.solve(operator2), + linalg_lib.LinearOperatorScaledIdentity) + + operator_solve = operator1.solve(operator2) + self.assertIsInstance( + operator_solve, + linalg_lib.LinearOperatorScaledIdentity) + self.assertAllClose(3., self.evaluate(operator_solve.multiplier)) + + operator_solve = operator2.solve(operator1) + self.assertIsInstance( + operator_solve, + linalg_lib.LinearOperatorScaledIdentity) + self.assertAllClose(1. / 3., self.evaluate(operator_solve.multiplier)) + + def test_scaled_identity_cholesky_type(self): + operator = linalg_lib.LinearOperatorScaledIdentity( + num_rows=2, + multiplier=3., + is_positive_definite=True, + is_self_adjoint=True, + ) + self.assertIsInstance( + operator.cholesky(), + linalg_lib.LinearOperatorScaledIdentity) + + def test_scaled_identity_inverse_type(self): + operator = linalg_lib.LinearOperatorScaledIdentity( + num_rows=2, + multiplier=3., + is_non_singular=True, + ) + self.assertIsInstance( + operator.inverse(), + linalg_lib.LinearOperatorScaledIdentity) + + def test_ref_type_shape_args_raises(self): + with self.assertRaisesRegex(TypeError, "num_rows.*reference"): + linalg_lib.LinearOperatorScaledIdentity( + num_rows=variables_module.Variable(2), multiplier=1.23) + + def test_tape_safe(self): + multiplier = variables_module.Variable(1.23) + operator = linalg_lib.LinearOperatorScaledIdentity( + num_rows=2, multiplier=multiplier) + self.check_tape_safe(operator) + + def test_convert_variables_to_tensors(self): + multiplier = variables_module.Variable(1.23) + operator = linalg_lib.LinearOperatorScaledIdentity( + num_rows=2, multiplier=multiplier) + with self.cached_session() as sess: + sess.run([multiplier.initializer]) + self.check_convert_variables_to_tensors(operator) + + +if __name__ == "__main__": + linear_operator_test_util.add_tests(LinearOperatorIdentityTest) + linear_operator_test_util.add_tests(LinearOperatorScaledIdentityTest) + test.main() From 63cd0620bc7c498867c5ced71943f9cc6835797f Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 14 Sep 2022 15:09:30 +0000 Subject: [PATCH 098/101] Added tests for linear operator identity --- .devcontainer/Dockerfile | 2 +- Makefile | 2 +- requirements.txt | 8 +- .../python/linalg/linear_operator.py | 74 ++- .../python/linalg/linear_operator_algebra.py | 20 + .../python/linalg/linear_operator_identity.py | 101 ++- .../linalg/linear_operator_identity_test.py | 595 ++++++++++-------- tensorflow_mri/python/util/__init__.py | 1 + tensorflow_mri/python/util/tensor_util.py | 39 +- tensorflow_mri/python/util/types_util.py | 25 + 10 files changed, 565 insertions(+), 302 deletions(-) create mode 100644 tensorflow_mri/python/linalg/linear_operator_algebra.py diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile index 175bc3f9..18fc211e 100644 --- a/.devcontainer/Dockerfile +++ b/.devcontainer/Dockerfile @@ -1,4 +1,4 @@ -FROM ghcr.io/mrphys/tensorflow-manylinux:1.12.0 +FROM ghcr.io/mrphys/tensorflow-manylinux:1.14.0 # To enable plotting. RUN apt-get update && \ diff --git a/Makefile b/Makefile index 2b6db006..d148e212 100644 --- a/Makefile +++ b/Makefile @@ -14,7 +14,7 @@ TF_LDFLAGS := $(shell $(PYTHON) -c 'import tensorflow as tf; print(" ".join(tf.s CFLAGS := -O3 -march=x86-64 -mtune=generic CXXFLAGS := $(CFLAGS) -CXXFLAGS += $(TF_CFLAGS) -fPIC -std=c++14 -fopenmp +CXXFLAGS += $(TF_CFLAGS) -fPIC -std=c++17 -fopenmp CXXFLAGS += -I$(ROOT_DIR) LDFLAGS := $(TF_LDFLAGS) diff --git a/requirements.txt b/requirements.txt index cf36181c..ecb06801 100755 --- a/requirements.txt +++ b/requirements.txt @@ -6,8 +6,8 @@ plotly PyWavelets scipy tensorboard -tensorflow>=2.9.0,<2.10.0 +tensorflow>=2.10.0,<2.11.0 tensorflow-addons>=0.17.0,<0.18.0 -tensorflow-io>=0.26.0 -tensorflow-nufft>=0.8.0 -tensorflow-probability>=0.16.0 +tensorflow-io>=0.27.0,<0.28.0 +tensorflow-nufft>=0.10.0,<0.11.0 +tensorflow-probability>=0.18.0,<0.19.0 diff --git a/tensorflow_mri/python/linalg/linear_operator.py b/tensorflow_mri/python/linalg/linear_operator.py index 6921c58a..49207d4b 100644 --- a/tensorflow_mri/python/linalg/linear_operator.py +++ b/tensorflow_mri/python/linalg/linear_operator.py @@ -15,6 +15,7 @@ """Base linear operator.""" import abc +import functools import tensorflow as tf from tensorflow.python.framework import type_spec @@ -175,18 +176,19 @@ def _matvec(self, x, adjoint=False): return x def _matmul(self, x, adjoint=False, adjoint_arg=False): - # Default implementation of `matmul` for imaging operator. If outer - # dimension of argument is 1, call `matvec`. Otherwise raise an error. - # Typically subclasses should not need to override this method. - arg_outer_dim = -2 if adjoint_arg else -1 - - if x.shape[arg_outer_dim] != 1: - raise ValueError( - f"`{self.__class__.__name__}` does not support matrix multiplication.") - - x = tf.squeeze(x, axis=arg_outer_dim) - x = self.matvec(x, adjoint=adjoint) - x = tf.expand_dims(x, axis=arg_outer_dim) + # Default implementation of `matmul` for imaging operator. Basically we + # just call `matvec` for each column of `x` (or for each row, if + # `adjoint_arg` is `True`). `tf.einsum` is used to transpose the input arg, + # moving the column/row dimension to be the leading batch dimension to be + # unpacked by `tf.map_fn`. Typically subclasses should not need to override + # this method. + batch_shape = tf.broadcast_static_shape(x.shape[:-2], self.batch_shape) + x = tf.einsum('...ij->i...j' if adjoint_arg else '...ij->j...i', x) + x = tf.map_fn(functools.partial(self.matvec, adjoint=adjoint), x, + fn_output_signature=tf.TensorSpec( + shape=batch_shape + [self.range_dimension], + dtype=x.dtype)) + x = tf.einsum('i...j->...ij' if adjoint_arg else 'j...i->...ij', x) return x @abc.abstractmethod @@ -221,16 +223,16 @@ def _batch_shape_tensor(self): # pylint: disable=arguments-differ def _shape(self): # Default implementation of `_shape` for imaging operators. Typically # subclasses should not need to override this method. - return self._batch_shape() + tf.TensorShape( + return self._batch_shape().concatenate(tf.TensorShape( [self.range_shape.num_elements(), - self.domain_shape.num_elements()]) + self.domain_shape.num_elements()])) def _shape_tensor(self): # Default implementation of `_shape_tensor` for imaging operators. Typically # subclasses should not need to override this method. return tf.concat([self.batch_shape_tensor(), - [tf.size(self.range_shape_tensor()), - tf.size(self.domain_shape_tensor())]], 0) + [tf.math.reduce_prod(self.range_shape_tensor()), + tf.math.reduce_prod(self.domain_shape_tensor())]], 0) def flatten_domain_shape(self, x): """Flattens `x` to match the domain dimension of this operator. @@ -242,11 +244,21 @@ def flatten_domain_shape(self, x): The flattened `Tensor`. Has shape `[..., self.domain_dimension]`. """ # pylint: disable=invalid-unary-operand-type - self.domain_shape.assert_is_compatible_with( - x.shape[-self.domain_shape.rank:]) - - batch_shape = x.shape[:-self.domain_shape.rank] - batch_shape_tensor = tf.shape(x)[:-self.domain_shape.rank] + domain_rank_static = self.domain_shape.rank + if domain_rank_static is not None: + domain_rank_dynamic = domain_rank_static + else: + domain_rank_dynamic = tf.shape(self.domain_shape_tensor())[0] + + if domain_rank_static is not None: + self.domain_shape.assert_is_compatible_with( + x.shape[-domain_rank_static:]) + + if domain_rank_static is not None: + batch_shape = x.shape[:-domain_rank_static] + else: + batch_shape = tf.TensorShape(None) + batch_shape_tensor = tf.shape(x)[:-domain_rank_dynamic] output_shape = batch_shape + self.domain_dimension output_shape_tensor = tf.concat( @@ -265,11 +277,21 @@ def flatten_range_shape(self, x): The flattened `Tensor`. Has shape `[..., self.range_dimension]`. """ # pylint: disable=invalid-unary-operand-type - self.range_shape.assert_is_compatible_with( - x.shape[-self.range_shape.rank:]) - - batch_shape = x.shape[:-self.range_shape.rank] - batch_shape_tensor = tf.shape(x)[:-self.range_shape.rank] + range_rank_static = self.range_shape.rank + if range_rank_static is not None: + range_rank_dynamic = range_rank_static + else: + range_rank_dynamic = tf.shape(self.range_shape_tensor())[0] + + if range_rank_static is not None: + self.range_shape.assert_is_compatible_with( + x.shape[-range_rank_static:]) + + if range_rank_static is not None: + batch_shape = x.shape[:-range_rank_static] + else: + batch_shape = tf.TensorShape(None) + batch_shape_tensor = tf.shape(x)[:-range_rank_dynamic] output_shape = batch_shape + self.range_dimension output_shape_tensor = tf.concat( diff --git a/tensorflow_mri/python/linalg/linear_operator_algebra.py b/tensorflow_mri/python/linalg/linear_operator_algebra.py new file mode 100644 index 00000000..9ad76612 --- /dev/null +++ b/tensorflow_mri/python/linalg/linear_operator_algebra.py @@ -0,0 +1,20 @@ +# Copyright 2022 The TensorFlow MRI 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. +# ============================================================================== + +from tensorflow.python.ops.linalg import linear_operator_algebra + + +RegisterAdjoint = linear_operator_algebra.RegisterAdjoint +RegisterInverse = linear_operator_algebra.RegisterInverse diff --git a/tensorflow_mri/python/linalg/linear_operator_identity.py b/tensorflow_mri/python/linalg/linear_operator_identity.py index 91bc4700..7d025c25 100644 --- a/tensorflow_mri/python/linalg/linear_operator_identity.py +++ b/tensorflow_mri/python/linalg/linear_operator_identity.py @@ -17,8 +17,10 @@ import tensorflow as tf from tensorflow_mri.python.linalg import linear_operator +from tensorflow_mri.python.linalg import linear_operator_algebra from tensorflow_mri.python.util import api_util from tensorflow_mri.python.util import tensor_util +from tensorflow_mri.python.util import types_util @api_util.export("linalg.LinearOperatorIdentity") @@ -67,13 +69,36 @@ def __init__(self, domain_shape, batch_shape=None, dtype=None, - is_non_singular=None, - is_self_adjoint=None, - is_positive_definite=None, + is_non_singular=True, + is_self_adjoint=True, + is_positive_definite=True, is_square=True, assert_proper_shapes=False, name="LinearOperatorIdentity"): - # Initialize the base class. + # Shape inputs must not have reference semantics. + types_util.assert_not_ref_type(domain_shape, "domain_shape") + types_util.assert_not_ref_type(batch_shape, "batch_shape") + + # Parse domain shape. + self._domain_shape_static, self._domain_shape_dynamic = ( + tensor_util.static_and_dynamic_shapes_from_shape( + domain_shape, + assert_proper_shape=assert_proper_shapes, + arg_name='domain_shape')) + + # Parse batch shape. + if batch_shape is not None: + # Extra underscore at the end to distinguish from base class property of + # the same name. + self._batch_shape_static_, self._batch_shape_dynamic = ( + tensor_util.static_and_dynamic_shapes_from_shape( + batch_shape, + assert_proper_shape=assert_proper_shapes, + arg_name='batch_shape')) + else: + self._batch_shape_static_ = tf.TensorShape([]) + self._batch_shape_dynamic = tf.constant([], dtype=tf.int32) + super().__init__(num_rows=tf.math.reduce_prod(domain_shape), batch_shape=batch_shape, dtype=dtype, @@ -84,18 +109,14 @@ def __init__(self, assert_proper_shapes=assert_proper_shapes, name=name) - self._domain_shape_static, self._domain_shape_dynamic = ( - tensor_util.static_and_dynamic_shapes_from_shape(domain_shape)) - if batch_shape is not None: - self._batch_shape_static, self._batch_shape_dynamic = ( - tensor_util.static_and_dynamic_shapes_from_shape(batch_shape)) - else: - self._batch_shape_static = tf.TensorShape([]) - self._batch_shape_dynamic = tf.constant([], dtype=tf.int32) - def _transform(self, x, adjoint=False): - output_shape = tf.concat([self.batch_shape_tensor(), - self.domain_shape_tensor()], axis=0) + if self.domain_shape.rank is not None: + rank = self.domain_shape.rank + else: + rank = tf.size(self.domain_shape_tensor()) + batch_shape = tf.broadcast_dynamic_shape( + tf.shape(x)[:-rank], self.batch_shape_tensor()) + output_shape = tf.concat([batch_shape, self.domain_shape_tensor()], axis=0) return tf.broadcast_to(x, output_shape) def _domain_shape(self): @@ -105,7 +126,7 @@ def _range_shape(self): return self._domain_shape_static def _batch_shape(self): - return self._batch_shape_static + return self._batch_shape_static_ def _domain_shape_tensor(self): return self._domain_shape_dynamic @@ -173,6 +194,15 @@ def __init__(self, is_square=True, assert_proper_shapes=False, name="LinearOperatorScaledIdentity"): + # Shape inputs must not have reference semantics. + types_util.assert_not_ref_type(domain_shape, "domain_shape") + + # Parse domain shape. + self._domain_shape_static, self._domain_shape_dynamic = ( + tensor_util.static_and_dynamic_shapes_from_shape( + domain_shape, + assert_proper_shape=assert_proper_shapes, + arg_name='domain_shape')) super().__init__( num_rows=tf.math.reduce_prod(domain_shape), @@ -184,9 +214,6 @@ def __init__(self, assert_proper_shapes=assert_proper_shapes, name=name) - self._domain_shape_static, self._domain_shape_dynamic = ( - tensor_util.static_and_dynamic_shapes_from_shape(domain_shape)) - def _transform(self, x, adjoint=False): domain_rank = tf.size(self.domain_shape_tensor()) multiplier_shape = tf.concat([ @@ -222,3 +249,39 @@ def _composite_tensor_fields(self): @property def _composite_tensor_prefer_static_fields(self): return ("domain_shape",) + + +@linear_operator_algebra.RegisterAdjoint(LinearOperatorIdentity) +def adjoint_identity(identity_operator): + return identity_operator + + +@linear_operator_algebra.RegisterAdjoint(LinearOperatorScaledIdentity) +def adjoint_scaled_identity(identity_operator): + multiplier = identity_operator.multiplier + if multiplier.dtype.is_complex: + multiplier = tf.math.conj(multiplier) + + return LinearOperatorScaledIdentity( + domain_shape=identity_operator.domain_shape_tensor(), + multiplier=multiplier, + is_non_singular=identity_operator.is_non_singular, + is_self_adjoint=identity_operator.is_self_adjoint, + is_positive_definite=identity_operator.is_positive_definite, + is_square=True) + + +@linear_operator_algebra.RegisterInverse(LinearOperatorIdentity) +def inverse_identity(identity_operator): + return identity_operator + + +@linear_operator_algebra.RegisterInverse(LinearOperatorScaledIdentity) +def inverse_scaled_identity(identity_operator): + return LinearOperatorScaledIdentity( + domain_shape=identity_operator.domain_shape_tensor(), + multiplier=1. / identity_operator.multiplier, + is_non_singular=identity_operator.is_non_singular, + is_self_adjoint=True, + is_positive_definite=identity_operator.is_positive_definite, + is_square=True) diff --git a/tensorflow_mri/python/linalg/linear_operator_identity_test.py b/tensorflow_mri/python/linalg/linear_operator_identity_test.py index a042ea96..e12b3d7f 100644 --- a/tensorflow_mri/python/linalg/linear_operator_identity_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_identity_test.py @@ -12,20 +12,17 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== +"""Tests for module `linear_operator_identity`. -import numpy as np +Adapted from tensorflow/python/kernel_tests/linalg/linear_operator_identity_test.py +""" -from tensorflow.python.framework import config -from tensorflow.python.framework import dtypes +import numpy as np +import tensorflow as tf from tensorflow.python.framework import test_util -from tensorflow.python.ops import array_ops -from tensorflow.python.ops import linalg_ops -from tensorflow.python.ops import math_ops -from tensorflow.python.ops import random_ops -from tensorflow.python.ops import variables as variables_module -from tensorflow.python.ops.linalg import linalg as linalg_lib from tensorflow.python.ops.linalg import linear_operator_test_util -from tensorflow.python.platform import test + +from tensorflow_mri.python.linalg import linear_operator_identity rng = np.random.RandomState(2016) @@ -37,17 +34,17 @@ class LinearOperatorIdentityTest( """Most tests done in the base class LinearOperatorDerivedClassTest.""" def tearDown(self): - config.enable_tensor_float_32_execution(self.tf32_keep_) + tf.config.experimental.enable_tensor_float_32_execution(self.tf32_keep_) def setUp(self): - self.tf32_keep_ = config.tensor_float_32_execution_enabled() - config.enable_tensor_float_32_execution(False) + self.tf32_keep_ = tf.config.experimental.tensor_float_32_execution_enabled() + tf.config.experimental.enable_tensor_float_32_execution(False) @staticmethod def dtypes_to_test(): # TODO(langmore) Test tf.float16 once tf.linalg.solve works in # 16bit. - return [dtypes.float32, dtypes.float64, dtypes.complex64, dtypes.complex128] + return [tf.float32, tf.float64, tf.complex64, tf.complex128] @staticmethod def optional_tests(): @@ -69,118 +66,171 @@ def operator_and_matrix( batch_shape = shape[:-2] num_rows = shape[-1] - operator = linalg_lib.LinearOperatorIdentity( + operator = linear_operator_identity.LinearOperatorIdentity( num_rows, batch_shape=batch_shape, dtype=dtype) - mat = linalg_ops.eye(num_rows, batch_shape=batch_shape, dtype=dtype) + mat = tf.linalg.eye(num_rows, batch_shape=batch_shape, dtype=dtype) return operator, mat + def test_to_dense(self): + with self.cached_session(): + operator = linear_operator_identity.LinearOperatorIdentity( + domain_shape=[2]) + self.assertAllClose(np.eye(2), self.evaluate(operator.to_dense())) + + operator = linear_operator_identity.LinearOperatorIdentity( + domain_shape=[2, 3]) + self.assertAllClose(np.eye(6), self.evaluate(operator.to_dense())) + + def test_shapes(self): + with self.cached_session(): + operator = linear_operator_identity.LinearOperatorIdentity( + domain_shape=[2, 3], batch_shape=[4, 5]) + self.assertAllEqual([2, 3], operator.domain_shape) + self.assertAllEqual([2, 3], operator.range_shape) + self.assertAllEqual([4, 5], operator.batch_shape) + self.assertAllEqual([4, 5, 6, 6], operator.shape) + self.assertAllEqual(6, operator.domain_dimension) + self.assertAllEqual(6, operator.range_dimension) + self.assertAllEqual([2, 3], self.evaluate(operator.domain_shape_tensor())) + self.assertAllEqual([2, 3], self.evaluate(operator.range_shape_tensor())) + self.assertAllEqual([4, 5], self.evaluate(operator.batch_shape_tensor())) + self.assertAllEqual([4, 5, 6, 6], self.evaluate(operator.shape_tensor())) + self.assertAllEqual(6, self.evaluate(operator.domain_dimension_tensor())) + self.assertAllEqual(6, self.evaluate(operator.range_dimension_tensor())) + + def test_shapes_dynamic(self): + # These cannot be done in the automated (base test class) tests since they + # test shapes that tf.batch_matmul cannot handle. + # In particular, tf.batch_matmul does not broadcast. + with self.cached_session(): + # Given this x and LinearOperatorIdentity shape of (2, 1, 6, 6), the + # broadcast shape of operator and 'x' is (2, 2, 3, 4) + domain_shape = tf.compat.v1.placeholder_with_default((2, 3), shape=None) + batch_shape = tf.compat.v1.placeholder_with_default((2, 1), shape=None) + + operator = linear_operator_identity.LinearOperatorIdentity( + domain_shape, batch_shape=batch_shape, dtype=tf.float64) + + self.assertAllEqual([2, 3], self.evaluate(operator.domain_shape_tensor())) + self.assertAllEqual([2, 1], self.evaluate(operator.batch_shape_tensor())) + self.assertAllEqual([2, 1, 6, 6], self.evaluate(operator.shape_tensor())) + self.assertAllEqual(6, self.evaluate(operator.domain_dimension_tensor())) + self.assertAllEqual(6, self.evaluate(operator.range_dimension_tensor())) + def test_assert_positive_definite(self): with self.cached_session(): - operator = linalg_lib.LinearOperatorIdentity(num_rows=2) + operator = linear_operator_identity.LinearOperatorIdentity(domain_shape=[2]) self.evaluate(operator.assert_positive_definite()) # Should not fail def test_assert_non_singular(self): with self.cached_session(): - operator = linalg_lib.LinearOperatorIdentity(num_rows=2) + operator = linear_operator_identity.LinearOperatorIdentity(domain_shape=[2]) self.evaluate(operator.assert_non_singular()) # Should not fail def test_assert_self_adjoint(self): with self.cached_session(): - operator = linalg_lib.LinearOperatorIdentity(num_rows=2) + operator = linear_operator_identity.LinearOperatorIdentity(domain_shape=[2]) self.evaluate(operator.assert_self_adjoint()) # Should not fail - def test_float16_matmul(self): - # float16 cannot be tested by base test class because tf.linalg.solve does - # not work with float16. - with self.cached_session(): - operator = linalg_lib.LinearOperatorIdentity( - num_rows=2, dtype=dtypes.float16) - x = rng.randn(2, 3).astype(np.float16) - y = operator.matmul(x) - self.assertAllClose(x, self.evaluate(y)) - - def test_non_scalar_num_rows_raises_static(self): - with self.assertRaisesRegex(ValueError, "must be a 0-D Tensor"): - linalg_lib.LinearOperatorIdentity(num_rows=[2]) - - def test_non_integer_num_rows_raises_static(self): - with self.assertRaisesRegex(TypeError, "must be integer"): - linalg_lib.LinearOperatorIdentity(num_rows=2.) - - def test_negative_num_rows_raises_static(self): - with self.assertRaisesRegex(ValueError, "must be non-negative"): - linalg_lib.LinearOperatorIdentity(num_rows=-2) + # TODO(jmontalt). + # def test_float16_matmul(self): + # # float16 cannot be tested by base test class because tf.linalg.solve does + # # not work with float16. + # with self.cached_session(): + # operator = linear_operator_identity.LinearOperatorIdentity( + # domain_shape=[2], dtype=tf.float16) + # x = rng.randn(2, 3).astype(np.float16) + # y = operator.matmul(x) + # self.assertAllClose(x, self.evaluate(y)) + + def test_non_1d_domain_shape_raises_static(self): + with self.assertRaisesRegex( + ValueError, "domain_shape must be a 1-D Tensor"): + linear_operator_identity.LinearOperatorIdentity(domain_shape=2) + + def test_non_integer_domain_shape_raises_static(self): + with self.assertRaisesRegex( + TypeError, "domain_shape must be integer"): + linear_operator_identity.LinearOperatorIdentity(domain_shape=[2.]) + + def test_negative_domain_shape_raises_static(self): + with self.assertRaisesRegex( + ValueError, "domain_shape must be non-negative"): + linear_operator_identity.LinearOperatorIdentity(domain_shape=[-2]) def test_non_1d_batch_shape_raises_static(self): - with self.assertRaisesRegex(ValueError, "must be a 1-D"): - linalg_lib.LinearOperatorIdentity(num_rows=2, batch_shape=2) + with self.assertRaisesRegex( + ValueError, "batch_shape must be a 1-D Tensor"): + linear_operator_identity.LinearOperatorIdentity(domain_shape=[2], batch_shape=2) def test_non_integer_batch_shape_raises_static(self): with self.assertRaisesRegex(TypeError, "must be integer"): - linalg_lib.LinearOperatorIdentity(num_rows=2, batch_shape=[2.]) + linear_operator_identity.LinearOperatorIdentity(domain_shape=[2], batch_shape=[2.]) def test_negative_batch_shape_raises_static(self): with self.assertRaisesRegex(ValueError, "must be non-negative"): - linalg_lib.LinearOperatorIdentity(num_rows=2, batch_shape=[-2]) + linear_operator_identity.LinearOperatorIdentity(domain_shape=[2], batch_shape=[-2]) - def test_non_scalar_num_rows_raises_dynamic(self): + def test_non_1d_domain_shape_raises_dynamic(self): with self.cached_session(): - num_rows = array_ops.placeholder_with_default([2], shape=None) - - with self.assertRaisesError("must be a 0-D Tensor"): - operator = linalg_lib.LinearOperatorIdentity( - num_rows, assert_proper_shapes=True) + domain_shape = tf.compat.v1.placeholder_with_default(2, shape=None) + with self.assertRaisesError("must be a 1-D Tensor"): + operator = linear_operator_identity.LinearOperatorIdentity( + domain_shape, assert_proper_shapes=True) self.evaluate(operator.to_dense()) - def test_negative_num_rows_raises_dynamic(self): + def test_negative_domain_shape_raises_dynamic(self): with self.cached_session(): - num_rows = array_ops.placeholder_with_default(-2, shape=None) + domain_shape = tf.compat.v1.placeholder_with_default([-2], shape=None) with self.assertRaisesError("must be non-negative"): - operator = linalg_lib.LinearOperatorIdentity( - num_rows, assert_proper_shapes=True) + operator = linear_operator_identity.LinearOperatorIdentity( + domain_shape, assert_proper_shapes=True) self.evaluate(operator.to_dense()) def test_non_1d_batch_shape_raises_dynamic(self): with self.cached_session(): - batch_shape = array_ops.placeholder_with_default(2, shape=None) + batch_shape = tf.compat.v1.placeholder_with_default(2, shape=None) with self.assertRaisesError("must be a 1-D"): - operator = linalg_lib.LinearOperatorIdentity( - num_rows=2, batch_shape=batch_shape, assert_proper_shapes=True) + operator = linear_operator_identity.LinearOperatorIdentity( + domain_shape=[2], batch_shape=batch_shape, + assert_proper_shapes=True) self.evaluate(operator.to_dense()) def test_negative_batch_shape_raises_dynamic(self): with self.cached_session(): - batch_shape = array_ops.placeholder_with_default([-2], shape=None) + batch_shape = tf.compat.v1.placeholder_with_default([-2], shape=None) with self.assertRaisesError("must be non-negative"): - operator = linalg_lib.LinearOperatorIdentity( - num_rows=2, batch_shape=batch_shape, assert_proper_shapes=True) + operator = linear_operator_identity.LinearOperatorIdentity( + domain_shape=[2], batch_shape=batch_shape, + assert_proper_shapes=True) self.evaluate(operator.to_dense()) def test_wrong_matrix_dimensions_raises_static(self): - operator = linalg_lib.LinearOperatorIdentity(num_rows=2) + operator = linear_operator_identity.LinearOperatorIdentity(domain_shape=[2]) x = rng.randn(3, 3).astype(np.float32) with self.assertRaisesRegex(ValueError, "Dimensions.*not compatible"): operator.matmul(x) - def test_wrong_matrix_dimensions_raises_dynamic(self): - num_rows = array_ops.placeholder_with_default(2, shape=None) - x = array_ops.placeholder_with_default( - rng.rand(3, 3).astype(np.float32), shape=None) + # TODO(jmontalt). + # def test_wrong_matrix_dimensions_raises_dynamic(self): + # domain_shape = tf.compat.v1.placeholder_with_default([2], shape=None) + # x = tf.compat.v1.placeholder_with_default( + # rng.rand(3, 3).astype(np.float32), shape=None) - with self.cached_session(): - with self.assertRaisesError("Dimensions.*not.compatible"): - operator = linalg_lib.LinearOperatorIdentity( - num_rows, assert_proper_shapes=True) - self.evaluate(operator.matmul(x)) + # with self.cached_session(): + # with self.assertRaisesError("Dimensions.*not.compatible"): + # operator = linear_operator_identity.LinearOperatorIdentity( + # domain_shape, assert_proper_shapes=True) + # self.evaluate(operator.matmul(x)) def test_default_batch_shape_broadcasts_with_everything_static(self): # These cannot be done in the automated (base test class) tests since they # test shapes that tf.batch_matmul cannot handle. # In particular, tf.batch_matmul does not broadcast. with self.cached_session() as sess: - x = random_ops.random_normal(shape=(1, 2, 3, 4)) - operator = linalg_lib.LinearOperatorIdentity(num_rows=3, dtype=x.dtype) + x = tf.random.normal(shape=(1, 2, 3, 4)) + operator = linear_operator_identity.LinearOperatorIdentity(domain_shape=[3], dtype=x.dtype) operator_matmul = operator.matmul(x) expected = x @@ -193,8 +243,8 @@ def test_default_batch_shape_broadcasts_with_everything_dynamic(self): # test shapes that tf.batch_matmul cannot handle. # In particular, tf.batch_matmul does not broadcast. with self.cached_session(): - x = array_ops.placeholder_with_default(rng.randn(1, 2, 3, 4), shape=None) - operator = linalg_lib.LinearOperatorIdentity(num_rows=3, dtype=x.dtype) + x = tf.compat.v1.placeholder_with_default(rng.randn(1, 2, 3, 4), shape=None) + operator = linear_operator_identity.LinearOperatorIdentity(domain_shape=[3], dtype=x.dtype) operator_matmul = operator.matmul(x) expected = x @@ -206,14 +256,14 @@ def test_broadcast_matmul_static_shapes(self): # test shapes that tf.batch_matmul cannot handle. # In particular, tf.batch_matmul does not broadcast. with self.cached_session() as sess: - # Given this x and LinearOperatorIdentity shape of (2, 1, 3, 3), the - # broadcast shape of operator and 'x' is (2, 2, 3, 4) - x = random_ops.random_normal(shape=(1, 2, 3, 4)) - operator = linalg_lib.LinearOperatorIdentity( - num_rows=3, batch_shape=(2, 1), dtype=x.dtype) + # Given this x and LinearOperatorIdentity shape of (2, 1, 6, 6), the + # broadcast shape of operator and 'x' is (2, 2, 6, 4) + x = tf.random.normal(shape=(1, 2, 6, 4)) + operator = linear_operator_identity.LinearOperatorIdentity( + domain_shape=(2, 3), batch_shape=(2, 1), dtype=x.dtype) # Batch matrix of zeros with the broadcast shape of x and operator. - zeros = array_ops.zeros(shape=(2, 2, 3, 4), dtype=x.dtype) + zeros = tf.zeros(shape=(2, 2, 6, 4), dtype=x.dtype) # Expected result of matmul and solve. expected = x + zeros @@ -227,17 +277,17 @@ def test_broadcast_matmul_dynamic_shapes(self): # test shapes that tf.batch_matmul cannot handle. # In particular, tf.batch_matmul does not broadcast. with self.cached_session(): - # Given this x and LinearOperatorIdentity shape of (2, 1, 3, 3), the + # Given this x and LinearOperatorIdentity shape of (2, 1, 6, 6), the # broadcast shape of operator and 'x' is (2, 2, 3, 4) - x = array_ops.placeholder_with_default(rng.rand(1, 2, 3, 4), shape=None) - num_rows = array_ops.placeholder_with_default(3, shape=None) - batch_shape = array_ops.placeholder_with_default((2, 1), shape=None) + x = tf.compat.v1.placeholder_with_default(rng.rand(1, 2, 6, 4), shape=None) + domain_shape = tf.compat.v1.placeholder_with_default((2, 3), shape=None) + batch_shape = tf.compat.v1.placeholder_with_default((2, 1), shape=None) - operator = linalg_lib.LinearOperatorIdentity( - num_rows, batch_shape=batch_shape, dtype=dtypes.float64) + operator = linear_operator_identity.LinearOperatorIdentity( + domain_shape, batch_shape=batch_shape, dtype=tf.float64) # Batch matrix of zeros with the broadcast shape of x and operator. - zeros = array_ops.zeros(shape=(2, 2, 3, 4), dtype=x.dtype) + zeros = tf.zeros(shape=(2, 2, 6, 4), dtype=x.dtype) # Expected result of matmul and solve. expected = x + zeros @@ -247,46 +297,48 @@ def test_broadcast_matmul_dynamic_shapes(self): def test_is_x_flags(self): # The is_x flags are by default all True. - operator = linalg_lib.LinearOperatorIdentity(num_rows=2) + operator = linear_operator_identity.LinearOperatorIdentity(domain_shape=[2]) self.assertTrue(operator.is_positive_definite) self.assertTrue(operator.is_non_singular) self.assertTrue(operator.is_self_adjoint) # Any of them False raises because the identity is always self-adjoint etc.. with self.assertRaisesRegex(ValueError, "is always non-singular"): - operator = linalg_lib.LinearOperatorIdentity( - num_rows=2, + operator = linear_operator_identity.LinearOperatorIdentity( + domain_shape=[2], is_non_singular=None, ) def test_identity_adjoint_type(self): - operator = linalg_lib.LinearOperatorIdentity( - num_rows=2, is_non_singular=True) - self.assertIsInstance( - operator.adjoint(), linalg_lib.LinearOperatorIdentity) - - def test_identity_cholesky_type(self): - operator = linalg_lib.LinearOperatorIdentity( - num_rows=2, - is_positive_definite=True, - is_self_adjoint=True, - ) + operator = linear_operator_identity.LinearOperatorIdentity( + domain_shape=[2], is_non_singular=True) self.assertIsInstance( - operator.cholesky(), linalg_lib.LinearOperatorIdentity) + operator.adjoint(), linear_operator_identity.LinearOperatorIdentity) + + # TODO(jmontalt). + # def test_identity_cholesky_type(self): + # operator = linear_operator_identity.LinearOperatorIdentity( + # domain_shape=[2], + # is_positive_definite=True, + # is_self_adjoint=True, + # ) + # self.assertIsInstance( + # operator.cholesky(), linear_operator_identity.LinearOperatorIdentity) def test_identity_inverse_type(self): - operator = linalg_lib.LinearOperatorIdentity( - num_rows=2, is_non_singular=True) + operator = linear_operator_identity.LinearOperatorIdentity( + domain_shape=[2], is_non_singular=True) self.assertIsInstance( - operator.inverse(), linalg_lib.LinearOperatorIdentity) + operator.inverse(), linear_operator_identity.LinearOperatorIdentity) def test_ref_type_shape_args_raises(self): - with self.assertRaisesRegex(TypeError, "num_rows.*reference"): - linalg_lib.LinearOperatorIdentity(num_rows=variables_module.Variable(2)) + with self.assertRaisesRegex(TypeError, "domain_shape.*reference"): + linear_operator_identity.LinearOperatorIdentity( + domain_shape=tf.Variable([2])) with self.assertRaisesRegex(TypeError, "batch_shape.*reference"): - linalg_lib.LinearOperatorIdentity( - num_rows=2, batch_shape=variables_module.Variable([3])) + linear_operator_identity.LinearOperatorIdentity( + domain_shape=[2], batch_shape=tf.Variable([3])) @test_util.run_all_in_graph_and_eager_modes @@ -295,17 +347,17 @@ class LinearOperatorScaledIdentityTest( """Most tests done in the base class LinearOperatorDerivedClassTest.""" def tearDown(self): - config.enable_tensor_float_32_execution(self.tf32_keep_) + tf.config.experimental.enable_tensor_float_32_execution(self.tf32_keep_) def setUp(self): - self.tf32_keep_ = config.tensor_float_32_execution_enabled() - config.enable_tensor_float_32_execution(False) + self.tf32_keep_ = tf.config.experimental.tensor_float_32_execution_enabled() + tf.config.experimental.enable_tensor_float_32_execution(False) @staticmethod def dtypes_to_test(): # TODO(langmore) Test tf.float16 once tf.linalg.solve works in # 16bit. - return [dtypes.float32, dtypes.float64, dtypes.complex64, dtypes.complex128] + return [tf.float32, tf.float64, tf.complex64, tf.complex128] @staticmethod def optional_tests(): @@ -333,119 +385,167 @@ def operator_and_matrix( if ensure_self_adjoint_and_pd: # Abs on complex64 will result in a float32, so we cast back up. - multiplier = math_ops.cast(math_ops.abs(multiplier), dtype=dtype) + multiplier = tf.cast(tf.abs(multiplier), dtype=dtype) # Nothing to feed since LinearOperatorScaledIdentity takes no Tensor args. lin_op_multiplier = multiplier if use_placeholder: - lin_op_multiplier = array_ops.placeholder_with_default( + lin_op_multiplier = tf.compat.v1.placeholder_with_default( multiplier, shape=None) - operator = linalg_lib.LinearOperatorScaledIdentity( + operator = linear_operator_identity.LinearOperatorScaledIdentity( num_rows, lin_op_multiplier, is_self_adjoint=True if ensure_self_adjoint_and_pd else None, is_positive_definite=True if ensure_self_adjoint_and_pd else None) - multiplier_matrix = array_ops.expand_dims( - array_ops.expand_dims(multiplier, -1), -1) - matrix = multiplier_matrix * linalg_ops.eye( + multiplier_matrix = tf.expand_dims( + tf.expand_dims(multiplier, -1), -1) + matrix = multiplier_matrix * tf.linalg.eye( num_rows, batch_shape=batch_shape, dtype=dtype) return operator, matrix + def test_to_dense(self): + with self.cached_session(): + operator = linear_operator_identity.LinearOperatorScaledIdentity( + domain_shape=[2], multiplier=1.0) + self.assertAllClose(np.eye(2), self.evaluate(operator.to_dense())) + + operator = linear_operator_identity.LinearOperatorScaledIdentity( + domain_shape=[2, 3], multiplier=2.0) + self.assertAllClose(2.0 * np.eye(6), self.evaluate(operator.to_dense())) + + def test_shapes(self): + with self.cached_session(): + multiplier = tf.ones([4, 5]) + operator = linear_operator_identity.LinearOperatorScaledIdentity( + domain_shape=[2, 3], multiplier=multiplier) + self.assertAllEqual([2, 3], operator.domain_shape) + self.assertAllEqual([2, 3], operator.range_shape) + self.assertAllEqual([4, 5], operator.batch_shape) + self.assertAllEqual([4, 5, 6, 6], operator.shape) + self.assertAllEqual(6, operator.domain_dimension) + self.assertAllEqual(6, operator.range_dimension) + self.assertAllEqual([2, 3], self.evaluate(operator.domain_shape_tensor())) + self.assertAllEqual([2, 3], self.evaluate(operator.range_shape_tensor())) + self.assertAllEqual([4, 5], self.evaluate(operator.batch_shape_tensor())) + self.assertAllEqual([4, 5, 6, 6], self.evaluate(operator.shape_tensor())) + self.assertAllEqual(6, self.evaluate(operator.domain_dimension_tensor())) + self.assertAllEqual(6, self.evaluate(operator.range_dimension_tensor())) + + def test_shapes_dynamic(self): + # These cannot be done in the automated (base test class) tests since they + # test shapes that tf.batch_matmul cannot handle. + # In particular, tf.batch_matmul does not broadcast. + with self.cached_session(): + # Given this x and LinearOperatorIdentity shape of (2, 1, 6, 6), the + # broadcast shape of operator and 'x' is (2, 2, 3, 4) + domain_shape = tf.compat.v1.placeholder_with_default((2, 3), shape=None) + batch_shape = tf.compat.v1.placeholder_with_default((2, 1), shape=None) + + operator = linear_operator_identity.LinearOperatorIdentity( + domain_shape, batch_shape=batch_shape, dtype=tf.float64) + + self.assertAllEqual([2, 3], self.evaluate(operator.domain_shape_tensor())) + self.assertAllEqual([2, 1], self.evaluate(operator.batch_shape_tensor())) + self.assertAllEqual([2, 1, 6, 6], self.evaluate(operator.shape_tensor())) + self.assertAllEqual(6, self.evaluate(operator.domain_dimension_tensor())) + self.assertAllEqual(6, self.evaluate(operator.range_dimension_tensor())) + def test_assert_positive_definite_does_not_raise_when_positive(self): with self.cached_session(): - operator = linalg_lib.LinearOperatorScaledIdentity( - num_rows=2, multiplier=1.) + operator = linear_operator_identity.LinearOperatorScaledIdentity( + domain_shape=[2], multiplier=1.) self.evaluate(operator.assert_positive_definite()) # Should not fail def test_assert_positive_definite_raises_when_negative(self): with self.cached_session(): - operator = linalg_lib.LinearOperatorScaledIdentity( - num_rows=2, multiplier=-1.) + operator = linear_operator_identity.LinearOperatorScaledIdentity( + domain_shape=[2], multiplier=-1.) with self.assertRaisesOpError("not positive definite"): self.evaluate(operator.assert_positive_definite()) def test_assert_non_singular_does_not_raise_when_non_singular(self): with self.cached_session(): - operator = linalg_lib.LinearOperatorScaledIdentity( - num_rows=2, multiplier=[1., 2., 3.]) + operator = linear_operator_identity.LinearOperatorScaledIdentity( + domain_shape=[2], multiplier=[1., 2., 3.]) self.evaluate(operator.assert_non_singular()) # Should not fail def test_assert_non_singular_raises_when_singular(self): with self.cached_session(): - operator = linalg_lib.LinearOperatorScaledIdentity( - num_rows=2, multiplier=[1., 2., 0.]) + operator = linear_operator_identity.LinearOperatorScaledIdentity( + domain_shape=[2], multiplier=[1., 2., 0.]) with self.assertRaisesOpError("was singular"): self.evaluate(operator.assert_non_singular()) def test_assert_self_adjoint_does_not_raise_when_self_adjoint(self): with self.cached_session(): - operator = linalg_lib.LinearOperatorScaledIdentity( - num_rows=2, multiplier=[1. + 0J]) + operator = linear_operator_identity.LinearOperatorScaledIdentity( + domain_shape=[2], multiplier=[1. + 0J]) self.evaluate(operator.assert_self_adjoint()) # Should not fail def test_assert_self_adjoint_raises_when_not_self_adjoint(self): with self.cached_session(): - operator = linalg_lib.LinearOperatorScaledIdentity( - num_rows=2, multiplier=[1. + 1J]) + operator = linear_operator_identity.LinearOperatorScaledIdentity( + domain_shape=[2], multiplier=[1. + 1J]) with self.assertRaisesOpError("not self-adjoint"): self.evaluate(operator.assert_self_adjoint()) - def test_float16_matmul(self): - # float16 cannot be tested by base test class because tf.linalg.solve does - # not work with float16. - with self.cached_session(): - multiplier = rng.rand(3).astype(np.float16) - operator = linalg_lib.LinearOperatorScaledIdentity( - num_rows=2, multiplier=multiplier) - x = rng.randn(2, 3).astype(np.float16) - y = operator.matmul(x) - self.assertAllClose(multiplier[..., None, None] * x, self.evaluate(y)) - - def test_non_scalar_num_rows_raises_static(self): +# def test_float16_matmul(self): +# # float16 cannot be tested by base test class because tf.linalg.solve does +# # not work with float16. +# with self.cached_session(): +# multiplier = rng.rand(3).astype(np.float16) +# operator = linear_operator_identity.LinearOperatorScaledIdentity( +# domain_shape=[2], multiplier=multiplier) +# x = rng.randn(2, 3).astype(np.float16) +# y = operator.matmul(x) +# self.assertAllClose(multiplier[..., None, None] * x, self.evaluate(y)) + + def test_non_1d_domain_shape_raises_static(self): # Many "test_...num_rows" tests are performed in LinearOperatorIdentity. - with self.assertRaisesRegex(ValueError, "must be a 0-D Tensor"): - linalg_lib.LinearOperatorScaledIdentity( - num_rows=[2], multiplier=123.) + with self.assertRaisesRegex(ValueError, "must be a 1-D Tensor"): + linear_operator_identity.LinearOperatorScaledIdentity( + domain_shape=2, multiplier=123.) def test_wrong_matrix_dimensions_raises_static(self): - operator = linalg_lib.LinearOperatorScaledIdentity( - num_rows=2, multiplier=2.2) + operator = linear_operator_identity.LinearOperatorScaledIdentity( + domain_shape=[2], multiplier=2.2) x = rng.randn(3, 3).astype(np.float32) with self.assertRaisesRegex(ValueError, "Dimensions.*not compatible"): operator.matmul(x) - def test_wrong_matrix_dimensions_raises_dynamic(self): - num_rows = array_ops.placeholder_with_default(2, shape=None) - x = array_ops.placeholder_with_default( - rng.rand(3, 3).astype(np.float32), shape=None) + # TODO(jmontalt): add assertions to `transform` / `matmul`. + # def test_wrong_matrix_dimensions_raises_dynamic(self): + # num_rows = tf.compat.v1.placeholder_with_default(2, shape=None) + # x = tf.compat.v1.placeholder_with_default( + # rng.rand(3, 3).astype(np.float32), shape=None) - with self.cached_session(): - with self.assertRaisesError("Dimensions.*not.compatible"): - operator = linalg_lib.LinearOperatorScaledIdentity( - num_rows, - multiplier=[1., 2], - assert_proper_shapes=True) - self.evaluate(operator.matmul(x)) + # with self.cached_session(): + # with self.assertRaisesError("Dimensions.*not.compatible"): + # operator = linear_operator_identity.LinearOperatorScaledIdentity( + # num_rows, + # multiplier=[1., 2], + # assert_proper_shapes=True) + # self.evaluate(operator.matmul(x)) def test_broadcast_matmul_and_solve(self): # These cannot be done in the automated (base test class) tests since they # test shapes that tf.batch_matmul cannot handle. # In particular, tf.batch_matmul does not broadcast. with self.cached_session() as sess: - # Given this x and LinearOperatorScaledIdentity shape of (2, 1, 3, 3), the - # broadcast shape of operator and 'x' is (2, 2, 3, 4) - x = random_ops.random_normal(shape=(1, 2, 3, 4)) + # Given this x and LinearOperatorScaledIdentity shape of (2, 1, 6, 6), the + # broadcast shape of operator and 'x' is (2, 2, 6, 4) + x = tf.random.normal(shape=(1, 2, 6, 4)) # operator is 2.2 * identity (with a batch shape). - operator = linalg_lib.LinearOperatorScaledIdentity( - num_rows=3, multiplier=2.2 * array_ops.ones((2, 1))) + operator = linear_operator_identity.LinearOperatorScaledIdentity( + domain_shape=[2, 3], multiplier=2.2 * tf.ones((2, 1))) # Batch matrix of zeros with the broadcast shape of x and operator. - zeros = array_ops.zeros(shape=(2, 2, 3, 4), dtype=x.dtype) + zeros = tf.zeros(shape=(2, 2, 6, 4), dtype=x.dtype) # Test matmul expected = x * 2.2 + zeros @@ -464,14 +564,14 @@ def test_broadcast_matmul_and_solve_scalar_scale_multiplier(self): # test shapes that tf.batch_matmul cannot handle. # In particular, tf.batch_matmul does not broadcast. with self.cached_session() as sess: - # Given this x and LinearOperatorScaledIdentity shape of (3, 3), the - # broadcast shape of operator and 'x' is (1, 2, 3, 4), which is the same + # Given this x and LinearOperatorScaledIdentity shape of (6, 6), the + # broadcast shape of operator and 'x' is (1, 2, 6, 4), which is the same # shape as x. - x = random_ops.random_normal(shape=(1, 2, 3, 4)) + x = tf.random.normal(shape=(1, 2, 6, 4)) # operator is 2.2 * identity (with a batch shape). - operator = linalg_lib.LinearOperatorScaledIdentity( - num_rows=3, multiplier=2.2) + operator = linear_operator_identity.LinearOperatorScaledIdentity( + domain_shape=[2, 3], multiplier=2.2) # Test matmul expected = x * 2.2 @@ -486,101 +586,102 @@ def test_broadcast_matmul_and_solve_scalar_scale_multiplier(self): self.assertAllClose(*self.evaluate([operator_solve, expected])) def test_is_x_flags(self): - operator = linalg_lib.LinearOperatorScaledIdentity( - num_rows=2, multiplier=1., + operator = linear_operator_identity.LinearOperatorScaledIdentity( + domain_shape=[2], multiplier=1., is_positive_definite=False, is_non_singular=True) self.assertFalse(operator.is_positive_definite) self.assertTrue(operator.is_non_singular) self.assertTrue(operator.is_self_adjoint) # Auto-set due to real multiplier - def test_identity_matmul(self): - operator1 = linalg_lib.LinearOperatorIdentity(num_rows=2) - operator2 = linalg_lib.LinearOperatorScaledIdentity( - num_rows=2, multiplier=3.) - self.assertIsInstance( - operator1.matmul(operator1), - linalg_lib.LinearOperatorIdentity) - - self.assertIsInstance( - operator1.matmul(operator1), - linalg_lib.LinearOperatorIdentity) - - self.assertIsInstance( - operator2.matmul(operator2), - linalg_lib.LinearOperatorScaledIdentity) - - operator_matmul = operator1.matmul(operator2) - self.assertIsInstance( - operator_matmul, - linalg_lib.LinearOperatorScaledIdentity) - self.assertAllClose(3., self.evaluate(operator_matmul.multiplier)) - - operator_matmul = operator2.matmul(operator1) - self.assertIsInstance( - operator_matmul, - linalg_lib.LinearOperatorScaledIdentity) - self.assertAllClose(3., self.evaluate(operator_matmul.multiplier)) - - def test_identity_solve(self): - operator1 = linalg_lib.LinearOperatorIdentity(num_rows=2) - operator2 = linalg_lib.LinearOperatorScaledIdentity( - num_rows=2, multiplier=3.) - self.assertIsInstance( - operator1.solve(operator1), - linalg_lib.LinearOperatorIdentity) - - self.assertIsInstance( - operator2.solve(operator2), - linalg_lib.LinearOperatorScaledIdentity) - - operator_solve = operator1.solve(operator2) - self.assertIsInstance( - operator_solve, - linalg_lib.LinearOperatorScaledIdentity) - self.assertAllClose(3., self.evaluate(operator_solve.multiplier)) - - operator_solve = operator2.solve(operator1) - self.assertIsInstance( - operator_solve, - linalg_lib.LinearOperatorScaledIdentity) - self.assertAllClose(1. / 3., self.evaluate(operator_solve.multiplier)) - - def test_scaled_identity_cholesky_type(self): - operator = linalg_lib.LinearOperatorScaledIdentity( - num_rows=2, - multiplier=3., - is_positive_definite=True, - is_self_adjoint=True, - ) - self.assertIsInstance( - operator.cholesky(), - linalg_lib.LinearOperatorScaledIdentity) + # TODO(jmontalt). + # def test_identity_matmul(self): + # operator1 = linear_operator_identity.LinearOperatorIdentity(domain_shape=[2]) + # operator2 = linear_operator_identity.LinearOperatorScaledIdentity( + # domain_shape=[2], multiplier=3.) + # self.assertIsInstance( + # operator1.matmul(operator1), + # linear_operator_identity.LinearOperatorIdentity) + + # self.assertIsInstance( + # operator1.matmul(operator1), + # linear_operator_identity.LinearOperatorIdentity) + + # self.assertIsInstance( + # operator2.matmul(operator2), + # linear_operator_identity.LinearOperatorScaledIdentity) + + # operator_matmul = operator1.matmul(operator2) + # self.assertIsInstance( + # operator_matmul, + # linear_operator_identity.LinearOperatorScaledIdentity) + # self.assertAllClose(3., self.evaluate(operator_matmul.multiplier)) + + # operator_matmul = operator2.matmul(operator1) + # self.assertIsInstance( + # operator_matmul, + # linear_operator_identity.LinearOperatorScaledIdentity) + # self.assertAllClose(3., self.evaluate(operator_matmul.multiplier)) + +# def test_identity_solve(self): +# operator1 = linear_operator_identity.LinearOperatorIdentity(domain_shape=[2]) +# operator2 = linear_operator_identity.LinearOperatorScaledIdentity( +# domain_shape=[2], multiplier=3.) +# self.assertIsInstance( +# operator1.solve(operator1), +# linear_operator_identity.LinearOperatorIdentity) + +# self.assertIsInstance( +# operator2.solve(operator2), +# linear_operator_identity.LinearOperatorScaledIdentity) + +# operator_solve = operator1.solve(operator2) +# self.assertIsInstance( +# operator_solve, +# linear_operator_identity.LinearOperatorScaledIdentity) +# self.assertAllClose(3., self.evaluate(operator_solve.multiplier)) + +# operator_solve = operator2.solve(operator1) +# self.assertIsInstance( +# operator_solve, +# linear_operator_identity.LinearOperatorScaledIdentity) +# self.assertAllClose(1. / 3., self.evaluate(operator_solve.multiplier)) + +# def test_scaled_identity_cholesky_type(self): +# operator = linear_operator_identity.LinearOperatorScaledIdentity( +# domain_shape=[2], +# multiplier=3., +# is_positive_definite=True, +# is_self_adjoint=True, +# ) +# self.assertIsInstance( +# operator.cholesky(), +# linear_operator_identity.LinearOperatorScaledIdentity) def test_scaled_identity_inverse_type(self): - operator = linalg_lib.LinearOperatorScaledIdentity( - num_rows=2, + operator = linear_operator_identity.LinearOperatorScaledIdentity( + domain_shape=[2], multiplier=3., is_non_singular=True, ) self.assertIsInstance( operator.inverse(), - linalg_lib.LinearOperatorScaledIdentity) + linear_operator_identity.LinearOperatorScaledIdentity) def test_ref_type_shape_args_raises(self): - with self.assertRaisesRegex(TypeError, "num_rows.*reference"): - linalg_lib.LinearOperatorScaledIdentity( - num_rows=variables_module.Variable(2), multiplier=1.23) + with self.assertRaisesRegex(TypeError, "domain_shape.*reference"): + linear_operator_identity.LinearOperatorScaledIdentity( + domain_shape=tf.Variable(2), multiplier=1.23) def test_tape_safe(self): - multiplier = variables_module.Variable(1.23) - operator = linalg_lib.LinearOperatorScaledIdentity( - num_rows=2, multiplier=multiplier) + multiplier = tf.Variable(1.23) + operator = linear_operator_identity.LinearOperatorScaledIdentity( + domain_shape=[2], multiplier=multiplier) self.check_tape_safe(operator) def test_convert_variables_to_tensors(self): - multiplier = variables_module.Variable(1.23) - operator = linalg_lib.LinearOperatorScaledIdentity( - num_rows=2, multiplier=multiplier) + multiplier = tf.Variable(1.23) + operator = linear_operator_identity.LinearOperatorScaledIdentity( + domain_shape=[2], multiplier=multiplier) with self.cached_session() as sess: sess.run([multiplier.initializer]) self.check_convert_variables_to_tensors(operator) @@ -589,4 +690,4 @@ def test_convert_variables_to_tensors(self): if __name__ == "__main__": linear_operator_test_util.add_tests(LinearOperatorIdentityTest) linear_operator_test_util.add_tests(LinearOperatorScaledIdentityTest) - test.main() + tf.test.main() diff --git a/tensorflow_mri/python/util/__init__.py b/tensorflow_mri/python/util/__init__.py index fe408a42..4cd8d11b 100644 --- a/tensorflow_mri/python/util/__init__.py +++ b/tensorflow_mri/python/util/__init__.py @@ -31,3 +31,4 @@ from tensorflow_mri.python.util import sys_util from tensorflow_mri.python.util import tensor_util from tensorflow_mri.python.util import test_util +from tensorflow_mri.python.util import types_util diff --git a/tensorflow_mri/python/util/tensor_util.py b/tensorflow_mri/python/util/tensor_util.py index dfeec070..207093fa 100644 --- a/tensorflow_mri/python/util/tensor_util.py +++ b/tensorflow_mri/python/util/tensor_util.py @@ -17,6 +17,9 @@ import tensorflow as tf +from tensorflow.python.ops.control_flow_ops import with_dependencies + + def cast_to_complex(tensor): """Casts a floating-point tensor to the corresponding complex dtype. @@ -110,12 +113,18 @@ def maybe_get_static_value(tensor): return tensor -def static_and_dynamic_shapes_from_shape(shape): +def static_and_dynamic_shapes_from_shape(shape, + assert_proper_shape=False, + arg_name=None): """Returns static and dynamic shapes from tensor shape. Args: shape: This could be a 1D integer tensor, a tensor shape, a list, a tuple or any other valid representation of a tensor shape. + assert_proper_shape: If `True`, adds assertion op to the graph to verify + that the shape is proper at runtime. If `False`, only static checks are + performed. + arg_name: An optional `str`. The name of the argument. Returns: A tuple of two objects: @@ -130,6 +139,25 @@ def static_and_dynamic_shapes_from_shape(shape): Raises: ValueError: If `shape` is not 1D. """ + try: + dynamic = tf.convert_to_tensor(shape, tf.int32) + except TypeError: + raise TypeError( + f"{arg_name or 'shape'} must be integer type. Found: {shape}") + if dynamic.shape.rank not in (None, 1): + raise ValueError( + f"{arg_name or 'shape'} must be a 1-D Tensor. Found: {shape}") + if assert_proper_shape: + dynamic = with_dependencies([ + tf.debugging.assert_rank( + dynamic, + 1, + message=f"{arg_name or 'shape'} must be a 1-D Tensor"), + tf.debugging.assert_non_negative( + dynamic, + message=f"{arg_name or 'shape'} must be non-negative"), + ], dynamic) + static = tf.get_static_value(shape, partial=True) if (static is None and isinstance(shape, tf.Tensor) and @@ -138,8 +166,11 @@ def static_and_dynamic_shapes_from_shape(shape): # values but known shape. In this case `tf.get_static_value` will simply # return None, but we can still infer the rank if we're a bit smarter. static = [None] * shape.shape[0] + # Check value is non-negative. This will be done by `tf.TensorShape`, but + # do it here anyway so that we can provide a more informative error. + if static is not None and any(s is not None and s < 0 for s in static): + raise ValueError( + f"{arg_name or 'shape'} must be non-negative. Found: {shape}") static = tf.TensorShape(static) - dynamic = tf.convert_to_tensor(shape, tf.int32) - if dynamic.shape.rank != 1: - raise ValueError(f"Expected shape to be 1D, got {dynamic}.") + return static, dynamic diff --git a/tensorflow_mri/python/util/types_util.py b/tensorflow_mri/python/util/types_util.py index 8ca424f3..3bfe8c9c 100644 --- a/tensorflow_mri/python/util/types_util.py +++ b/tensorflow_mri/python/util/types_util.py @@ -22,3 +22,28 @@ FLOATING_TYPES = [tf.float16, tf.float32, tf.float64] COMPLEX_TYPES = [tf.complex64, tf.complex128] + + +def is_ref(x): + """Evaluates if the object has reference semantics. + + An object is deemed "reference" if it is a `tf.Variable` instance or is + derived from a `tf.Module` with `dtype` and `shape` properties. + + Args: + x: Any object. + + Returns: + is_ref: Python `bool` indicating input is has nonreference semantics, i.e., + is a `tf.Variable` or a `tf.Module` with `dtype` and `shape` properties. + """ + return ( + isinstance(x, tf.Variable) or + (isinstance(x, tf.Module) and hasattr(x, "dtype") and + hasattr(x, "shape"))) + + +def assert_not_ref_type(x, arg_name): + if is_ref(x): + raise TypeError( + f"Argument {arg_name} cannot be reference type. Found: {type(x)}.") From 6d0047a1d6a5a8ccba4b65ee6a7cf87f229c6ec6 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 14 Sep 2022 15:28:28 +0000 Subject: [PATCH 099/101] Fixed README --- README.md | 2 +- tensorflow_mri/python/util/tensor_util.py | 10 +++++++--- tools/docs/guide/install.md | 4 ++-- tools/docs/templates/index.md | 4 ++-- 4 files changed, 12 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index 0554aef2..81743ae0 100644 --- a/README.md +++ b/README.md @@ -7,7 +7,7 @@ [![Docs](https://img.shields.io/badge/api-reference-blue.svg)](https://mrphys.github.io/tensorflow-mri/) [![DOI](https://zenodo.org/badge/388094708.svg)](https://zenodo.org/badge/latestdoi/388094708) -% start-intro + TensorFlow MRI is a library of TensorFlow operators for computational MRI. The library has a Python interface and is mostly written in Python. However, diff --git a/tensorflow_mri/python/util/tensor_util.py b/tensorflow_mri/python/util/tensor_util.py index 207093fa..5f6529e1 100644 --- a/tensorflow_mri/python/util/tensor_util.py +++ b/tensorflow_mri/python/util/tensor_util.py @@ -138,10 +138,14 @@ def static_and_dynamic_shapes_from_shape(shape, Raises: ValueError: If `shape` is not 1D. + TypeError: If `shape` does not have integer dtype. """ - try: - dynamic = tf.convert_to_tensor(shape, tf.int32) - except TypeError: + if isinstance(shape, (tuple, list)) and not shape: + dtype = tf.int32 + else: + dtype = None + dynamic = tf.convert_to_tensor(shape, dtype=dtype, name=arg_name) + if not dynamic.dtype.is_integer: raise TypeError( f"{arg_name or 'shape'} must be integer type. Found: {shape}") if dynamic.shape.rank not in (None, 1): diff --git a/tools/docs/guide/install.md b/tools/docs/guide/install.md index 79935f08..73571a5b 100644 --- a/tools/docs/guide/install.md +++ b/tools/docs/guide/install.md @@ -18,8 +18,8 @@ versions of TensorFlow and TensorFlow MRI according to the table below. ```{include} ../../../README.md --- -start-after: start-compatibility-table -end-before: end-compatibility-table +start-after: +end-before: --- ``` diff --git a/tools/docs/templates/index.md b/tools/docs/templates/index.md index 181fc54f..ef928571 100644 --- a/tools/docs/templates/index.md +++ b/tools/docs/templates/index.md @@ -2,8 +2,8 @@ ```{include} ../../README.md --- -start-after: start-intro -end-before: end-intro +start-after: +end-before: --- ``` From e24108e7f85617e3af37dccab9a9292b6dfc6872 Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Wed, 14 Sep 2022 15:58:13 +0000 Subject: [PATCH 100/101] Linting --- pylintrc | 4 +- .../python/layers/coil_sensitivities.py | 2 +- tensorflow_mri/python/layers/concatenate.py | 2 +- .../python/layers/data_consistency.py | 4 +- tensorflow_mri/python/layers/normalization.py | 4 +- tensorflow_mri/python/layers/padding.py | 2 +- tensorflow_mri/python/layers/pooling.py | 4 +- .../python/layers/preproc_layers.py | 14 +-- tensorflow_mri/python/layers/recon_adjoint.py | 2 +- tensorflow_mri/python/layers/reshaping.py | 2 +- tensorflow_mri/python/layers/signal_layers.py | 2 +- .../python/linalg/linear_operator.py | 8 +- .../python/linalg/linear_operator_algebra.py | 1 + .../python/linalg/linear_operator_identity.py | 4 +- .../linalg/linear_operator_identity_test.py | 111 ++++++++++-------- .../python/linalg/linear_operator_mri.py | 3 + tensorflow_mri/python/models/conv_blocks.py | 6 +- tensorflow_mri/python/models/conv_endec.py | 3 +- tensorflow_mri/python/ops/fft_ops_test.py | 5 +- 19 files changed, 98 insertions(+), 85 deletions(-) diff --git a/pylintrc b/pylintrc index b74f480f..4cf1c83b 100755 --- a/pylintrc +++ b/pylintrc @@ -327,10 +327,10 @@ ignore-exceptions=AssertionError,NotImplementedError,StopIteration,TypeError # Number of spaces of indent required when the last token on the preceding line # is an open (, [, or {. -indent-after-paren=2 +indent-after-paren=4 [GOOGLE LINES] # Regexp for a proper copyright notice. -copyright=Copyright \d{4} University College London\. +All [Rr]ights [Rr]eserved\. +copyright=Copyright \d{4} The TensorFlow MRI Authors\. +All [Rr]ights [Rr]eserved\. diff --git a/tensorflow_mri/python/layers/coil_sensitivities.py b/tensorflow_mri/python/layers/coil_sensitivities.py index ae756021..04f4465a 100644 --- a/tensorflow_mri/python/layers/coil_sensitivities.py +++ b/tensorflow_mri/python/layers/coil_sensitivities.py @@ -66,7 +66,7 @@ def __init__(self, self.refinement_network = tf.keras.layers.TimeDistributed( network_class(**network_kwargs)) - def call(self, inputs): + def call(self, inputs): # pylint: arguments-differ data, operator, calib_data = parse_inputs(inputs) # Compute coil sensitivities. diff --git a/tensorflow_mri/python/layers/concatenate.py b/tensorflow_mri/python/layers/concatenate.py index 5a894631..d852dd2e 100644 --- a/tensorflow_mri/python/layers/concatenate.py +++ b/tensorflow_mri/python/layers/concatenate.py @@ -33,7 +33,7 @@ def __init__(self, axis=-1, **kwargs): super().__init__(**kwargs) self.axis = axis - def call(self, inputs): # pylint: disable=missing-function-docstring + def call(self, inputs): # pylint: disable=missing-function-docstring,arguments-differ if not isinstance(inputs, (list, tuple)): raise ValueError( f"Layer {self.__class__.__name__} expects a list of inputs. " diff --git a/tensorflow_mri/python/layers/data_consistency.py b/tensorflow_mri/python/layers/data_consistency.py index 717738db..645c4896 100644 --- a/tensorflow_mri/python/layers/data_consistency.py +++ b/tensorflow_mri/python/layers/data_consistency.py @@ -24,7 +24,7 @@ class LeastSquaresGradientDescent(tf.keras.layers.Layer): - """Least squares gradient descent layer. + """Least squares gradient descent layer for ${rank}-D images. """ def __init__(self, rank, @@ -51,7 +51,7 @@ def build(self, input_shape): trainable=self.trainable, constraint=tf.keras.constraints.NonNeg()) - def call(self, inputs): # pylint: disable=missing-function-docstring + def call(self, inputs): # pylint: disable=missing-function-docstring,arguments-differ image, data, operator = parse_inputs(inputs) if self.reinterpret_complex: image = math_ops.view_as_complex(image, stacked=False) diff --git a/tensorflow_mri/python/layers/normalization.py b/tensorflow_mri/python/layers/normalization.py index ffd6aa1d..4c909ee0 100644 --- a/tensorflow_mri/python/layers/normalization.py +++ b/tensorflow_mri/python/layers/normalization.py @@ -52,11 +52,11 @@ def __init__(self, layer, axis=-1, **kwargs): def compute_output_shape(self, input_shape): return self.layer.compute_output_shape(input_shape) - def call(self, inputs, **kwargs): + def call(self, inputs, *args, **kwargs): mean, variance = tf.nn.moments(inputs, axes=self.axis, keepdims=True) std = tf.math.maximum(tf.math.sqrt(variance), tf.keras.backend.epsilon()) inputs = (inputs - mean) / std - outputs = self.layer(inputs, **kwargs) + outputs = self.layer(inputs, *args, **kwargs) outputs = outputs * std + mean return outputs diff --git a/tensorflow_mri/python/layers/padding.py b/tensorflow_mri/python/layers/padding.py index a33e1602..0689b5f0 100644 --- a/tensorflow_mri/python/layers/padding.py +++ b/tensorflow_mri/python/layers/padding.py @@ -43,7 +43,7 @@ def __init__(self, rank, divisor=2, **kwargs): f'Received: {divisor}') self.input_spec = tf.keras.layers.InputSpec(ndim=rank + 2) - def call(self, inputs): # pylint: disable=missing-function-docstring + def call(self, inputs): # pylint: disable=missing-function-docstring,arguments-differ static_input_shape = inputs.shape static_output_shape = tuple( ((s + d - 1) // d) * d if s is not None else None for s, d in zip( diff --git a/tensorflow_mri/python/layers/pooling.py b/tensorflow_mri/python/layers/pooling.py index 5c070db2..ee953d86 100644 --- a/tensorflow_mri/python/layers/pooling.py +++ b/tensorflow_mri/python/layers/pooling.py @@ -52,7 +52,7 @@ def complex_pool(base): if issubclass(base, (tf.keras.layers.AveragePooling1D, tf.keras.layers.AveragePooling2D, tf.keras.layers.AveragePooling3D)): - def call(self, inputs): + def call(self, inputs): # pylint: arguments-differ if tf.as_dtype(self.dtype).is_complex: return tf.dtypes.complex( base.call(self, tf.math.real(inputs)), @@ -64,7 +64,7 @@ def call(self, inputs): elif issubclass(base, (tf.keras.layers.MaxPooling1D, tf.keras.layers.MaxPooling2D, tf.keras.layers.MaxPooling3D)): - def call(self, inputs): + def call(self, inputs): # pylint: arguments-differ if tf.as_dtype(self.dtype).is_complex: # For complex numbers the max is computed according to the magnitude # or absolute value of the complex input. To do this we rely on diff --git a/tensorflow_mri/python/layers/preproc_layers.py b/tensorflow_mri/python/layers/preproc_layers.py index 6be42b67..eedc40fc 100644 --- a/tensorflow_mri/python/layers/preproc_layers.py +++ b/tensorflow_mri/python/layers/preproc_layers.py @@ -31,7 +31,7 @@ class AddChannelDimension(tf.keras.layers.Layer): Args: **kwargs: Additional keyword arguments to be passed to base class. """ - def call(self, inputs): + def call(self, inputs): # pylint: arguments-differ """Runs forward pass on the input tensor.""" return tf.expand_dims(inputs, -1) @@ -43,7 +43,7 @@ class Cast(tf.keras.layers.Layer): Args: **kwargs: Additional keyword arguments to be passed to base class. """ - def call(self, inputs): + def call(self, inputs): # pylint: arguments-differ """Runs forward pass on the input tensor.""" return tf.cast(inputs, self.dtype) @@ -62,7 +62,7 @@ def __init__(self, axis, **kwargs): super().__init__(**kwargs) self._axis = axis - def call(self, inputs): + def call(self, inputs): # pylint: arguments-differ """Runs forward pass on the input tensor.""" return tf.expand_dims(inputs, self._axis) @@ -377,7 +377,7 @@ def __init__(self, repeats, **kwargs): super().__init__(**kwargs) self._repeats = repeats - def call(self, inputs): + def call(self, inputs): # pylint: arguments-differ """Runs forward pass on the input tensor.""" return [inputs] * self._repeats @@ -412,7 +412,7 @@ def __init__(self, shape, padding_mode='constant', **kwargs): self._shape_internal += [-1] self._padding_mode = padding_mode - def call(self, inputs): + def call(self, inputs): # pylint: arguments-differ """Runs forward pass on the input tensor.""" return array_ops.resize_with_crop_or_pad(inputs, self._shape_internal, padding_mode=self._padding_mode) @@ -441,7 +441,7 @@ def __init__(self, output_min=0.0, output_max=1.0, **kwargs): self._output_min = output_min self._output_max = output_max - def call(self, inputs): + def call(self, inputs): # pylint: arguments-differ """Runs forward pass on the input tensor.""" return math_ops.scale_by_min_max(inputs, self._output_min, self._output_max) @@ -468,7 +468,7 @@ def __init__(self, perm=None, conjugate=False, **kwargs): self._perm = perm self._conjugate = conjugate - def call(self, inputs): + def call(self, inputs): # pylint: arguments-differ """Runs forward pass on the input tensor.""" return tf.transpose(inputs, self._perm, conjugate=self._conjugate) diff --git a/tensorflow_mri/python/layers/recon_adjoint.py b/tensorflow_mri/python/layers/recon_adjoint.py index 5d3f18a9..18599a2e 100644 --- a/tensorflow_mri/python/layers/recon_adjoint.py +++ b/tensorflow_mri/python/layers/recon_adjoint.py @@ -88,7 +88,7 @@ def __init__(self, self.expand_channel_dim = expand_channel_dim self.reinterpret_complex = reinterpret_complex - def call(self, inputs): + def call(self, inputs): # pylint: arguments-differ data, operator = parse_inputs(inputs) image = recon_adjoint.recon_adjoint(data, operator) if self.expand_channel_dim: diff --git a/tensorflow_mri/python/layers/reshaping.py b/tensorflow_mri/python/layers/reshaping.py index d20decef..e9c918f4 100644 --- a/tensorflow_mri/python/layers/reshaping.py +++ b/tensorflow_mri/python/layers/reshaping.py @@ -51,7 +51,7 @@ def complex_reshape(base): if issubclass(base, (tf.keras.layers.UpSampling1D, tf.keras.layers.UpSampling2D, tf.keras.layers.UpSampling3D)): - def call(self, inputs): + def call(self, inputs): # pylint: arguments-differ if tf.as_dtype(self.dtype).is_complex: return tf.dtypes.complex( base.call(self, tf.math.real(inputs)), diff --git a/tensorflow_mri/python/layers/signal_layers.py b/tensorflow_mri/python/layers/signal_layers.py index eba871ca..a4762cc4 100644 --- a/tensorflow_mri/python/layers/signal_layers.py +++ b/tensorflow_mri/python/layers/signal_layers.py @@ -96,7 +96,7 @@ def __init__(self, rank, inverse, wavelet, mode, format_dict=True, **kwargs): else: raise NotImplementedError('rank must be 1, 2, or 3') - def call(self, inputs): # pylint: disable=missing-function-docstring + def call(self, inputs): # pylint: disable=missing-function-docstring,arguments-differ # If not using dict format, convert input to dict. if self.inverse and not self.format_dict: if not isinstance(inputs, (list, tuple)): diff --git a/tensorflow_mri/python/linalg/linear_operator.py b/tensorflow_mri/python/linalg/linear_operator.py index 49207d4b..e2f697b7 100644 --- a/tensorflow_mri/python/linalg/linear_operator.py +++ b/tensorflow_mri/python/linalg/linear_operator.py @@ -65,7 +65,7 @@ def preprocess(self, x, adjoint=False, name="preprocess"): Returns: The preprocessed `tf.Tensor` with the same `dtype` as `self`. """ - with self._name_scope(name): + with self._name_scope(name): # pylint: disable=not-callable x = tf.convert_to_tensor(x, name="x") self._check_input_dtype(x) input_shape = self.range_shape if adjoint else self.domain_shape @@ -89,7 +89,7 @@ def postprocess(self, x, adjoint=False, name="postprocess"): Returns: The preprocessed `tf.Tensor` with the same `dtype` as `self`. """ - with self._name_scope(name): + with self._name_scope(name): # pylint: disable=not-callable x = tf.convert_to_tensor(x, name="x") self._check_input_dtype(x) input_shape = self.domain_shape if adjoint else self.range_shape @@ -572,14 +572,14 @@ def from_operator(cls, operator): """ validation_fields = ("is_non_singular", "is_self_adjoint", "is_positive_definite", "is_square") - kwargs = tf_linear_operator._extract_attrs( + kwargs = tf_linear_operator._extract_attrs( # pylint: disable=protected-access operator, keys=set(operator._composite_tensor_fields + validation_fields)) # pylint: disable=protected-access non_tensor_params = {} param_specs = {} for k, v in list(kwargs.items()): - type_spec_or_v = tf_linear_operator._extract_type_spec_recursively(v) + type_spec_or_v = tf_linear_operator._extract_type_spec_recursively(v) # pylint: disable=protected-access is_tensor = [isinstance(x, type_spec.TypeSpec) for x in tf.nest.flatten(type_spec_or_v)] if all(is_tensor): diff --git a/tensorflow_mri/python/linalg/linear_operator_algebra.py b/tensorflow_mri/python/linalg/linear_operator_algebra.py index 9ad76612..ff0f2965 100644 --- a/tensorflow_mri/python/linalg/linear_operator_algebra.py +++ b/tensorflow_mri/python/linalg/linear_operator_algebra.py @@ -12,6 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== +"""Linear operator algebra.""" from tensorflow.python.ops.linalg import linear_operator_algebra diff --git a/tensorflow_mri/python/linalg/linear_operator_identity.py b/tensorflow_mri/python/linalg/linear_operator_identity.py index 7d025c25..187632b0 100644 --- a/tensorflow_mri/python/linalg/linear_operator_identity.py +++ b/tensorflow_mri/python/linalg/linear_operator_identity.py @@ -25,7 +25,7 @@ @api_util.export("linalg.LinearOperatorIdentity") @linear_operator.make_composite_tensor -class LinearOperatorIdentity(linear_operator.LinearOperatorMixin, +class LinearOperatorIdentity(linear_operator.LinearOperatorMixin, # pylint: disable=abstract-method tf.linalg.LinearOperatorIdentity): """Linear operator representing an identity matrix. @@ -116,7 +116,7 @@ def _transform(self, x, adjoint=False): rank = tf.size(self.domain_shape_tensor()) batch_shape = tf.broadcast_dynamic_shape( tf.shape(x)[:-rank], self.batch_shape_tensor()) - output_shape = tf.concat([batch_shape, self.domain_shape_tensor()], axis=0) + output_shape = tf.concat([batch_shape, self.domain_shape_tensor()], axis=0) # pylint: disable=unexpected-keyword-arg,no-value-for-parameter return tf.broadcast_to(x, output_shape) def _domain_shape(self): diff --git a/tensorflow_mri/python/linalg/linear_operator_identity_test.py b/tensorflow_mri/python/linalg/linear_operator_identity_test.py index e12b3d7f..7364b12b 100644 --- a/tensorflow_mri/python/linalg/linear_operator_identity_test.py +++ b/tensorflow_mri/python/linalg/linear_operator_identity_test.py @@ -14,8 +14,10 @@ # ============================================================================== """Tests for module `linear_operator_identity`. -Adapted from tensorflow/python/kernel_tests/linalg/linear_operator_identity_test.py +Adapted from: + tensorflow/python/kernel_tests/linalg/linear_operator_identity_test.py """ +# pylint: disable=missing-function-docstring import numpy as np import tensorflow as tf @@ -120,17 +122,20 @@ def test_shapes_dynamic(self): def test_assert_positive_definite(self): with self.cached_session(): - operator = linear_operator_identity.LinearOperatorIdentity(domain_shape=[2]) + operator = linear_operator_identity.LinearOperatorIdentity( + domain_shape=[2]) self.evaluate(operator.assert_positive_definite()) # Should not fail def test_assert_non_singular(self): with self.cached_session(): - operator = linear_operator_identity.LinearOperatorIdentity(domain_shape=[2]) + operator = linear_operator_identity.LinearOperatorIdentity( + domain_shape=[2]) self.evaluate(operator.assert_non_singular()) # Should not fail def test_assert_self_adjoint(self): with self.cached_session(): - operator = linear_operator_identity.LinearOperatorIdentity(domain_shape=[2]) + operator = linear_operator_identity.LinearOperatorIdentity( + domain_shape=[2]) self.evaluate(operator.assert_self_adjoint()) # Should not fail # TODO(jmontalt). @@ -162,15 +167,18 @@ def test_negative_domain_shape_raises_static(self): def test_non_1d_batch_shape_raises_static(self): with self.assertRaisesRegex( ValueError, "batch_shape must be a 1-D Tensor"): - linear_operator_identity.LinearOperatorIdentity(domain_shape=[2], batch_shape=2) + linear_operator_identity.LinearOperatorIdentity( + domain_shape=[2], batch_shape=2) def test_non_integer_batch_shape_raises_static(self): with self.assertRaisesRegex(TypeError, "must be integer"): - linear_operator_identity.LinearOperatorIdentity(domain_shape=[2], batch_shape=[2.]) + linear_operator_identity.LinearOperatorIdentity( + domain_shape=[2], batch_shape=[2.]) def test_negative_batch_shape_raises_static(self): with self.assertRaisesRegex(ValueError, "must be non-negative"): - linear_operator_identity.LinearOperatorIdentity(domain_shape=[2], batch_shape=[-2]) + linear_operator_identity.LinearOperatorIdentity( + domain_shape=[2], batch_shape=[-2]) def test_non_1d_domain_shape_raises_dynamic(self): with self.cached_session(): @@ -228,9 +236,10 @@ def test_default_batch_shape_broadcasts_with_everything_static(self): # These cannot be done in the automated (base test class) tests since they # test shapes that tf.batch_matmul cannot handle. # In particular, tf.batch_matmul does not broadcast. - with self.cached_session() as sess: + with self.cached_session(): x = tf.random.normal(shape=(1, 2, 3, 4)) - operator = linear_operator_identity.LinearOperatorIdentity(domain_shape=[3], dtype=x.dtype) + operator = linear_operator_identity.LinearOperatorIdentity( + domain_shape=[3], dtype=x.dtype) operator_matmul = operator.matmul(x) expected = x @@ -243,8 +252,10 @@ def test_default_batch_shape_broadcasts_with_everything_dynamic(self): # test shapes that tf.batch_matmul cannot handle. # In particular, tf.batch_matmul does not broadcast. with self.cached_session(): - x = tf.compat.v1.placeholder_with_default(rng.randn(1, 2, 3, 4), shape=None) - operator = linear_operator_identity.LinearOperatorIdentity(domain_shape=[3], dtype=x.dtype) + x = tf.compat.v1.placeholder_with_default( + rng.randn(1, 2, 3, 4), shape=None) + operator = linear_operator_identity.LinearOperatorIdentity( + domain_shape=[3], dtype=x.dtype) operator_matmul = operator.matmul(x) expected = x @@ -255,7 +266,7 @@ def test_broadcast_matmul_static_shapes(self): # These cannot be done in the automated (base test class) tests since they # test shapes that tf.batch_matmul cannot handle. # In particular, tf.batch_matmul does not broadcast. - with self.cached_session() as sess: + with self.cached_session(): # Given this x and LinearOperatorIdentity shape of (2, 1, 6, 6), the # broadcast shape of operator and 'x' is (2, 2, 6, 4) x = tf.random.normal(shape=(1, 2, 6, 4)) @@ -279,7 +290,8 @@ def test_broadcast_matmul_dynamic_shapes(self): with self.cached_session(): # Given this x and LinearOperatorIdentity shape of (2, 1, 6, 6), the # broadcast shape of operator and 'x' is (2, 2, 3, 4) - x = tf.compat.v1.placeholder_with_default(rng.rand(1, 2, 6, 4), shape=None) + x = tf.compat.v1.placeholder_with_default( + rng.rand(1, 2, 6, 4), shape=None) domain_shape = tf.compat.v1.placeholder_with_default((2, 3), shape=None) batch_shape = tf.compat.v1.placeholder_with_default((2, 1), shape=None) @@ -535,7 +547,7 @@ def test_broadcast_matmul_and_solve(self): # These cannot be done in the automated (base test class) tests since they # test shapes that tf.batch_matmul cannot handle. # In particular, tf.batch_matmul does not broadcast. - with self.cached_session() as sess: + with self.cached_session(): # Given this x and LinearOperatorScaledIdentity shape of (2, 1, 6, 6), the # broadcast shape of operator and 'x' is (2, 2, 6, 4) x = tf.random.normal(shape=(1, 2, 6, 4)) @@ -563,7 +575,7 @@ def test_broadcast_matmul_and_solve_scalar_scale_multiplier(self): # These cannot be done in the automated (base test class) tests since they # test shapes that tf.batch_matmul cannot handle. # In particular, tf.batch_matmul does not broadcast. - with self.cached_session() as sess: + with self.cached_session(): # Given this x and LinearOperatorScaledIdentity shape of (6, 6), the # broadcast shape of operator and 'x' is (1, 2, 6, 4), which is the same # shape as x. @@ -622,40 +634,41 @@ def test_is_x_flags(self): # linear_operator_identity.LinearOperatorScaledIdentity) # self.assertAllClose(3., self.evaluate(operator_matmul.multiplier)) -# def test_identity_solve(self): -# operator1 = linear_operator_identity.LinearOperatorIdentity(domain_shape=[2]) -# operator2 = linear_operator_identity.LinearOperatorScaledIdentity( -# domain_shape=[2], multiplier=3.) -# self.assertIsInstance( -# operator1.solve(operator1), -# linear_operator_identity.LinearOperatorIdentity) - -# self.assertIsInstance( -# operator2.solve(operator2), -# linear_operator_identity.LinearOperatorScaledIdentity) - -# operator_solve = operator1.solve(operator2) -# self.assertIsInstance( -# operator_solve, -# linear_operator_identity.LinearOperatorScaledIdentity) -# self.assertAllClose(3., self.evaluate(operator_solve.multiplier)) - -# operator_solve = operator2.solve(operator1) -# self.assertIsInstance( -# operator_solve, -# linear_operator_identity.LinearOperatorScaledIdentity) -# self.assertAllClose(1. / 3., self.evaluate(operator_solve.multiplier)) - -# def test_scaled_identity_cholesky_type(self): -# operator = linear_operator_identity.LinearOperatorScaledIdentity( -# domain_shape=[2], -# multiplier=3., -# is_positive_definite=True, -# is_self_adjoint=True, -# ) -# self.assertIsInstance( -# operator.cholesky(), -# linear_operator_identity.LinearOperatorScaledIdentity) + # def test_identity_solve(self): + # operator1 = linear_operator_identity.LinearOperatorIdentity( + # domain_shape=[2]) + # operator2 = linear_operator_identity.LinearOperatorScaledIdentity( + # domain_shape=[2], multiplier=3.) + # self.assertIsInstance( + # operator1.solve(operator1), + # linear_operator_identity.LinearOperatorIdentity) + + # self.assertIsInstance( + # operator2.solve(operator2), + # linear_operator_identity.LinearOperatorScaledIdentity) + + # operator_solve = operator1.solve(operator2) + # self.assertIsInstance( + # operator_solve, + # linear_operator_identity.LinearOperatorScaledIdentity) + # self.assertAllClose(3., self.evaluate(operator_solve.multiplier)) + + # operator_solve = operator2.solve(operator1) + # self.assertIsInstance( + # operator_solve, + # linear_operator_identity.LinearOperatorScaledIdentity) + # self.assertAllClose(1. / 3., self.evaluate(operator_solve.multiplier)) + + # def test_scaled_identity_cholesky_type(self): + # operator = linear_operator_identity.LinearOperatorScaledIdentity( + # domain_shape=[2], + # multiplier=3., + # is_positive_definite=True, + # is_self_adjoint=True, + # ) + # self.assertIsInstance( + # operator.cholesky(), + # linear_operator_identity.LinearOperatorScaledIdentity) def test_scaled_identity_inverse_type(self): operator = linear_operator_identity.LinearOperatorScaledIdentity( diff --git a/tensorflow_mri/python/linalg/linear_operator_mri.py b/tensorflow_mri/python/linalg/linear_operator_mri.py index e494adda..5f0cfe91 100644 --- a/tensorflow_mri/python/linalg/linear_operator_mri.py +++ b/tensorflow_mri/python/linalg/linear_operator_mri.py @@ -401,6 +401,9 @@ def _transform(self, x, adjoint=False): containing *k*-space data, if `adjoint` is `False`, or a `tf.Tensor` of type `self.dtype` and shape `[..., *self.domain_shape]` containing images, if `adjoint` is `True`. + + Raises: + ValueError: If the masking algorithm is invalid. """ if adjoint: # Apply density compensation. diff --git a/tensorflow_mri/python/models/conv_blocks.py b/tensorflow_mri/python/models/conv_blocks.py index 0744fcb0..ede6fb96 100644 --- a/tensorflow_mri/python/models/conv_blocks.py +++ b/tensorflow_mri/python/models/conv_blocks.py @@ -218,16 +218,12 @@ def __init__(self, if self.use_residual: self._add = tf.keras.layers.Add() - def call(self, inputs): # pylint: disable=unused-argument, missing-param-doc - """Runs forward pass on the input tensor.""" + def call(self, inputs): # pylint: disable=unused-argument x = inputs - for layer in self._layers: x = layer(x) - if self.use_residual: x = self._add([x, inputs]) - return x def get_config(self): diff --git a/tensorflow_mri/python/models/conv_endec.py b/tensorflow_mri/python/models/conv_endec.py index 8524dccd..95a680e7 100644 --- a/tensorflow_mri/python/models/conv_endec.py +++ b/tensorflow_mri/python/models/conv_endec.py @@ -308,8 +308,7 @@ def upsamp_fn(**config): self._add = tf.keras.layers.Add() self._out_activation = tf.keras.layers.Activation(self.output_activation) - def call(self, inputs): # pylint: disable=missing-param-doc - """Runs forward pass on the input tensors.""" + def call(self, inputs): x = inputs # For skip connections to decoder. diff --git a/tensorflow_mri/python/ops/fft_ops_test.py b/tensorflow_mri/python/ops/fft_ops_test.py index c4033ea1..b78c4a95 100644 --- a/tensorflow_mri/python/ops/fft_ops_test.py +++ b/tensorflow_mri/python/ops/fft_ops_test.py @@ -28,6 +28,7 @@ # limitations under the License. # ============================================================================== """Tests for module `fft_ops`.""" +# pylint: disable=missing-function-docstring,unused-argument,missing-class-docstring,no-else-return import distutils import itertools @@ -54,7 +55,7 @@ class BaseFFTOpsTest(test.TestCase): - + """Base class for FFT tests.""" def _compare(self, x, rank, fft_length=None, use_placeholder=False, rtol=1e-4, atol=1e-4): self._compare_forward(x, rank, fft_length, use_placeholder, rtol, atol) @@ -124,7 +125,7 @@ def f(inx): @test_util.run_all_in_graph_and_eager_modes class FFTNTest(BaseFFTOpsTest, parameterized.TestCase): - + """Tests for `fftn`.""" def _tf_fft(self, x, rank, fft_length=None, feed_dict=None): # fft_length unused for complex FFTs. with self.cached_session() as sess: From 5a68e77c91ab937ad92f97c931df17e12046ec4b Mon Sep 17 00:00:00 2001 From: Javier Montalt Tordera Date: Fri, 21 Oct 2022 15:51:32 +0100 Subject: [PATCH 101/101] Fix linop --- tensorflow_mri/python/linalg/linear_operator.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/tensorflow_mri/python/linalg/linear_operator.py b/tensorflow_mri/python/linalg/linear_operator.py index e2f697b7..9ad6bc3c 100644 --- a/tensorflow_mri/python/linalg/linear_operator.py +++ b/tensorflow_mri/python/linalg/linear_operator.py @@ -183,13 +183,16 @@ def _matmul(self, x, adjoint=False, adjoint_arg=False): # unpacked by `tf.map_fn`. Typically subclasses should not need to override # this method. batch_shape = tf.broadcast_static_shape(x.shape[:-2], self.batch_shape) + output_dim = self.domain_dimension if adjoint else self.range_dimension + if adjoint_arg and x.dtype.is_complex: + x = tf.math.conj(x) x = tf.einsum('...ij->i...j' if adjoint_arg else '...ij->j...i', x) - x = tf.map_fn(functools.partial(self.matvec, adjoint=adjoint), x, + y = tf.map_fn(functools.partial(self.matvec, adjoint=adjoint), x, fn_output_signature=tf.TensorSpec( - shape=batch_shape + [self.range_dimension], + shape=batch_shape + [output_dim], dtype=x.dtype)) - x = tf.einsum('i...j->...ij' if adjoint_arg else 'j...i->...ij', x) - return x + y = tf.einsum('i...j->...ji' if adjoint_arg else 'j...i->...ij', y) + return y @abc.abstractmethod def _domain_shape(self):