sha256 stringlengths 64 64 | language stringclasses 27
values | size int32 1 491k | lines int32 1 21.8k | content stringlengths 1 200k |
|---|---|---|---|---|
5e2a1c6b796230eaf9c5d675c4c3587512f4f67c0fd55decef372d4da5c2e487 | C/C++ | 31,803 | 686 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2008-2015 Imperial College London
* Copyright 2008-2013 Daniel Rueckert, Julia Schnabel
* Copyright 2013-2015 Andreas Schuh
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the ... |
5e07b6e2ea4a99f0b2c2fffc87fced267e39a7ee6a3ed8a314f262fca7d046fe | C/C++ | 32,316 | 762 | /*
* Copyright 2022 Google LLC.
* 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... |
db12a9df6e3e39a0ff66941f2a7cf117bddc3e4632c00dca68f032e13fff21fb | C/C++ | 33,433 | 941 | #ifndef UTIL_H
#define UTIL_H
#include <boost/multi_array.hpp>
#include <boost/unordered_map.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/iostreams/filtering_streambuf.hpp>
#include <boost/iostreams/copy.hpp>
#include <boost/iostreams/filter/gzip.hpp>
#include <htslib/sam.h>
#include <sstream>
#include <... |
733245ac3cc02e4bca705e289cce08cd502a1253d1faa020f3dca2bd90e7678f | C/C++ | 33,713 | 899 | #ifndef CNV_H
#define CNV_H
#include <limits>
#include <algorithm>
#include <fstream>
#include <boost/filesystem.hpp>
#include <boost/multi_array.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/unordered_map.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/tokenizer.hpp>
#include <... |
8ce22eab144bfc16ea1af5ac51d67436522c00d356d00d38905b1e4a1db0b29e | C/C++ | 33,862 | 752 | #ifndef JUNCTION_H
#define JUNCTION_H
#include <boost/filesystem.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/iostreams/filtering_streambuf.hpp>
#include <boost/iostreams/filtering_stream.hpp>
#include <boost/iostreams/copy.hpp>
#include <boost/iostreams/filter/gzip.... |
83e5075ac460f977d4d3a6eb4f74fbb6ecf619002666fd3a6c8d5f2100ffd8c3 | C/C++ | 34,216 | 897 | #ifndef ASMODE_H
#define ASMODE_H
#include <boost/unordered_map.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/date_time/gregorian/gregorian.hpp>
#include <boost/program_options/cmdline.hpp>
#include <boost/program_options/options_description.hpp>
#include <boost/program_options/parsers.hpp>... |
f4212da063466a5738137585dc8870fdbb759332a061bc6fec3317424dbd5b3e | C/C++ | 34,672 | 832 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
cb91635c7f6be44669f9df1a7d222c17b6f101325e2f6f48cf7904364421a03c | C/C++ | 34,780 | 1,014 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2008-2015 Imperial College London
* Copyright 2008-2013 Daniel Rueckert, Julia Schnabel
* Copyright 2013-2015 Andreas Schuh
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the ... |
655c145e476b2c97d56958961d8f0e07bfee4655ca8f3e39554402fc4b2aad13 | C/C++ | 35,043 | 727 | /** \file nifti2_io.h
\brief Data structures for using nifti2_io API.
- Written by Bob Cox, SSCC NIMH
- Revisions by Rick Reynolds, SSCC NIMH
*/
#ifndef _MIRTK_NIFTI2_IO_HEADER_
#define _MIRTK_NIFTI2_IO_HEADER_
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include... |
321439e050dbf4f5d1711b32c4b860da38c4d0a9e1905edb59f7990be66f7deb | C/C++ | 35,246 | 815 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
e030cffa2f2a5490e2d084178c6d07e42ebe02a9fbf88642ee580309e9f34888 | C/C++ | 35,933 | 816 | #ifndef MODVCF_H
#define MODVCF_H
#include <htslib/sam.h>
#include <htslib/vcf.h>
#include "bolog.h"
#include "ploidy.h"
#include "methyl.h"
namespace torali
{
void _remove_info_tag(bcf_hdr_t const* hdr, bcf1_t* rec, std::string const& tag) {
bcf_update_info(hdr, rec, tag.c_str(), NULL, 0, BCF_HT_INT); // Type... |
c564e12583928af241b517100fe5fd3aa06569e4e468e62c52c44ef1593e3598 | C/C++ | 36,210 | 933 | #ifndef CORAL_H
#define CORAL_H
#include <limits>
#include <iomanip>
#include <boost/icl/split_interval_map.hpp>
#include <boost/dynamic_bitset.hpp>
#include <boost/unordered_map.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/date_time/gregorian/gregorian.hpp>
#include <boost/math/special_f... |
2593bee36626fe5e2b3d315412dd5f2458aba01fa5d818619ae2f662fb3659b3 | C/C++ | 36,495 | 969 | #ifndef ASSEMBLE_H
#define ASSEMBLE_H
#include <iostream>
#include "edlib.h"
#include "msa.h"
#include "split.h"
#include "gotoh.h"
#include "needle.h"
namespace torali
{
struct SeqSlice {
int32_t svid;
int32_t sstart;
int32_t inslen;
int32_t qual; // Only required for junction count map
SeqS... |
61d834c3b6aa44c3b93f7279c93045490afb1b4b4e4fef67608bc2e1b79e54fa | C/C++ | 36,878 | 1,461 | /*
* Copyright 1993-2010 NVIDIA Corporation. All rights reserved.
*
* Please refer to the NVIDIA end user license agreement (EULA) associated
* with this source code for terms and conditions that govern your use of
* this software. Any use, reproduction, disclosure, or distribution of
* this software and related... |
4a9578ac546293a1e791f364fb3a3f5d48c4a2702d1b0ab8238728af3f7095d3 | C/C++ | 36,934 | 823 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2008-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
9b809b0034a5291ac12e7bac2d27ff328c61f69c04a29c5eabe5ffc0ef9c4889 | C/C++ | 37,726 | 1,338 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2017 Imperial College London
* Copyright 2013-2017 Andreas Schuh
*
* 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
*
... |
58caac2073805004b3cd87674268be9a5eec195625d1101a4158a53873e0238a | C/C++ | 38,579 | 891 | /***************************************************************************
*cr
*cr (C) Copyright 1995-2006 The Board of Trustees of the
*cr University of Illinois
*cr All Rights Reserved
*cr
***************************************************************... |
7b5266fe4b7d8c048ba9a706c4f4f14afe3e7f61d47a7998ea8bdc55bc15da84 | C/C++ | 39,328 | 1,873 | #include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <mex.h>
#include <math.h>
#include "matrix.h"
#define delta 1e-10
/*
Revision History
First Version available on October 10, 2009
A runnable version on October 15, 2009
Major revision on October 29, 2009
(Some functions appearing in a p... |
b89795a964b5b20ae9998668aec0eaea8ea5c50c579ad6927266337c4fff493d | C/C++ | 39,532 | 956 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
35f5e8cf40c5333497dec23ab572db1770719708ef9afd4c9d62507cfef68ee4 | C/C++ | 40,328 | 1,504 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2017 Imperial College London
* Copyright 2013-2017 Andreas Schuh
*
* 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
*
... |
83fb1f5d7b3c6c8beb3393c41b39bd3d10fa21ee0d9f7d8b960289b81dfbec95 | C/C++ | 40,453 | 1,181 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2017 Imperial College London
* Copyright 2013-2018 Andreas Schuh
*
* 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
*
... |
e459498ffc70d91da98ecebe0a26e33f4fca9de273c315f851182edfb90e8a61 | C/C++ | 40,991 | 1,400 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
aa6648c12ca3a1a075b7eb84ae3c9655b4f79fffbe3ce8acb4d72c12dff4c90b | C/C++ | 41,761 | 1,253 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
fd8c00b2616d2aa9ddd25960e45d12412d58c2773cd8948064cd64090a51511b | C/C++ | 43,241 | 1,155 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
7d5b6da4512304db2d6a48729934e8ae31e94ec137f295426ae2f9611c2a8ba8 | C/C++ | 43,474 | 1,173 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2017 Imperial College London
* Copyright 2013-2017 Andreas Schuh
*
* 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
*
... |
b11d4dd6c41ccdea546a67f0cb2bd3762c94626736eb90edc591090843c64694 | C/C++ | 43,609 | 970 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
7f55edac90469b42c4ba3e3efc9533cb2e4930df40822765543b41124f468682 | C/C++ | 44,330 | 1,206 | /*
* Copyright 2022 Google LLC.
* 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... |
e20efaada53aa9d9ec12a7093f70c43daee998e8ec5bb8e5eb81ddb4847a2843 | C/C++ | 45,034 | 1,070 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2008-2015 Imperial College London
* Copyright 2008-2013 Daniel Rueckert, Julia Schnabel
* Copyright 2013-2015 Andreas Schuh
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the ... |
d87ea4e978d19acab9847c8149e0383bd317745d54759401b09af55fe0d22dc8 | C/C++ | 45,356 | 241 | #ifndef SVANNO_H
#define SVANNO_H
#include <boost/unordered_map.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/date_time/gregorian/gregorian.hpp>
#include <boost/program_options/cmdline.hpp>
#include <boost/program_options/options_description.hpp>
#include <boost/program_options/parsers.hpp>... |
821257eb3ffd4cc67d7a1ae0259c006c293b3b20335d6cfc28a5121e5eabf07f | C/C++ | 49,219 | 1,532 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2008-2015 Imperial College London
* Copyright 2008-2015 Daniel Rueckert, Julia Schnabel
* Copyright 2013-2015 Andreas Schuh
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the ... |
8d3e125fe44112456b14dbd4f7d8e17ded7c5363bc03c78b65aebe75ac7ee6dc | C/C++ | 51,668 | 1,075 | /*
* Copyright 2022 Google LLC.
* 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... |
af578254d11944338c1b47122014584e4df198afa20c86ed6352478a77ec266a | C/C++ | 51,673 | 1,176 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2008-2015 Imperial College London
* Copyright 2008-2013 Daniel Rueckert, Julia Schnabel
* Copyright 2013-2015 Andreas Schuh
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the ... |
af35725a08d0f43b0c8da445355dac2045b2ebefabce25dd98bd90d3df9edde4 | C/C++ | 53,800 | 1,359 | /*
* Copyright 2022 Google LLC.
* 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... |
108dacdde2dc65478ad14b0a6a4eaf313c5287527603e24d24cda2f2d396df48 | C/C++ | 54,739 | 1,407 | #ifndef FILTER_H
#define FILTER_H
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <boost/unordered_map.hpp>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/connected_components.hpp>
#include <boost/program_opti... |
18da971c71bf88739db8731a0034ca38ee23b1a24fb79e832de740d0c001403a | C/C++ | 55,394 | 1,477 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
3b18a5d0218e6d554f1da5345038eff7b65805f783992c4818f3e5e631ab2dc6 | C/C++ | 58,885 | 1,569 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
532d0e1f1aa081180a6d30bc07ed113709d4d1e6493a2a43f26d04f4e184907c | C/C++ | 59,425 | 1,808 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2008-2017 Imperial College London
* Copyright 2008-2013 Daniel Rueckert, Julia Schnabel
* Copyright 2013-2017 Andreas Schuh
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the ... |
b5642880e52258ecb4c2d308c760cfae771978e672edefcbef12b3b5405ac586 | C/C++ | 62,036 | 1,998 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
13ada17cc0bf23dcfc6b88a4875a1ecc8da554d9bddaca4dc4e008d2004aa201 | C/C++ | 63,314 | 1,472 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
7fd0cc350cd403aca6eaa5cfb38fb56f7460343e5b57a1ad83e99fc2a12fde23 | C/C++ | 67,146 | 1,643 | /*
* Copyright 2022 Google LLC.
* 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... |
41acfb966a3033d9a19c62a099969ec2b1a285405827788a7e022efaf0e565ec | C/C++ | 69,465 | 1,501 | /** \file nifti1.h
\brief Official definition of the nifti1 header. Written by Bob Cox, SSCC, NIMH.
HISTORY:
29 Nov 2007 [rickr]
- added DT_RGBA32 and NIFTI_TYPE_RGBA32
- added NIFTI_INTENT codes:
TIME_SERIES, NODE_INDEX, RGB_VECTOR, RGBA_VECTOR, SHAPE
*/
#ifnd... |
469ff41e3555ee9236b327a6ad8998ea8268f24b1f1f39e4eaeb040256573871 | C/C++ | 70,864 | 2,149 | /*
* Copyright 2022 Google LLC.
* 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... |
abec68765be8af46ee3d7e57b611253db1eacfec8236d3eb12d4516d394f4a13 | C/C++ | 73,087 | 1,839 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2008-2017 Imperial College London
* Copyright 2008-2013 Daniel Rueckert, Julia Schnabel
* Copyright 2013-2017 Andreas Schuh
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the ... |
94c26450c0d15befdbeec16c8ae74e15e0ee8982f70b558b67bf5479feff089c | C/C++ | 87,241 | 2,166 | #ifndef MERGE_H
#define MERGE_H
#define BOOST_UUID_RANDOM_PROVIDER_FORCE_POSIX
#include <iostream>
#include <fstream>
#include <boost/unordered_map.hpp>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/connected_components.hpp>
#include <boost/program_options/cmdline.hpp>
#include <boost/program_option... |
ff8509361e531dab540b182885233f50cd93391665003ee53bceb4b76aa1fe3d | C/C++ | 87,574 | 2,105 | /*
* Copyright 2022 Google LLC.
* 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... |
fa10599bd89c323f4740d834d0cbaa21d22361b3eadbf609b5a870ac3532ff6f | C/C++ | 98,195 | 2,115 | // FastDelegate.h
// Efficient delegates in C++ that generate only two lines of asm code!
// Documentation is found at http://www.codeproject.com/cpp/FastDelegate.asp
//
// - Don Clugston, Mar 2004.
// Major contributions were made by Jody Hagins.
// History:
// 24-Apr-04 1.0 * Submitted to CodeProject.
... |
316dad0fcf430ea7ccd7b4cc7ff8575b8ec6946e8bd9fa43e9fb2df217079782 | C/C++ | 117,593 | 3,851 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
5632e97425f4fda5614af59a7214c7b7e8f6be2b3babc2b6ca71e995a70f2469 | C/C++ | 129,548 | 3,247 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
1679f1e23c627be843b3aee61985a856285cac98a378a2e9e7d00c6db2f3b708 | C/C++ | 200,000 | 3,794 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
42f552c6ff81983ba7f33c2adf17f7e3d6ada272168c33a489d7de9fa5725fdc | C/C++ | 200,000 | 2,908 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
61da84d8508b925f7a5a41390328ba6f9845fdf364e7a25c4317be3372715b50 | C/C++ | 200,000 | 3,272 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
6b1a64269bd32e516d62445ed2f7ecee431b8d1e6f3f6d3af31d8076994b9065 | C/C++ | 200,000 | 4,909 | // Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions ... |
8e26be456e89c672bb25935806b6344fa5f939383881d5a456f8b28b50260edf | C/C++ | 200,000 | 2,768 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
b08cd8e0b189bb18f9fdb48b0c8794a14ed5a7cfd5280afb0a3ae8f55c502f9a | C/C++ | 200,000 | 4,539 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
b4c9fa950aaa4d4fa3859ae949fb437e7764786f856ebc35feea09508f1fab5a | C/C++ | 200,000 | 3,531 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
f129d83185d6b86afba6b3fd333cd4a3217674763729b3245a145467ae64f68b | C/C++ | 200,000 | 3,066 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
f512bd8c15aefba5372c6f8a7a1403352bff5857c05cbc88e3ffa0173230309a | C/C++ | 200,000 | 4,121 | /*
* Medical Image Registration ToolKit (MIRTK)
*
* Copyright 2013-2015 Imperial College London
* Copyright 2013-2015 Andreas Schuh
*
* 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
*
... |
6d297cd63af12615e8e5d1304c2c25eb9fc25f15e42430cd017d8de9b6302ec7 | CUDA | 715 | 27 | #include <vector>
#include "caffe/layers/silence_layer.hpp"
#include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
void SilenceLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
// Do nothing.
}
template <typename Dtype>
void Silenc... |
6ecdcffccc7b3881114c77ff13a2e1afef4440e93c07c62f6ca96464d910d17f | CUDA | 735 | 24 | #include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
__global__ void SGDUpdate(int N, Dtype* g, Dtype* h,
Dtype momentum, Dtype local_rate) {
CUDA_KERNEL_LOOP(i, N) {
g[i] = h[i] = momentum*h[i] + local_rate*g[i];
}
}
template <typename Dtype>
void sgd_update_gpu(int N, Dt... |
1f01576d58395d780450cfde2d66cc9567eca52d9d9431ae329ec9f2b3d917c2 | CUDA | 801 | 26 | #include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
__global__ void AdaGradUpdate(int N, Dtype* g, Dtype* h, Dtype delta,
Dtype local_rate) {
CUDA_KERNEL_LOOP(i, N) {
float gi = g[i];
float hi = h[i] = h[i] + gi*gi;
g[i] = local_rate * gi / (sqrt(hi) + delta);
}
}... |
bb52e1aebb189dd26e2b8bdb5df61c06b19a398d4df26af32667cdc0a0e9dc31 | CUDA | 845 | 27 | #include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
__global__ void NesterovUpdate(int N, Dtype* g, Dtype* h,
Dtype momentum, Dtype local_rate) {
CUDA_KERNEL_LOOP(i, N) {
float hi = h[i];
float hi_new = h[i] = momentum * hi + local_rate * g[i];
g[i] = (1+momentum) *... |
3360bb66be324c92739c911620baa06513996c0fca74599c438fab3bf8e14036 | CUDA | 854 | 31 | #include <vector>
#include "caffe/layers/threshold_layer.hpp"
namespace caffe {
template <typename Dtype>
__global__ void ThresholdForward(const int n, const Dtype threshold,
const Dtype* in, Dtype* out) {
CUDA_KERNEL_LOOP(index, n) {
out[index] = in[index] > threshold ? 1 : 0;
}
}
template <typename Dt... |
dbae2402665341f1963c516cd7b53e320653ff09d7a802393e7e4b118fd632ae | CUDA | 895 | 28 | #include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
__global__ void RMSPropUpdate(int N, Dtype* g, Dtype* h,
Dtype rms_decay, Dtype delta, Dtype local_rate) {
CUDA_KERNEL_LOOP(i, N) {
float gi = g[i];
float hi = h[i] = rms_decay*h[i] + (1-rms_decay)*gi*gi;
g[i] = lo... |
a4ddc67ebe00a149af7c7668e3072e11a15cae5b701fa4f50fbcd62ea0fc0de7 | CUDA | 988 | 32 | #include <vector>
#include "caffe/layers/absval_layer.hpp"
#include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
void AbsValLayer<Dtype>::Forward_gpu(
const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
const int count = top[0]->count();
Dtype* top_data = top... |
0d703205f5cdb1d3dee23a2c99bfc591947b4dec4c6eccfc029e3c5db7ba6fce | CUDA | 1,029 | 30 | #include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
__global__ void AdaDeltaUpdate(int N, Dtype* g, Dtype* h, Dtype* h2,
Dtype momentum, Dtype delta, Dtype local_rate) {
CUDA_KERNEL_LOOP(i, N) {
float gi = g[i];
float hi = h[i] = momentum * h[i] + (1-momentum) * gi * gi... |
04a04a90589c0b5dc49cccd555419911452ac0ab5c96d41242475a44902dc77b | CUDA | 1,043 | 29 | #include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
__global__ void AdamUpdate(int N, Dtype* g, Dtype* m, Dtype* v,
Dtype beta1, Dtype beta2, Dtype eps_hat, Dtype corrected_local_rate) {
CUDA_KERNEL_LOOP(i, N) {
float gi = g[i];
float mi = m[i] = m[i]*beta1 + gi*(1-beta... |
6662a61a023661c73b54a6adf98da9b009282fbf32d57ac648550bfc41de8c27 | CUDA | 1,098 | 37 | #include <vector>
#include "caffe/layers/split_layer.hpp"
#include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
void SplitLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
for (int i = 0; i < top.size(); ++i) {
top[i]->ShareDat... |
d19c8d8b42e00c943550bea35b7565609a8d7214edd663a135ebb291c070835d | CUDA | 1,305 | 42 | #include <vector>
#include "caffe/layers/exp_layer.hpp"
#include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
void ExpLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
const int count = bottom[0]->count();
const Dtype* bottom_data ... |
e2f0bbd5095f31302a87cafbaefecd094af3f879813b1d870fb74cfd428635fe | CUDA | 1,310 | 41 | #ifdef USE_CUDNN
#include <vector>
#include "caffe/layers/cudnn_pooling_layer.hpp"
namespace caffe {
template <typename Dtype>
void CuDNNPoolingLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
const Dtype* bottom_data = bottom[0]->gpu_data();
Dtype* top_data = ... |
80f508b2a03d4c13d29eb299116d8a8b75b41437b4d63bc606c0a89aedf86ce6 | CUDA | 1,331 | 42 | #include <vector>
#include "caffe/layers/euclidean_loss_layer.hpp"
#include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
void EuclideanLossLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
int count = bottom[0]->count();
caffe_gpu_... |
3e137ff30a9d764592053d690494a43d30837e0b29aeb142e9f68a8f67d885c6 | CUDA | 1,344 | 39 | #include <vector>
#include "hdf5.h"
#include "hdf5_hl.h"
#include "caffe/layers/hdf5_output_layer.hpp"
namespace caffe {
template <typename Dtype>
void HDF5OutputLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
CHECK_GE(bottom.size(), 2);
CHECK_EQ(bottom[0]-... |
56412efb2092e203ce4c758e17176d953a18f163010c244261cb2563faa0ea9e | CUDA | 1,352 | 44 | #include <vector>
#include "caffe/blob.hpp"
#include "caffe/common.hpp"
#include "caffe/filler.hpp"
#include "caffe/layer.hpp"
#include "caffe/layers/recurrent_layer.hpp"
#include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
void RecurrentLayer<Dtype>::Forward_gpu(const vector<Blob<Dty... |
eedae6ed438662e2a0f2d1ba1c2c034f3b0502fc0024cb8618e60abeaea8235a | CUDA | 1,352 | 44 | #ifdef USE_CUDNN
#include <vector>
#include "caffe/layers/cudnn_lrn_layer.hpp"
namespace caffe {
template <typename Dtype>
void CuDNNLRNLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
const Dtype* bottom_data = bottom[0]->gpu_data();
Dtype* top_data = top[0]->... |
e917aa71ddc14acc664540298f6bd94c3f6892858f8be2cab9b179a7b586cfc3 | CUDA | 1,408 | 44 | #ifdef USE_CUDNN
#include <vector>
#include "thrust/device_vector.h"
#include "caffe/layers/cudnn_softmax_layer.hpp"
namespace caffe {
template <typename Dtype>
void CuDNNSoftmaxLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
const Dtype* bottom_data = bottom[0... |
7656e8631bb6f9edf3f5917c86b5e530f0cf7dc86e3b9f28964165483adfea32 | CUDA | 1,487 | 46 | #ifdef USE_CUDNN
#include <vector>
#include "caffe/layers/cudnn_lcn_layer.hpp"
namespace caffe {
template <typename Dtype>
void CuDNNLCNLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
const Dtype* bottom_data = bottom[0]->gpu_data();
Dtype* top_data = top[0]->... |
db730d8f187e7d9bd300e25dc35520f0536cf77a1f09ed707970a579baaaa11f | CUDA | 1,585 | 50 | /*
TODO:
- only load parts of the file, in accordance with a prototxt param "max_mem"
*/
#include <stdint.h>
#include <vector>
#include "hdf5.h"
#include "hdf5_hl.h"
#include "caffe/layers/hdf5_data_layer.hpp"
namespace caffe {
template <typename Dtype>
void HDF5DataLayer<Dtype>::Forward_gpu(const vector<Blob<Dtyp... |
7d18c953f6acbd23ffafd0a3c44584e3816ba381426a9433d242d686f548652e | CUDA | 1,747 | 57 | // TanH neuron activation function layer.
// Adapted from ReLU layer code written by Yangqing Jia
#include <vector>
#include "caffe/layers/tanh_layer.hpp"
namespace caffe {
template <typename Dtype>
__global__ void TanHForward(const int n, const Dtype* in, Dtype* out) {
CUDA_KERNEL_LOOP(index, n) {
out[index]... |
f5b6835fe20f9e4e5065cc59e3054f241cc9836c1a23b51dddb351cbdb539db8 | CUDA | 1,831 | 59 | #include <algorithm>
#include <vector>
#include "caffe/layers/bnll_layer.hpp"
namespace caffe {
const float kBNLL_THRESHOLD = 50.;
template <typename Dtype>
__global__ void BNLLForward(const int n, const Dtype* in, Dtype* out) {
CUDA_KERNEL_LOOP(index, n) {
out[index] = in[index] > 0 ?
in[index] + log... |
eb797d455b65f3c6fb9a976a55de3b181fbc91e1c3606ea4f4d996d44034bec8 | CUDA | 1,853 | 51 | #include <vector>
#include "caffe/layers/base_data_layer.hpp"
namespace caffe {
template <typename Dtype>
void BasePrefetchingDataLayer<Dtype>::Forward_gpu(
const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
Batch<Dtype>* batch = prefetch_full_.pop("Data layer prefetch queue empty");
// R... |
8ea70f4726b14fc7e7d57084369e1425fb2af7cd187c1aabb4c4c284fce5d7e3 | CUDA | 1,861 | 55 | #include <vector>
#include "caffe/layers/log_layer.hpp"
#include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
void LogLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
const int count = bottom[0]->count();
const Dtype* bottom_data ... |
c44278f2765fb6e2cda12923330d288bdca1e0be7e2acb3404c7d09c90845e44 | CUDA | 1,962 | 60 | #include <cmath>
#include <vector>
#include "caffe/layers/sigmoid_layer.hpp"
namespace caffe {
template <typename Dtype>
__global__ void SigmoidForward(const int n, const Dtype* in, Dtype* out) {
CUDA_KERNEL_LOOP(index, n) {
out[index] = 1. / (1. + exp(-in[index]));
}
}
template <typename Dtype>
void Sigmoi... |
17af7241fb4191936e30eb30a93977e0e5158ec71962960f03cc00685577f91d | CUDA | 1,979 | 62 | #include <algorithm>
#include <vector>
#include "caffe/layers/elu_layer.hpp"
namespace caffe {
template <typename Dtype>
__global__ void ELUForward(const int n, const Dtype* in, Dtype* out,
Dtype alpha) {
CUDA_KERNEL_LOOP(index, n) {
out[index] = in[index] > 0 ? in[index] :
alpha * (exp(in[index]) ... |
ca81b35d31639c202b4807eafc25516fca1aab123bd2757d119fc752524c358e | CUDA | 1,985 | 65 | #ifdef USE_CUDNN
#include <vector>
#include "caffe/layers/cudnn_tanh_layer.hpp"
namespace caffe {
template <typename Dtype>
void CuDNNTanHLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
const Dtype* bottom_data = bottom[0]->gpu_data();
Dtype* top_data = top[0]... |
cf59121e95eadac72ad5f357a4e90f2bcb51b63f047c122d7109cea1a5926a14 | CUDA | 1,996 | 64 | #ifdef USE_CUDNN
#include <vector>
#include "caffe/layers/cudnn_sigmoid_layer.hpp"
namespace caffe {
template <typename Dtype>
void CuDNNSigmoidLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
const Dtype* bottom_data = bottom[0]->gpu_data();
Dtype* top_data = ... |
995e1cdd4fb7358b916fb5368051c037bb5cf1d34f3274ed96c7293c77f544fc | CUDA | 2,123 | 59 | #include <vector>
#include "caffe/filler.hpp"
#include "caffe/layers/bias_layer.hpp"
#include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
__global__ void BiasForward(const int n, const Dtype* in,
const Dtype* bias, const int bias_dim, const int inner_dim,
Dtype* out) {
CUDA_... |
ad1e4a631ebb113ad5d7b0d7403b7d1d90696a2e039088916235ed7ffc397baf | CUDA | 2,209 | 64 | #include <algorithm>
#include <vector>
#include "caffe/layers/relu_layer.hpp"
namespace caffe {
template <typename Dtype>
__global__ void ReLUForward(const int n, const Dtype* in, Dtype* out,
Dtype negative_slope) {
CUDA_KERNEL_LOOP(index, n) {
out[index] = in[index] > 0 ? in[index] : in[index] * negative_... |
d4b61549736da9101fd21d4a57265af66ab1901f6cadeb0ce2326e52e9c77d8a | CUDA | 2,228 | 60 | #include <vector>
#include "caffe/layers/conv_layer.hpp"
namespace caffe {
template <typename Dtype>
void ConvolutionLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
const Dtype* weight = this->blobs_[0]->gpu_data();
for (int i = 0; i < bottom.size(); ++i) {
... |
7169a62c4637077bee1aaf7ee1d334b09f79abb19cd6eafe5fe89bd248898b04 | CUDA | 2,278 | 61 | #include <vector>
#include "caffe/layers/deconv_layer.hpp"
namespace caffe {
template <typename Dtype>
void DeconvolutionLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
const Dtype* weight = this->blobs_[0]->gpu_data();
for (int i = 0; i < bottom.size(); ++i... |
c90a1a18c6ea5001275f76a9efd1ca36bd4823b681dee919927d1a529bb9c51b | CUDA | 2,336 | 70 | #include <vector>
#include "caffe/layers/dropout_layer.hpp"
#include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
__global__ void DropoutForward(const int n, const Dtype* in,
const unsigned int* mask, const unsigned int threshold, const float scale,
Dtype* out) {
CUDA_KERNEL_... |
5acca71f7b0b0e95542ea577739376a1be63dec6deba74cf083ee1bf6f53bcac | CUDA | 2,350 | 60 | #include <vector>
#include "caffe/layers/auto_crop_layer.hpp"
namespace caffe {
// Copy (one line per thread) from one array to another, with arbitrary
// strides in the last two dimensions.
template <typename Dtype>
__global__ void copy_kernel(const int n, const int height, const int width,
const int src_outer_... |
580b3ad332ac16ba335bb401e0dad64e3a70cb8c17894ff679725beaadfc5c27 | CUDA | 2,367 | 74 | #ifdef USE_CUDNN
#include <vector>
#include "caffe/layers/cudnn_relu_layer.hpp"
namespace caffe {
template <typename Dtype>
void CuDNNReLULayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
// Fallback to standard Caffe for leaky ReLU.
if (ReLULayer<Dtype>::layer_... |
112834272c99ed8373cf787bce569c9a0b396a8e90b06dd1a231f16dd9d58aa7 | CUDA | 2,468 | 62 | #include <vector>
#include "caffe/layers/im2col_layer.hpp"
#include "caffe/util/im2col.hpp"
namespace caffe {
template <typename Dtype>
void Im2colLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
const Dtype* bottom_data = bottom[0]->gpu_data();
Dtype* top_da... |
4c93b6e2b468b7a36cbf66d21f664d19ab67c5fd40bb0dcdcace252965f3475d | CUDA | 2,567 | 66 | #include <vector>
#include "caffe/layers/tile_layer.hpp"
#include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
__global__ void Tile(const int nthreads, const Dtype* bottom_data,
const int tile_size, const int num_tiles, const int bottom_tile_axis,
Dtype* top_data) {
CUDA_KERN... |
9945eca57c4af0b7f2fb923f915af849a5795e41168fe536ab820d9782f39673 | CUDA | 2,713 | 69 | #include <vector>
#include "caffe/layers/filter_layer.hpp"
#include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
void FilterLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
int new_tops_num = indices_to_forward_.size();
// forwa... |
f177eff8d8b79c7627b5ae62ba08b1fa77f1731397a1d15b3c27287f60327bc5 | CUDA | 2,831 | 71 | #include <vector>
#include "caffe/layers/slice_layer.hpp"
#include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
__global__ void Slice(const int nthreads, const Dtype* in_data,
const bool forward, const int num_slices, const int slice_size,
const int bottom_slice_axis, const int... |
710b1f0a4db9ac8af22383e0ef204dd6f8c4c46e595ed43568d32a5466385dbf | CUDA | 2,914 | 79 | #include <vector>
#include "caffe/filler.hpp"
#include "caffe/layers/inner_product_layer.hpp"
#include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
void InnerProductLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
const Dtype* botto... |
8e52725cfa0e5c41a5bdf385b0c2c3c8cf57af51f4608a406a5b5ae6e1676b25 | CUDA | 2,916 | 101 | // ---------------------------------------------------------------
// Copyright (c) 2019-2022, NVIDIA Corporation. All rights reserved.
// ---------------------------------------------------------------
//
// This work is made available under the Nvidia Source Code License-NC.
// To view a copy of this license, visit
/... |
d19ce97e1714b5fd8eba92d919726a62347b649086af898451aef27c88538636 | CUDA | 2,916 | 91 | #include <vector>
#include "caffe/layers/reduction_layer.hpp"
#include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
void ReductionLayer<Dtype>::Forward_gpu(
const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
const Dtype* bottom_data = bottom[0]->gpu_data();
... |
7cc356e9a412d95acce26b67adfb08f5e8ceb02762df6e339798bed30cbbb34f | CUDA | 2,967 | 73 | #include <vector>
#include "caffe/layers/concat_layer.hpp"
#include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
__global__ void Concat(const int nthreads, const Dtype* in_data,
const bool forward, const int num_concats, const int concat_size,
const int top_concat_axis, const i... |
fe7c30d102622a11c8b26ff4cbbeac2487dc824cf012f5bcb10135b145296eee | CUDA | 3,080 | 81 | #include <vector>
#include "caffe/filler.hpp"
#include "caffe/layers/embed_layer.hpp"
#include "caffe/util/gpu_util.cuh"
#include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
__global__ void EmbedForward(const int nthreads, const Dtype* bottom_data,
const Dtype* weight, const int M... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.