Saravanan666/pypi-org huggingface dataset:
Package: torchsparsegradutils
Sparsity-preserving gradient utility tools for PyTorchA collection of utility functions to work with PyTorch sparse tensors. This is work-in-progress, here be dragons.Currenly available features with backprop include:Memory efficient sparse mm with batch support (workaround forhttps://github.com/pytorch/pytorch/issues/41128)Sparse triangular solver with batch support (see discussion inhttps://github.com/pytorch/pytorch/issues/87358)Generic sparse linear solver (requires a non-differentiable backbone sparse solver)Generic sparse linear least-squares solver (requires a non-differentiable backbone sparse linear least-squares solver)Wrappers aroundcupy sparse solvers(see discussion inhttps://github.com/pytorch/pytorch/issues/69538)Wrappers aroundjax sparse solversSparse multivariate normal distribution with sparse covariance and precision parameterisation, with reparameterised sampling (rsample)Additional backbone solvers implemented in pytorch with no additional dependencies include:BICGSTAB (ported frompykrylov)CG (ported fromcornellius-gp/linear_operator)LSMR (ported frompytorch-minimize)MINRES (ported fromcornellius-gp/linear_operator)Additional features:Pairwise voxel encoder for encoding local neighbourhood relationships in a 3D spatial volume with multiple channels, into a sparse COO or CSR matrix.Things that are missing may be listed asissues.InstallationThe provided package can be installed using:pip install torchsparsegradutilsorpip install git+https://github.com/cai4cai/torchsparsegradutilsUnit TestsA number of unittests are provided, which can be run as:python -m pytest(Note that this also runs the tests fromunittest)
Package: torch-sparse-solve
Torch Sparse SolveAn alternative totorch.solvefor sparse PyTorch CPU tensors using
the efficientKLU algorithm.CPU tensors onlyThis library is a wrapper around theSuiteSparseKLU
algorithms. This means the algorithm is only implemented for
C-arrays and hence is only available for PyTorch CPU
tensors. However, for large, sparse enough tensors, it might still be
worth doing the GPU→CPU conversion.UsageThetorch_sparse_solvelibrary provides a single functionsolve(A, b), which solves forxin thebatched matrix × batched matrixsystemAx=bfortorch.float64tensors (notice the different API in comparison totorch.solve):importtorchfromtorch_sparse_solveimportsolvetorch.manual_seed(42)mask=torch.tensor([[[1,0,0],[1,1,0],[0,0,1]]],dtype=torch.float64)A=(mask*torch.randn(4,3,3,dtype=torch.float64)).to_sparse()b=torch.randn(4,3,2,dtype=torch.float64)x=solve(A,b)# compare to torch.solve:A=A.to_dense()print((x-torch.solve(b,A)[0]<1e-9).all())TrueCaveatsThere are two major caveats you should be aware of when usingtorch_sparse_solve.solve(A, b):Ashould be 'dense' in the first dimension, i.e. the batch dimension
should contain as many elements as the batch size.Ashould have the same sparsity pattern for every element in the batch.
If this is not the case, you have two options:Create a new sparse matrix with the same sparsity pattern for
every element in the batch by adding zeros to the sparse
representation.ORloop over the batch dimension and solve sequentially, i.e.
with shapes(1, m, m)and(1, m, n)for each element inAandbrespectively.InstallationThe library can be installed withpip:pipinstalltorch_sparse_solvePlease note that no pre-built wheels exist. This means thatpipwill
attempt to install the library from source. Make sure you have the
necessary dependencies installed for your OS.DependenciesLinuxOn Linux, having PyTorch, scipy and suitesparse installed is often
enough to be able install the library (along with the typical
developer tools for your distribution). Run the following inside a
conda environment:condainstallsuitesparsescipy
condainstallpytorch-cpytorch
pipinstalltorch_sparse_solveWindowsOn Windows, the installation process is a bit more involved as
typically the build dependencies are not installed. To install those,
downloadVisual Studio Community 2017fromhere.
During installation, go toWorkloadsand select the following
workloads:Desktop development with C++Python developmentThen go toIndividual Componentsand select the following
additional items:C++/CLI supportVC++ 2015.3 v14.00 (v140) toolset for desktopThen, download and install Microsoft Visual C++ Redistributable fromhere.After these installation steps, run the following commandsinsideax64 Native Tools Command Prompt for VS 2017, after activating your
conda environment:setDISTUTILS_USE_SDK=1condainstallsuitesparsescipy
condainstallpytorch-cpytorch
pipinstalltorch_sparse_solveLicense & Credits© Floris Laporte 2020, LGPL-2.1This library was partly based on:SuiteSparse, LGPL-2.1kagami-c/PyKLU, LGPL-2.1scipy.sparse, BSD-3
Package: torch-spatiotemporal
Neural spatiotemporal forecasting with PyTorch🚀Getting Started- 📚Documentation- 💻Introductory notebooktsl(Torch Spatiotemporal)is a library built to accelerate research on neural spatiotemporal data processing
methods, with a focus on Graph Neural Networks.tsl is built on several libraries of thePythonscientific computing ecosystem, with the final objective of providing a straightforward process that goes from data preprocessing to model prototyping.
In particular,tsl offers a wide range of utilities to develop neural networks inPyTorchfor processing spatiotemporal data signals.Getting StartedBefore you start usingtsl, please review thedocumentationto get an understanding of the library and its capabilities.You can also explore the examples provided in theexamplesdirectory to see how train deep learning models working with spatiotemporal data.InstallationBefore installingtsl, make sure you have installedPyTorch(>=1.9.0) andPyG(>=2.0.3) in your virtual environment (seePyG installation guidelines).tsl is available for Python>=3.8. We recommend installation from github to be up-to-date with the latest version:pipinstallgit+https://github.com/TorchSpatiotemporal/tsl.gitAlternatively, you can install the library from the pypi repository:pipinstalltorch-spatiotemporalTo avoid dependencies issues, we recommend usingAnacondaand the provided environment configuration by running the command:condaenvcreate-fconda_env.ymlTutorialThe best way to start usingtsl is by following the tutorial notebook inexamples/notebooks/a_gentle_introduction_to_tsl.ipynb.DocumentationThe documentation is hosted onreadthedocs. For local access, you can build it from thedocsdirectory.CitingIf you use Torch Spatiotemporal for your research, please consider citing the library@software{Cini_Torch_Spatiotemporal_2022,
    author ={Cini, Andrea and Marisca, Ivan},
    license ={MIT},
    month ={3},
    title ={{Torch Spatiotemporal}},
    url ={https://github.com/TorchSpatiotemporal/tsl},
    year ={2022}}ByAndrea CiniandIvan Marisca.Thanks to all contributors! Check theContributing guidelinesand help us build a bettertsl.
Package: torch-specinv
Spectrogram InversionSome useful spectrogram inversion tools written in PyTorch.MethodsGriffin & LimGriffin, Daniel, and Jae Lim. "Signal estimation from modified short-time Fourier transform." IEEE Transactions on Acoustics, Speech, and Signal Processing 32, no. 2 (1984): 236-243.RTISI-LAZhu, Xinglei, Gerald T. Beauregard, and Lonce Wyse. "Real-time iterative spectrum inversion with look-ahead." In 2006 IEEE International Conference on Multimedia and Expo, pp. 229-232. IEEE, 2006.L-BFGSDecorsière, Rémi, Peter L. Søndergaard, Ewen N. MacDonald, and Torsten Dau. "Inversion of auditory spectrograms, traditional spectrograms, and other envelope representations." IEEE/ACM Transactions on Audio, Speech, and Language Processing 23, no. 1 (2014): 46-56.TODOSpeed comparison on GPU.Documentation.Examples.
Package: torchspleeter
torchspleeterTorchspleeter is a simplified interface for spleeter running completely on Torch, enabling cross platform functionality. It comes with a converted version of the 2stems model built in, and largely builds off the work ofTuan Nguyen.Installationpip install torchspleeteror download from this repository andpip install .UsageTorchspleeter comes with both a Python API and a standard CLI for simplistic use. Once installed, you can usetorchspleeter -hfor instructions on how to use the CLI.For the Python API, an example is pretty simple:from torchspleeter.command_interface import *

outputfiles=split_to_parts(input_audio_file,output_directory)This will return two files, the first one isolates the vocals and the second everything but the vocals, using the default 2stems model included with torchspleeter. The number of files scales to the number of models specified.This makes torchspleeter ideal for situations specifically where you need to isolate vocals, such as generating voice datasets.Seethe testing examplefor in depth useage.ReferenceOriginal SpleeterTuan NguyenContributingIf you'd like to contribute, please do! Please check theCONTRIBUTING.mdfor details on the best way to get started.LicenseMIT.
Package: torchstain
torchstainGPU-accelerated stain normalization tools for histopathological images. Compatible with PyTorch, TensorFlow, and Numpy.
Normalization algorithms currently implemented:Macenko[1](ported fromnumpy implementation)Reinhard[2]Modified Reinhard[3]InstallationpipinstalltorchstainTo install a specific backend use eithertorchstain[torch]ortorchstain[tf]. The numpy backend is included by default in both.Example Usageimporttorchfromtorchvisionimporttransformsimporttorchstainimportcv2target=cv2.cvtColor(cv2.imread("./data/target.png"),cv2.COLOR_BGR2RGB)to_transform=cv2.cvtColor(cv2.imread("./data/source.png"),cv2.COLOR_BGR2RGB)T=transforms.Compose([transforms.ToTensor(),transforms.Lambda(lambdax:x*255)])torch_normalizer=torchstain.normalizers.MacenkoNormalizer(backend='torch')torch_normalizer.fit(T(target))t_to_transform=T(to_transform)norm,H,E=normalizer.normalize(I=t_to_transform,stains=True)Implemented algorithmsAlgorithmnumpytorchtensorflowMacenko✓✓✓Reinhard✓✓✓Modified Reinhard✓✓✓Backend comparisonResults with 10 runs per size on a Intel(R) Core(TM) i5-8365U CPU @ 1.60GHzsizenumpy avg. timetorch avg. timetf avg. time2240.0182s ± 0.00160.0180s ± 0.03900.0048s ± 0.00024480.0880s ± 0.02240.0283s ± 0.01720.0210s ± 0.00256720.1810s ± 0.01390.0463s ± 0.03010.0354s ± 0.00188960.3013s ± 0.03770.0820s ± 0.03290.0713s ± 0.000811200.4694s ± 0.03500.1321s ± 0.02370.1036s ± 0.004213440.6640s ± 0.05530.1665s ± 0.00260.1663s ± 0.002115681.1935s ± 0.07390.2590s ± 0.00880.2531s ± 0.003117921.4523s ± 0.02070.3402s ± 0.01140.3080s ± 0.0188Reference[1] Macenko, Marc et al. "A method for normalizing histology slides for quantitative analysis." 2009 IEEE International Symposium on Biomedical Imaging: From Nano to Macro. IEEE, 2009.[2] Reinhard, Erik et al. "Color transfer between images." IEEE Computer Graphics and Applications. IEEE, 2001.[3] Roy, Santanu et al. "Modified Reinhard Algorithm for Color Normalization of Colorectal Cancer Histopathology Images". 2021 29th European Signal Processing Conference (EUSIPCO), IEEE, 2021.CitingIf you find this software useful for your research, please cite it as:@software{barbano2022torchstain,author={Carlo Alberto Barbano andAndré Pedersen},title={EIDOSLAB/torchstain: v1.2.0-stable},month=aug,year=2022,publisher={Zenodo},version={v1.2.0-stable},doi={10.5281/zenodo.6979540},url={https://doi.org/10.5281/zenodo.6979540}}Torchstain was originally developed within theUNITOPATHOdata collection, which you can cite as:@inproceedings{barbano2021unitopatho,title={UniToPatho, a labeled histopathological dataset for colorectal polyps classification and adenoma dysplasia grading},author={Barbano, Carlo Alberto and Perlo, Daniele and Tartaglione, Enzo and Fiandrotti, Attilio and Bertero, Luca and Cassoni, Paola and Grangetto, Marco},booktitle={2021 IEEE International Conference on Image Processing (ICIP)},pages={76--80},year={2021},organization={IEEE}}
Package: torchstat
torchstatThis is a lightweight neural network analyzer based on PyTorch.
It is designed to make building your networks quick and easy, with the ability to debug them.Note: This repository is currently under development. Therefore, some APIs might be changed.This tools can showTotal number of network parametersTheoretical amount of floating point arithmetics (FLOPs)Theoretical amount of multiply-adds (MAdd)Memory usageInstallingThere're two ways to install torchstat into your environment.Install it via pip.$pipinstalltorchstatInstall and update usingsetup.pyafter cloning this repository.$python3setup.pyinstallA Simple ExampleIf you want to run the torchstat asap, you can call it as a CLI tool if your network exists in a script.
Otherwise you need to import torchstat as a module.CLI tool$torchstatmasato$torchstat-fexample.py-mNet[MAdd]:Dropout2disnotsupported![Flops]:Dropout2disnotsupported![Memory]:Dropout2disnotsupported!modulenameinputshapeoutputshapeparamsmemory(MB)MAddFlopsMemRead(B)MemWrite(B)duration[%]MemR+W(B)0conv1322422410220220760.01.8572,600,000.036,784,000.0605152.01936000.057.49%2541152.01conv210110110201061065020.00.86112,360,000.056,404,720.0504080.0898880.026.62%1402960.02conv2_drop20106106201061060.00.860.00.00.00.04.09%0.03fc156180502809050.00.005,617,950.02,809,000.011460920.0200.011.58%11461120.04fc25010510.00.00990.0500.02240.040.00.22%2280.0
total2815340.03.56190,578,940.095,998,220.02240.040.0100.00%15407512.0===============================================================================================================================================Totalparams:2,815,340
-----------------------------------------------------------------------------------------------------------------------------------------------
Totalmemory:3.56MB
TotalMAdd:190.58MMAdd
TotalFlops:96.0MFlops
TotalMemR+W:14.69MBIf you're not sure how to use a specific command, run the command with the -h or –help switches.
You'll see usage information and a list of options you can use with the command.Modulefromtorchstatimportstatimporttorchvision.modelsasmodelsmodel=models.resnet18()stat(model,(3,224,224))Features & TODONote: These features work only nn.Module. Modules in torch.nn.functional are not supported yet.FLOPsNumber of ParametersTotal memoryMadd(FMA)MemReadMemWriteModel summary(detail, layer-wise)Export score tableArbitrary input shapeFor the supported layers, check outthe details.RequirementsPython 3.6+Pytorch 0.4.0+Pandas 0.23.4+NumPy 1.14.3+ReferencesThanks to @sovrasov for the initial version of flops computation, @ceykmc for the backbone of scripts.flops-counter.pytorchpytorch_model_summarychainer_computational_costconvnet-burden.
Package: torch-stethoscope
StethoscopeMedical imaging toolbox for PytorchContributingHow to contribute ?Create a branch by feature and/or bug fixGet the codeCommit and pushCreate a pull requestBranch namingFeature branchfeature/ [Short feature description] [Issue number]Bug branchfix/ [Short fix description] [Issue number]Commits syntax:Adding code:+ Added [Short Description] [Issue Number]Deleting code:- Deleted [Short Description] [Issue Number]Modifying code:* Changed [Short Description] [Issue Number]Merging code:Y Merged [Short Description] [Issue Number]Icons made byFreepikfromwww.flaticon.comis licensed byCC 3.0 BY
Package: torch-stft
STFT/iSTFT in PyTorchAn STFT/iSTFT written up in PyTorch using 1D Convolutions. Requirements are a recent version PyTorch, numpy, and librosa (for loading audio in test_stft.py). Thanks to Shrikant Venkataramani for sharing code this was based off of and Rafael Valle for catching bugs and adding the proper windowing logic. Uses Python 3.InstallationInstall easily with pip:pip install torch_stftUsageimport torch
from torch_stft import STFT
import numpy as np
import librosa 
import matplotlib.pyplot as plt

audio = librosa.load(librosa.util.example_audio_file(), duration=10.0, offset=30)[0]
device = 'cpu'
filter_length = 1024
hop_length = 256
win_length = 1024 # doesn't need to be specified. if not specified, it's the same as filter_length
window = 'hann'

audio = torch.FloatTensor(audio)
audio = audio.unsqueeze(0)
audio = audio.to(device)

stft = STFT(
    filter_length=filter_length, 
    hop_length=hop_length, 
    win_length=win_length,
    window=window
).to(device)

magnitude, phase = stft.transform(audio)
output = stft.inverse(magnitude, phase)
output = output.cpu().data.numpy()[..., :]
audio = audio.cpu().data.numpy()[..., :]
print(np.mean((output - audio) ** 2)) # on order of 1e-16Output ofcompare_stft.py:TestsTest it by just cloning this repo and runningpip install -r requirements.txt
python -m pytest .Unfortunately, since it's implemented with 1D Convolutions, some filter_length/hop_length
combinations can result in out of memory errors on your GPU when run on sufficiently large input.ContributingPull requests welcome.
Package: torch-stoi
PyTorch implementation of STOIImplementation of the classical and extended Short
Term Objective Intelligibility in PyTorch.
See alsoCees Taal's websiteand
thepython implementationInstallpipinstalltorch_stoiImportant warningThis implementation is intended to be used as a loss function only.It doesn't replicate the exact behavior of the original metrics
but the results should be close enough that it can be used
as a loss function. See the Notes in theNegSTOILossclass.Quantitative comparison coming soon hopefully :rocket:Usageimporttorchfromtorchimportnnfromtorch_stoiimportNegSTOILosssample_rate=16000loss_func=NegSTOILoss(sample_rate=sample_rate)# Your nnet and optimizer definition herennet=nn.Module()noisy_speech=torch.randn(2,16000)clean_speech=torch.randn(2,16000)# Estimate clean speechest_speech=nnet(noisy_speech)# Compute loss and backward (then step etc...)loss_batch=loss_func(est_speech,clean_speech)loss_batch.mean().backward()Comparing NumPy and PyTorch versions : the static testValues obtained with the NumPy version (commit84b1bd8) are compared to
the PyTorch version in the following graphs.8kHzClassic STOI measureExtended STOI measure16kHzClassic STOI measureExtended STOI measure16kHz signals used to compare both versions contained a lot
of silence, which explains why the match is very bad without
VAD.Comparing NumPy and PyTorch versions : Training a DNNComing in the near futureReferences[1] C.H.Taal, R.C.Hendriks, R.Heusdens, J.Jensen 'A Short-Time
Objective Intelligibility Measure for Time-Frequency Weighted Noisy Speech',
ICASSP 2010, Texas, Dallas.[2] C.H.Taal, R.C.Hendriks, R.Heusdens, J.Jensen 'An Algorithm for
Intelligibility Prediction of Time-Frequency Weighted Noisy Speech',
IEEE Transactions on Audio, Speech, and Language Processing, 2011.[3] J. Jensen and C. H. Taal, 'An Algorithm for Predicting the
Intelligibility of Speech Masked by Modulated Noise Maskers',
IEEE Transactions on Audio, Speech and Language Processing, 2016.
Package: torchstruct
torchstructWrap your multipletorch.Tensors into singleTensorStructand use it like you are usingtorch.Tensor.InstallationpipinstalltorchstructTestingPYTHONPATH=.pytestExamplesimporttorchfromtorchstructimportTensorStruct# Initializationts=TensorStruct.zeros({'obs':(2,),'rew':(1,),'done':(1,)},prefix_shape=(10,),dtype=torch.float32,device='cpu')raw_data={'obs':torch.randn((10,2)),'rew':torch.randn((10,1)),'done':torch.randn((10,1))}# Assigningts[:]=raw_data# Indexingts[2:4]ts['rew']# Calling PyTorch methodsts.unsqueeze(dim=0)ts.sum(dim=0)
Package: torch-struct
Torch-Struct: Structured Prediction LibraryA library of tested, GPU implementations of core structured prediction algorithms for deep learning applications.HMM / LinearChain-CRFHSMM / SemiMarkov-CRFDependency Tree-CRFPCFG Binary Tree-CRF...Designed to be used as efficient batched layers in other PyTorch code.Tutorial paperdescribing methodology.Getting Started!pipinstall-qUgit+https://github.com/harvardnlp/pytorch-struct# Optional CUDA kernels for FastLogSemiring!pipinstall-qUgit+https://github.com/harvardnlp/genbmm# For plotting.!pipinstall-qmatplotlibimporttorchfromtorch_structimportDependencyCRF,LinearChainCRFimportmatplotlib.pyplotaspltdefshow(x):plt.imshow(x.detach())# Make some data.vals=torch.zeros(2,10,10)+1e-5vals[:,:5,:5]=torch.rand(5)vals[:,5:,5:]=torch.rand(5)dist=DependencyCRF(vals.log())show(dist.log_potentials[0])# Compute marginalsshow(dist.marginals[0])# Compute argmaxshow(dist.argmax.detach()[0])# Compute scoring and enumeration (forward / inside)log_partition=dist.partitionmax_score=dist.log_prob(dist.argmax)# Compute samplesshow(dist.sample((1,)).detach()[0,0])# Padding/Masking built into library.dist=DependencyCRF(vals,lengths=torch.tensor([10,7]))show(dist.marginals[0])plt.show()show(dist.marginals[1])# Many other structured prediction approacheschain=torch.zeros(2,10,10,10)+1e-5chain[:,:,:,:]=vals.unsqueeze(-1).exp()chain[:,:,:,:]+=torch.eye(10,10).view(1,1,10,10)chain[:,0,:,0]=1chain[:,-1,9,:]=1chain=chain.log()dist=LinearChainCRF(chain)show(dist.marginals.detach()[0].sum(-1))LibraryFull docs:http://nlp.seas.harvard.edu/pytorch-struct/Current distributions implemented:LinearChainCRFSemiMarkovCRFDependencyCRFNonProjectiveDependencyCRFTreeCRFNeuralPCFG / NeuralHMMEach distribution includes:Argmax, sampling, entropy, partition, masking, log_probs, k-maxExtensions:Integration withtorchtext,pytorch-transformers,dglAdapters for generative structured models (CFG / HMM / HSMM)Common tree structured parameterizations TreeLSTM / SpanLSTMLow-level API:Everything implemented through semiring dynamic programming.Log MarginalsMax and MAP computationSampling through specialized backpropEntropy and first-order semirings.ExamplesBERTPart-of-SpeechBERTDependency ParsingUnsupervised LearningStructured VAECitation@misc{alex2020torchstruct,
    title={Torch-Struct: Deep Structured Prediction Library},
    author={Alexander M. Rush},
    year={2020},
    eprint={2002.00876},
    archivePrefix={arXiv},
    primaryClass={cs.CL}
}
Package: torchstuff
TorchStuffCalculate the Polygon area and length (perimeter).Table of ContentsInstallationUsageContributingInstallationpip3installtorchstuffUsageimporttorch# Example verticesvertices=torch.tensor([[0.0,0.0],[1.0,0.0],[1.0,1.0],[0.0,1.0]])# Create Polygon objectpolygon=Polygon(vertices)# Access propertiesarea=polygon.arealength=polygon.lengthprint(f"Area:{area}, Length:{length}")ContributingJust me for now
Package: torchsubband
torchsubbandThis's a package for subband decomposition.It can transform waveform into three kinds of revertable subband feature representations, which are potentially useful features for music source separation or similar tasks.UsageInstallationpipinstalltorchsubbandA simple example:fromtorchsubbandimportSubbandDSPimporttorch# nn.Modulemodel=SubbandDSP(subband=2)# You can choose 1,2,4, or 8batchsize=3# any int numberchannel=1# any int numberlength=44100*2# any int numberinput=torch.randn((batchsize,channel,length))# Get subband waveformsubwav=model.wav_to_sub(input)reconstruct_1=model.sub_to_wav(subwav,length=length)# Get subband magnitude spectrogramsub_spec,cos,sin=model.wav_to_mag_phase_sub_spec(input)reconstruct_2=model.mag_phase_sub_spec_to_wav(sub_spec,cos,sin,length=length)# Get subband complex spectrogramsub_complex_spec=model.wav_to_complex_sub_spec(input)reconstruct_3=model.complex_sub_spec_to_wav(sub_complex_spec,length=length)Reconstruction lossThe following table shows the reconstruction quality. We tried a set of audio to conduct subband decomposition and reconstruction.SubbandsL1lossPESQSiSDR21e-64.6461.841e-64.6458.985e-54.6458.2You can also test this program by running the following test script. It will give you some evaluation output.fromtorchsubbandimporttesttest()CitationIf you find our code useful for your research, please consider citing:@misc{liu2021cwspresunet,title={CWS-PResUNet: Music Source Separation with Channel-wise Subband Phase-aware ResUNet},author={Haohe Liu and Qiuqiang Kong and Jiafeng Liu},year={2021},eprint={2112.04685},archivePrefix={arXiv},primaryClass={cs.SD}}@inproceedings{Liu2020,author={Haohe Liu and Lei Xie and Jian Wu and Geng Yang},title={{Channel-Wise Subband Input for Better Voice and Accompaniment Separation on High Resolution Music}},year=2020,booktitle={Proc. Interspeech 2020},pages={1241--1245},doi={10.21437/Interspeech.2020-2555},url={http://dx.doi.org/10.21437/Interspeech.2020-2555}}