Saravanan666/pypi-org huggingface dataset:
Package: torch-data-bigquery
Torch Data BigqueryTorchDatasetinterface for Google BigQuery datasets.Table of ContentsTorch Data BigqueryInstallationExamplesLicenseInstallationpip install torch-data-bigqueryExamplesBigQueryStorageDatasetimporttorchfromtorch_data_bigqueryimportBigQueryStorageDatasetdataset=BigQueryStorageDataset(billing_project=PROJECT,selected_fields=["PassengerId","Survived","Pclass",],location=f"bq://your-gcp-project.kaggle_titanic.train",)dataloader=torch.utils.data.DataLoader(dataset)BigQueryDatasetimporttorchfromtorch_data_bigqueryimportBigQueryDatasetdataset=BigQueryDataset(billing_project=PROJECT,query=f"""SELECTSurvived                                AS survived,    # 1Pclass                                  AS pclass,      # 2DENSE_RANK() OVER(ORDER by Sex)         AS sex,         # 3COALESCE(Age, AVG(Age) OVER())          AS age,         # 4SibSp                                   AS siblings,    # 5Parch                                   AS parents,     # 6Fare                                    AS fare,        # 7DENSE_RANK() OVER(ORDER by Embarked)    AS embarked,    # 8FROM `your-gcp-project.kaggle_titanic.train`""",)dataloader=torch.utils.data.DataLoader(dataset)Licensetorch-data-bigqueryis distributed under the terms of theMITlicense.
Package: torch-dataset-mirror
PyTorch数据集国内镜像一、使用方法只需要在使用数据集之前导入torch_dataset_mirror模块即可，如下：importtorchimporttorch_dataset_mirrorimporttorchvision.datasets.mnistasmnisttrain_dataset=mnist.MNIST("./data",train=True,download=True)test_dataset=mnist.MNIST("./data",train=False,download=True)二、使用其他镜像要使用其他镜像，只需要修改PYTORCH_DATASET_MIRROR环境变量即可，如下：exportPYTORCH_DATASET_MIRROR=http://192.168.0.100:8080
Package: torch-dct
DCT (Discrete Cosine Transform) for pytorchThis library implements DCT in terms of the built-in FFT operations in pytorch so that
back propagation works through it, on both CPU and GPU. For more information on
DCT and the algorithms used here, seeWikipediaand the paper byJ. Makhoul. ThisStackExchange articlemight also be helpful.The following are currently implemented:1-D DCT-I and its inverse (which is a scaled DCT-I)1-D DCT-II and its inverse (which is a scaled DCT-III)2-D DCT-II and its inverse (which is a scaled DCT-III)3-D DCT-II and its inverse (which is a scaled DCT-III)Installpip install torch-dctRequirestorch>=0.4.1(lower versions are probably OK but I haven't tested them).You can run test by getting the source and runpytest. To run the test you also
needscipyinstalled.Usageimporttorchimporttorch_dctasdctx=torch.randn(200)X=dct.dct(x)# DCT-II done through the last dimensiony=dct.idct(X)# scaled DCT-III done through the last dimensionassert(torch.abs(x-y)).sum()<1e-10# x == y within numerical tolerancedct.dct1anddct.idct1are for DCT-I and its inverse. The usage is the same.Just replacedctandidctbydct_2d,dct_3d,idct_2d,idct_3d, etc
to get the multidimensional versions.
Package: torchde
Torch Density EstimationGeneric implementation of Deep Neural Networks for Density Estimation inPyTorchandPytorchLightning.InstallationIn order to network implementations installtorchdevia pip:pipinstalltorchdeIn case you wish to employ the training procedures and datamodule implementations (on top ofpytorch-lightning), you would need to install the additional tools as well:pipinstall"torchde[tools]"
Package: torchdecomp
PyTorchDecompA set of matrix and tensor decomposition models implemented as PyTorch classesInstallationBecause PyTorchDecomp is a PyPI package, please install it bypipcommand as follows:python-mvenvenv
pipinstalltorchdecompFor the other OS-specific or package-manager-specific installation, please check theREADME.mdof PyTorch.UsageimporttorchdecompastdimporttorchReferencesNon-negative Matrix Factorization (NMF)Kimura, K. A Study on Efficient Algorithms for Nonnegative Matrix/Tensor Factorization, Ph.D. Thesis, 2017Exponent term depending on Beta parameterNakano, M. et al., Convergence-guaranteed multiplicative algorithms for nonnegative matrix factorization with Beta-divergence. IEEE MLSP, 283-288, 2010Beta-divergence NMF and Backpropagationhttps://yoyololicon.github.io/posts/2021/02/torchnmf-algorithm/ContributingIf you have suggestions for howPyTorchDecompcould be improved, or want to report a bug, open an issue! We'd love all and any contributions.For more, check out theContributing Guide.LicensePyTorchDecomp has a MIT license, as found in theLICENSEfile.AuthorsKoki Tsuyuzaki
Package: torchdefenses
Adversarial-Defenses-PyTorch (Under Reconstruction)[Torchdefenses] is a PyTorch library that providesadversarial defensesto obtain robust model against adversarial attacks. It containsPyTorch Lightning-likeinterface and functions that make it easier for PyTorch users to implement adversarial defenses.How to use?importtorchdefensesastdrmodel=td.RobModel(model,n_classes=10,normalize={'mean':[0.4914,0.4822,0.4465],'std':[0.2023,0.1994,0.2010]})Easy trainingimporttorchdefenses.trainerastrtrainer=tr.Standard(rmodel)trainer.record_rob(train_loader,val_loader,eps=0.3,alpha=0.1,steps=5,std=0.1)trainer.fit(train_loader=train_loader,max_epoch=10,optimizer="SGD(lr=0.01)",scheduler="Step([100, 105], 0.1)",scheduler_type="Epoch",record_type="Epoch",save_type="Epoch",save_path="./_temp/"+"sample",save_overwrite=True)Supporting Multi-GPUimportosos.environ["CUDA_VISIBLE_DEVICES"]="1,2"# Possible GPUSmodel=td.utils.load_model(model_name="ResNet18",n_classes=10).cuda()# Load modelmodel=torch.nn.DataParallel(model)# Parallelizermodel=td.RobModel(model,n_classes=10,normalize={'mean':[0.4914,0.4822,0.4465],'std':[0.2023,0.1994,0.2010]})# Wrap it with RobModeltrainer=...# Define trainertrainer.fit(..)# Training startRecording, Saving and Visualizingtrainer.save_all("./_temp/"+"sample",overwrite=True)trainer.rm.plot(title="A",xlabel="Epoch",ylabel="Accuracy",figsize=(6,4),x_key='Epoch',y_keys=['Clean(Tr)','FGSM(Tr)','PGD(Tr)','GN(Tr)','Clean(Val)','FGSM(Val)','PGD(Val)','GN(Val)'],ylim=(-10,110),colors=['k','#D81B60','#1E88E5','#004D40']*2,labels=['Clean','FGSM','PGD','GN','','','',''],linestyles=['-','-','-','-','--','--','--','--'],)Easy evaluationrmodel.eval_accuracy(test_loader)rmodel.eval_rob_accuracy_pgd(test_loader,eps=1,alpha=0.1,steps=10,random_start=True,restart_num=1)Useful functionsfromtorchdefenses.utilsimportfix_randomness,fix_gpufix_randomness(0)fix_gpu(0)How to customize?
Package: torchdemon
torchdemonDocumentation:https://jacknurminen.github.io/torchdemonSource Code:https://github.com/jacknurminen/torchdemonPyPI:https://pypi.org/project/torchdemon/Inference Server for RLInference Server. Serve model on GPU to workers. Workers communicate with the inference server over
multiprocessing Pipe connections.Dynamic Batching. Accumulate batches from workers for forward passes. Set maximum batch size or maximum wait time
for releasing batch for inference.InstallationpipinstalltorchdemonUsageDefine a modelimporttorchclassModel(torch.nn.Module):def__init__(self,input_size:int,output_size:int):super(Model,self).__init__()self.linear=torch.nn.Linear(input_size,output_size)defforward(self,x:torch.Tensor)->torch.Tensor:returnself.linear(x)model=Model(8,4)Create an inference server for the modelimporttorchdemoninference_server=torchdemon.InferenceServer(model,batch_size=8,max_wait_ns=1000000,device=torch.device("cuda:0"))Create an inference client per agent and run in parallel processesimportmultiprocessingprocesses=[]for_inrange(multiprocessing.cpu_count()):inference_client=inference_server.create_client()agent=Agent(inference_client)process=multiprocessing.Process(target=play,args=(agent,))process.start()processes.append(process)Run serverinference_server.run()forprocessinprocesses:process.join()DevelopmentClone this repositoryRequirements:PoetryPython 3.7+Create a virtual environment and install the dependenciespoetryinstallActivate the virtual environmentpoetryshellTestingpytestDocumentationThe documentation is automatically generated from the content of thedocs directoryand from the docstrings
of the public signatures of the source code. The documentation is updated and published as aGithub project pageautomatically as part each release.ReleasingTrigger theDraft release workflow(pressRun workflow). This will update the changelog & version and create a GitHub release which is inDraftstate.Find the draft release from theGitHub releasesand publish it. When
a release is published, it'll triggerreleaseworkflow which creates PyPI
release and deploys updated documentation.Pre-commitPre-commit hooks run all the auto-formatters (e.g.black,isort), linters (e.g.mypy,flake8), and other quality
checks to make sure the changeset is in good shape before a commit/push happens.You can install the hooks with (runs for each commit):pre-commitinstallOr if you want them to run only for each push:pre-commitinstall-tpre-pushOr if you want e.g. want to run all checks manually for all files:pre-commitrun--all-filesThis project was generated using thewolt-python-package-cookiecuttertemplate.
Package: torch-discounted-cumsum
This package implements an efficient parallel algorithm for the computation of discounted cumulative sums
with differentiable bindings to PyTorch. Thecumsumoperation is frequently seen in data science
domains concerned with time series, including Reinforcement Learning (RL).The traditional sequential algorithm performs the computation of the output elements in a loop. For an input of sizeN, it requiresO(N)operations and takesO(N)time steps to complete.The proposed parallel algorithm requires a total ofO(N log N)operations, but takes onlyO(log N)time, which is a
considerable trade-off in many applications involving large inputs.Features of the parallel algorithm:Speed logarithmic in the input sizeBetter numerical precision than sequential algorithmsFeatures of the package:CPU: sequential algorithm in C++GPU: parallel algorithm in CUDAGradients computation for input and gammaBatch support for input and gammaBoth left and right directions of summation supportedPyTorch bindingsFind more details and the most up-to-date information on the project webpage:https://www.github.com/toshas/torch-discounted-cumsum
Package: torch-distmap
torch-distmapEuclidean distance transform in PyTorch.This is an implementation of the algorithm from the paper"Distance Transforms of Sampled Functions"Pedro F. Felzenszwalb & Daniel P. HuttenlocherTheory of Computing(2012)Although it is in PyTorch, our implementation performs loops across
voxels and hence quite slow. Moreover, it takes masks as an input
and therefore does not allow backpropagation.Installationpipinstallgit+https://github.com/balbasty/torch-distmapAPIeuclidean_distance_transform(x,ndim=None,vx=1)"""Compute the Euclidean distance transform of a binary imageParameters----------x : (..., *spatial) tensorInput tensor. Zeros will stay zero, and the distance willbe propagated into nonzero voxels.ndim : int, default=`x.dim()`Number of spatial dimensionsvx : [sequence of] float, default=1Voxel sizeReturns-------d : (..., *spatial) tensorDistance map"""euclidean_signed_transform(x,ndim=None,vx=1)"""Compute the signed Euclidean distance transform of a binary imageParameters----------x : (..., *spatial) tensorInput tensor.A negative distance will propagate into zero voxels anda positive distance will propagate into nonzero voxels.ndim : int, default=`x.dim()`Number of spatial dimensionsvx : [sequence of] float, default=1Voxel sizeReturns-------d : (..., *spatial) tensorSigned distance map"""l1_distance_transform(x,ndim=None,vx=1)"""Compute the L1 distance transform of a binary imageParameters----------x : (..., *spatial) tensorInput tensor. Zeros will stay zero, and the distance willbe propagated into nonzero voxels.ndim : int, default=`x.dim()`Number of spatial dimensionsvx : [sequence of] float, default=1Voxel sizeReturns-------d : (..., *spatial) tensorDistance map"""l1_signed_transform(x,ndim=None,vx=1)"""Compute the signed L1 distance transform of a binary imageParameters----------x : (..., *spatial) tensorInput tensor.A negative distance will propagate into zero voxels anda positive distance will propagate into nonzero voxels.ndim : int, default=`x.dim()`Number of spatial dimensionsvx : [sequence of] float, default=1Voxel sizeReturns-------d : (..., *spatial) tensorSigned distance map"""Related packagesedt:
a very fast CPU implementation of the same algorithm, written in C.scipy.ndimage.distance_transform_edt:
reference implementation, written in C, based on the paper"A linear time algorithm for computing exact euclidean distance
transforms of binary images in arbitrary dimensions"C. R. Maurer,  Jr., R. Qi, V. RaghavanIEEE Trans. PAMI 25, 265-270, (2003)
Package: torchdrift
TorchDrift: drift detection for PyTorchTorchDrift is a data and concept drift library for PyTorch. It lets you monitor your PyTorch models to see if they operate within spec.We focus on practical application
and strive to seamlessly integrate with PyTorch.InstallationTo install the latest release version usepip install torchdriftTo get the latest and greatest install from git withpip install git+https://github.com/torchdrift/torchdrift/DocumentationOur documentation is atTorchDrift.org.ExamplesCheck outour worked examplewith an ImageNet-type classifier.If you have a model (without head) as the feature extractor and a training dataloader you can fit the reference distribution asdrift_detector=torchdrift.detectors.KernelMMDDriftDetector()torchdrift.utils.fit(train_dataloader,feature_extractor,drift_detector)and then check drifts withfeatures=feature_extractor(inputs)score=drift_detector(features)p_val=drift_detector.compute_p_value(features)ifp_val<0.01:raiseRuntimeError("Drifted Inputs")Also check out ourdeployment examplefor integration of TorchDrift into
inference with a model.AuthorsTorchDrift is a joint project of Orobix Srl, Bergamo, Italy and
MathInf GmbH, Garching b. München, Germany.The TorchDrift Team: Thomas Viehmann, Luca Antiga, Daniele Cortinovis, Lisa LozzaAcknowledgementsWe were inspired byFailing Loudly: An Empirical Study of Methods for Detecting Dataset
Shift, NeurIPS 2019https://github.com/steverab/failing-loudlyHendrycks & Dietterich:
Benchmarking Neural Network Robustness to Common Corruptions and Perturbations
ICLR 2019https://github.com/hendrycks/robustness/Van Looveren et al.: Alibi Detecthttps://github.com/SeldonIO/alibi-detect/
Package: torchdynamo
TorchDynamo is a Python-level JIT compiler designed to make unmodified
PyTorch programs faster. TorchDynamo hooks into the frame evaluation API
in CPython (PEP 523) to dynamically modify Python bytecode right before
it is executed. It rewrites Python bytecode in order to extract sequences
of PyTorch operations into an FX Graph which is then just-in-time
compiled with an ensemble of different backends and autotuning.
Package: torch-edit-distance
PyTorch edit-distance functionsUseful functions for E2E Speech Recognition training with PyTorch and CUDA.Here is a simple use case with Reinforcement Learning and RNN-T loss:blank=torch.tensor([0],dtype=torch.int).cuda()space=torch.tensor([1],dtype=torch.int).cuda()xs=model.greedy_decode(xs,sampled=True)torch_edit_distance.remove_blank(xs,xn,blank)rewards=1-torch_edit_distance.compute_wer(xs,ys,xn,yn,blank,space)nll=rnnt_loss(zs,ys,xn,yn)loss=nll*rewardslevenshtein_distanceLevenshtein edit-distance with detailed statistics for ins/del/sub operations.collapse_repeatedMerge repeated tokens, useful for CTC-based model.remove_blankRemove unnecessary blank tokens, useful for CTC, RNN-T, RNA models.strip_separatorRemove leading, trailing and repeated middle separators.RequirementsC++11 compiler (tested with GCC 9.4.0).Python: 3.5, 3.6, 3.7, 3.8, 3.9 (tested with version 3.8).PyTorch>= 1.5.0 (tested with version 1.13.1+cu116).CUDA Toolkit(tested with version 11.2).InstallThere is no compiled version of the package. The following setup instructions compile the package from the source code locally.From Pypipipinstalltorch_edit_distanceFrom GitHubgitclonehttps://github.com/1ytic/pytorch-edit-distancecdpytorch-edit-distance
pythonsetup.pyinstallTestpython-mtorch_edit_distance.test
Package: torchei
TorchEI⚡Intro●Usage●Doc●Cite●Contribution●License中文Introduction👋TorchEI, pronounced*/ˈtôrCHər/*(like torture), short for Pytorch Error Injection, is a high-speed toolbox for DNN Reliability's Research and Development. TorchEI enables you quickly and simply inject errors into DNN, collects information you needed, and harden your DNN.FeaturesFull typing system supportedImplemented methods from papersHighly customizableQuick ExampleHere we gonna show you a quick example, or you can tryinteractive demoandonline editor.InstallingInstall public distribution usingpip3 install torcheiordownloadit.ExampleInit fault modelimporttorchfromtorchvisionimportmodelsimporttorcheimodel=models.resnet18(pretrained=True)data=torch.load('data/ilsvrc_valid8.pt')fault_model=torchei.fault_model(model,data)Calc reliability using emat methodfault_model.emat_attack(10,1e-3)Calc reliability usingSERNfault_model.sern_calc(output_class=1000)Harden DNN by ODRfault_model.outlierDR_protection()fault_model.emat_attack(10,1e-3)ContributionIf you found🧐 any bugs or have🖐️ any suggestions, please tell us.This repo is open to everyone wants to maintain together.You can helps us with follow things:PR your implemented methods in your or others' papersComplete our projectTranslate our docs to your languageOtherWe want to build TorchEI to best toolbox in DNN Reliability for bit flip, adversarial attack, and others.:e-mail:forcessless@foxmail.comCitationOur paper is under delivering.LicenseMITLicense.
Copyright:copyright:2022/5/23-present, Hao Zheng.
Package: torchelastic
TorchElasticTorchElastic allows you to launch distributed PyTorch jobs in a
fault-tolerant and elastic manner.
For the latest documentation, please refer to ourwebsite.Requirementstorchelastic requirespython3 (3.8+)torchetcdInstallationpipinstalltorchelasticQuickstartFault-toleranton4nodes,8trainers/node, total4 * 8 = 32trainers.
Run the following on all nodes.python-mtorchelastic.distributed.launch--nnodes=4--nproc_per_node=8--rdzv_id=JOB_ID--rdzv_backend=etcd--rdzv_endpoint=ETCD_HOST:ETCD_PORTYOUR_TRAINING_SCRIPT.py(--arg1...trainscriptargs...)Elastic on1 ~ 4nodes,8trainers/node, total8 ~ 32trainers. Job
starts as soon as1node is healthy, you may add up to4nodes.python-mtorchelastic.distributed.launch--nnodes=1:4--nproc_per_node=8--rdzv_id=JOB_ID--rdzv_backend=etcd--rdzv_endpoint=ETCD_HOST:ETCD_PORTYOUR_TRAINING_SCRIPT.py(--arg1...trainscriptargs...)ContributingWe welcome PRs. See theCONTRIBUTINGfile.Licensetorchelastic is BSD licensed, as found in theLICENSEfile.
Package: torch-emb2vec
torch-emb2vecConvert W2V embeddings of a sequence (2D) to one vector (1D)UsageCreate toy datanum_emb,emb_dim=1000,256emb=torch.nn.Embedding(num_emb,emb_dim)batch_sz,seq_len=5,128inputs=torch.randint(num_emb,(batch_sz,seq_len))z=emb(inputs)Averaging the embedding vectors over the sequence is the most common
technique to convert the 2D representation to a 1D representation.avg=AverageToVec()vec=avg(z)vec.shape# torch.Size([5, 128])Concatenating the W2V values, i.e., flattening, might seem like an
attractive option but will result in huge vectors that is usually not
practiable for downstream tasks.con=ConcatToVec()vec=con(z)vec.shape# torch.Size([5, 32768])Another way are random projections. ConvToVec applies a 1D-Convolution
over the sequence wheras the embedding elements are treated as Conv1D
input channels.conv1=ConvToVec(seq_len=z.shape[1],emb_dim=z.shape[2],num_output=768)vec=conv1(z)vec.shape# torch.Size([5, 768])It is also possible to apply the heaviside function to generate binary
1D vector embeddings.conv1=ConvToVec(seq_len=z.shape[1],emb_dim=z.shape[2],num_output=2048,hashed=True)vec=conv1(z)vec.shape,vec.min(),vec.max()# torch.Size([5, 2048]), 0.0, 1.0AppendixInstallationThetorch-emb2vecgit
repois available asPyPi
packagepipinstalltorch-emb2vecpipinstallgit+ssh://git@github.com/ulf1/torch-emb2vec.gitInstall a virtual environmentpython3.6-mvenv.venvsource.venv/bin/activatepipinstall--upgradepippipinstall-rrequirements.txt--no-cache-dirpipinstall-rrequirements-dev.txt--no-cache-dir(If your git repo is stored in a folder with whitespaces, then don’t use
the subfolder.venv. Use an absolute path without whitespaces.)Python commandsCheck syntax:flake8--ignore=F401--exclude=$(grep-v'^#'.gitignore | xargs | sed-e's//,/g')Run Unit Tests:PYTHONPATH=. pytestPublishpandocREADME.md--frommarkdown--torst-s-oREADME.rstpythonsetup.pysdisttwineupload-rpypidist/*Clean upfind.-typef-name"*.pyc"|xargsrmfind.-typed-name"__pycache__"|xargsrm-rrm-r.pytest_cacherm-r.venvSupportPleaseopen an
issuefor support.ContributingPlease contribute usingGithub
Flow. Create a branch,
add commits, andopen a pull
request.
Package: torch-embed-sim
PyTorch Embedding SimilarityInstallpipinstalltorch-embed-simUsagefromtorch_embed_simimportEmbeddingSimclassNet(nn.Module):def__init__(self):super(Net,self).__init__()self.embed=torch.nn.Embedding(num_embeddings=10,embedding_dim=20)self.embed_sim=EmbeddingSim(num_embeddings=10)defforward(self,x):returnself.embed_sim(self.embed(x),self.embed.weight)
Package: torchember
Torch EmberTracking and visualize after the burning pytorchThis framework tracks the pytorch model:Onnn.ModulelevelDown to the metrics/ features of all tensors, includesinputs/outputs of each moduleweight/grad tensorsByminimalextra codingOther lovely featuresCustomizable metrics, with easy decorator syntaxSplit the tracking log in the way you like, justmark(k=v,k1=v2...)You can easily switch on/off the tracking:Even cost of computation is tiny, torchember don't have to calculate metric for every iterationHence, you can track eg. only the last steps, only each 200 steps .etcInstallationpip install torchemberFast Tutorial30 secondstutorialFulldocumentationsStep1, Track your modelPlace you torch ember tracker on your modelfromtorchember.coreimporttorchEmberte=torchEmber(model)The above can track input and output of every module,The following can track status of every moduleforiinrange(1000):...loss.backward()optimizer.step()te.log_model()Train your model as usualStep2, Check the analysis on the WebUIRun the service from terminal$torchemberThe default port will be 8080Or assign a port$torchember--port=4200Visit your analysis athttp://[host]:[port]
Package: torch-encoding
PyTorch-Encodingcreated byHang ZhangDocumentationPlease visit theDocsfor detail instructions of installation and usage.Please visit thelinkto image classification models.Please visit thelinkto semantic segmentation models.CitationsResNeSt: Split-Attention Networks[arXiv]Hang Zhang, Chongruo Wu, Zhongyue Zhang, Yi Zhu, Zhi Zhang, Haibin Lin, Yue Sun, Tong He, Jonas Muller, R. Manmatha, Mu Li and Alex Smola@article{zhang2020resnest,
title={ResNeSt: Split-Attention Networks},
author={Zhang, Hang and Wu, Chongruo and Zhang, Zhongyue and Zhu, Yi and Zhang, Zhi and Lin, Haibin and Sun, Yue and He, Tong and Muller, Jonas and Manmatha, R. and Li, Mu and Smola, Alexander},
journal={arXiv preprint},
year={2020}
}Context Encoding for Semantic Segmentation[arXiv]Hang Zhang,Kristin Dana,Jianping Shi,Zhongyue Zhang,Xiaogang Wang,Ambrish Tyagi,Amit Agrawal@InProceedings{Zhang_2018_CVPR,
author = {Zhang, Hang and Dana, Kristin and Shi, Jianping and Zhang, Zhongyue and Wang, Xiaogang and Tyagi, Ambrish and Agrawal, Amit},
title = {Context Encoding for Semantic Segmentation},
booktitle = {The IEEE Conference on Computer Vision and Pattern Recognition (CVPR)},
month = {June},
year = {2018}
}Deep TEN: Texture Encoding Network[arXiv]Hang Zhang,Jia Xue,Kristin Dana@InProceedings{Zhang_2017_CVPR,
author = {Zhang, Hang and Xue, Jia and Dana, Kristin},
title = {Deep TEN: Texture Encoding Network},
booktitle = {The IEEE Conference on Computer Vision and Pattern Recognition (CVPR)},
month = {July},
year = {2017}
}
Package: torch-es
torch-esDouble Seasonal Exponential Smoothing usingPyTorchwith batched data and multiple series training support.📋 RoadmapThere are lots of tools built on top of the code in this repository, so the plan is to add them here eventually.Here's what's published:3d Holt-Winters implementationAdditive and Multiplicative seasonalitiesBlender module to merge predictions from multiple series.Training loop for normal and bptt training.Uncertainty estimation via sampling.Additional lossesRNN training on top of HW.📚 Dependenciestorchnumpy