1659414049

In this Julia tutorial, we'll learn about BesselK.jl, a package implements one function: the modified second-kind Bessel function Kᵥ(x)

This package implements one function: the modified second-kind Bessel function Kᵥ(x). It is designed specifically to be automatically differentiable **with ForwardDiff.jl**, including providing derivatives with respect to the order parameter `v`

**that are fast and non-allocating in the entire domain for both first and second order**.

Derivatives with respect to \nu are significantly faster than any finite differencing method, including the most naive fixed-step minimum-order method, and in almost all of the domain are meaningful more accurate. Particularly near the origin you should expect to gain at least 3-5 digits. Second derivatives are even more dramatic, both in terms of the speedup and accuracy gains, now commonly giving 10+ more digits of accuracy.

As a happy accident/side-effect, if you're willing to give up the last couple digits of accuracy, you could also use `ForwardDiff.jl`

on this code for derivatives with respect to argument for an order-of-magnitude speedup. In some casual testing the argument-derivative errors with this code are never worse than `1e-12`

, and they turn 1.4 μs with allocations into 140 ns without any allocations.

In order to avoid naming conflicts with `SpecialFunctions.besselk`

, this package exports two functions: `adbesselk`

and `adbesselkxv`

. The first function is Kᵥ(x), and the second function is (xᵛ)*Kᵥ(x). This second function has the nice property of being bounded at the origin when v>0, and comes up in the Matern covariance function, which was the primary motivation for this implementation. The function `adbesselk`

returns `SpecialFunctions.besselk`

if `v isa AbstractFloat`

, since the AMOS `besselk`

is slightly more accurate, and there is a rule in place for the exact argument derivatives. But otherwise, it returns `BesselK._besselk(v, x, args...)`

, which is the Julia-native implementation here that provides very accurate derivatives.

Here is a very basic demo:

```
using ForwardDiff, SpecialFunctions, BesselK
(v, x) = (1.1, 2.1)
# For regular evaluations, you get what you're used to getting:
@assert isapprox(besselk(v, x), adbesselk(v, x))
@assert isapprox((x^v)*besselk(v, x), adbesselkxv(v, x))
# But now you also get good (and fast!) derivatves:
@show ForwardDiff.derivative(_v->adbesselk(_v, x), v) # good to go.
@show ForwardDiff.derivative(_v->adbesselkxv(_v, x), v) # good to go.
```

A note to people coming here from the paper

You'll see that this repo defines a great deal of specific derivative functions in the files in `./examples`

and `./paperscripts`

. **This is only because we specifically tested those quantities in the paper**. If you're just here to fit a Matern covariance function, then you should **not** be doing that. Your code, at least in the simplest case, should probably look more like this:

```
using ForwardDiff, BesselK
function my_covariance_function(loc1, loc2, params)
... # your awesome covariance function, presumably using adbesselk somewhere.
end
const my_data = ... # load in your data
const my_locations = ... # load in your locations
# Create your likelihood and use ForwardDiff for the grad and Hessian:
function nll(params)
K = cholesky!(Symmetric([my_covariance_function(x, y, params)
for x in my_locations, y in my_locations]))
0.5*(logdet(K) + dot(my_data, K\my_data))
end
nllg(params) = ForwardDiff.gradient(nll, params)
nllh(params) = ForwardDiff.hessian(nll, params)
my_mle = some_optimizer(init_params, nll, nllg, nllh, ...)
```

Or something like that. You of course do not *have* to do it this way, and could manually implement the gradient and Hessian of the likelihood after manually creating derivatives of the covariance function itself (see `./example/matern.jl`

for a demo of that), and manual implementations, particularly for the Hessian, will be faster if they are thoughtful enough. But what I mean to emphasize here is that in general you should *not* be doing manual chain rule or derivative computations of your covariance function itself. Let the AD handle that for you and enjoy the power that Julia's composability offers.

Limitations

For the moment there are two primary limitations:

**AD compatibility with ****ForwardDiff.jl**** only**. The issue here is that in one particular case I use a different function branch of one is taking a derivative with respect to `v`

or just evaluating `besselk(v, x)`

. The way that is currently checked in the code is with `if (v isa AbstractFloat)`

, which may not work properly for other methods.

**Only derivatives up to the second are checked and confirmed accurate.** The code uses a large number of local polynomial expansions at slightly hairy values of internal intermediate functions, and so at some sufficiently high level of derivative those local polynomials won't give accurate partial information.

Also consider: `Bessels.jl`

This software package was written with the pretty specific goal of computing derivatives of Kᵥ(x) with respect to the order using `ForwardDiff.jl`

. While it is in general a bit faster than AMOS, we give up a few digits of accuracy here and there in the interest of better and faster derivatives. If you just want the fastest possible Kᵥ(x), then you would probably be better off using `Bessels.jl`

. At the time of writing it only offers Kᵥ(x) for integer orders, but non-integer orders will be available soon enough I'm sure. While differentiability is on the roadmap, they more explicitly target writing the fastest possible base Kᵥ(x), and what they offer is seriously fast.

There is and will be some cross-pollination between the two software projects, and at some point I expect to switch `adbesselk`

to use `Bessels.besselk`

where possible instead of `SpecialFunctions.besselk`

. And at some point if the order derivatives become available there might not be much reason to use this package instead of that one, although I think for the moment if you want to fit a Matern covariance function you probably need to be here.

On the topic, the following methods are lifted directly from `Bessels.jl`

so that we can go fast in the meantime:

- Integer order
`\nu`

when`\nu isa AbstractFloat`

.

Implementation details

See the reference for an entire paper discussing the implementation. But in a word, this code uses several routines to evaluate Kᵥ accurately on different parts of the domain, and has to use some non-standard to maintain AD compatibility and correctness. When `v`

is an integer or half-integer, for example, a lot of additional work is required.

The code is also pretty well-optimized, and you can benchmark for yourself or look at the paper to see that in several cases the `ForwardDiff.jl`

-generated derivatives are faster than a single call to `SpecialFunctions.besselk`

. To achieve this performance, particularly for second derivatives, some work was required to make sure that all of the function calls are non-allocating, which means switching from raw `Tuple`

s to `Polynomial`

types in places where the polynomials are large enough and things like that. Again this arguably makes the code look a bit disorganized or inconsistent, but to my knowledge it is all necessary. If somebody looking at the source finds a simplification, I would love to see it, either in terms of an issue or a PR or an email or a patch file or anything.

A to-do item (written 2022/07/27), I think, is to re-organize the code a bit so that there is a function `_besselk_vdual`

that only gets called when `v isa ForwardDiff.Dual`

and a function `_besselk_abstractfloat`

when `v isa AbstractFloat`

. For the initial release, `adbesselk`

always defaulted to `SpecialFunctions.besselk`

where possible to give people what they expected and every digit possible. But as `Bessels.jl`

matures, I think lifting at least a few of those routines in the interim is appealing but means that there is awkwardly a lot of control flow in `BesselK._besselk`

as well as `BesselK.adbesselk`

now. Probably better to compartmentalize those two domain partitionings. Defaulting to `Bessels.besselk`

when `v isa AbstractFloat`

is probably a good intermediate goal once it's ready for all arguments.

Citation

If you use this package in your research that gets compiled into some kind of report/article/poster/etc, please cite this paper:

```
@misc{GMSS_2022,
title={Fitting Mat\'ern Smoothness Parameters Using Automatic Differentiation},
author={Christopher J. Geoga and Oana Marin and Michel Schanen and Michael L. Stein},
year={2022},
eprint={2201.00090},
archivePrefix={arXiv},
primaryClass={stat.CO}
}
```

While this package ostensibly only covers a single function, putting all of this together and making it this fast and accurate was really a lot of work. I would *really* appreciate you citing this paper if this package was useful in your research. Like, for example, if you used this package to fit a Matern smoothness parameter with second order optimization methods.

Also, if you're reading this a few months into 2022 or later, we would also really appreciate it if you check back here or even open an issue/email to ask if there is an official journal reference by that point. Thanks in advance!

**Download Details: **

Author: cgeoga

Source Code: https://github.com/cgeoga/BesselK.jl

License: MIT

#julia

1659414049

In this Julia tutorial, we'll learn about BesselK.jl, a package implements one function: the modified second-kind Bessel function Kᵥ(x)

This package implements one function: the modified second-kind Bessel function Kᵥ(x). It is designed specifically to be automatically differentiable **with ForwardDiff.jl**, including providing derivatives with respect to the order parameter `v`

**that are fast and non-allocating in the entire domain for both first and second order**.

Derivatives with respect to \nu are significantly faster than any finite differencing method, including the most naive fixed-step minimum-order method, and in almost all of the domain are meaningful more accurate. Particularly near the origin you should expect to gain at least 3-5 digits. Second derivatives are even more dramatic, both in terms of the speedup and accuracy gains, now commonly giving 10+ more digits of accuracy.

As a happy accident/side-effect, if you're willing to give up the last couple digits of accuracy, you could also use `ForwardDiff.jl`

on this code for derivatives with respect to argument for an order-of-magnitude speedup. In some casual testing the argument-derivative errors with this code are never worse than `1e-12`

, and they turn 1.4 μs with allocations into 140 ns without any allocations.

In order to avoid naming conflicts with `SpecialFunctions.besselk`

, this package exports two functions: `adbesselk`

and `adbesselkxv`

. The first function is Kᵥ(x), and the second function is (xᵛ)*Kᵥ(x). This second function has the nice property of being bounded at the origin when v>0, and comes up in the Matern covariance function, which was the primary motivation for this implementation. The function `adbesselk`

returns `SpecialFunctions.besselk`

if `v isa AbstractFloat`

, since the AMOS `besselk`

is slightly more accurate, and there is a rule in place for the exact argument derivatives. But otherwise, it returns `BesselK._besselk(v, x, args...)`

, which is the Julia-native implementation here that provides very accurate derivatives.

Here is a very basic demo:

```
using ForwardDiff, SpecialFunctions, BesselK
(v, x) = (1.1, 2.1)
# For regular evaluations, you get what you're used to getting:
@assert isapprox(besselk(v, x), adbesselk(v, x))
@assert isapprox((x^v)*besselk(v, x), adbesselkxv(v, x))
# But now you also get good (and fast!) derivatves:
@show ForwardDiff.derivative(_v->adbesselk(_v, x), v) # good to go.
@show ForwardDiff.derivative(_v->adbesselkxv(_v, x), v) # good to go.
```

A note to people coming here from the paper

You'll see that this repo defines a great deal of specific derivative functions in the files in `./examples`

and `./paperscripts`

. **This is only because we specifically tested those quantities in the paper**. If you're just here to fit a Matern covariance function, then you should **not** be doing that. Your code, at least in the simplest case, should probably look more like this:

```
using ForwardDiff, BesselK
function my_covariance_function(loc1, loc2, params)
... # your awesome covariance function, presumably using adbesselk somewhere.
end
const my_data = ... # load in your data
const my_locations = ... # load in your locations
# Create your likelihood and use ForwardDiff for the grad and Hessian:
function nll(params)
K = cholesky!(Symmetric([my_covariance_function(x, y, params)
for x in my_locations, y in my_locations]))
0.5*(logdet(K) + dot(my_data, K\my_data))
end
nllg(params) = ForwardDiff.gradient(nll, params)
nllh(params) = ForwardDiff.hessian(nll, params)
my_mle = some_optimizer(init_params, nll, nllg, nllh, ...)
```

Or something like that. You of course do not *have* to do it this way, and could manually implement the gradient and Hessian of the likelihood after manually creating derivatives of the covariance function itself (see `./example/matern.jl`

for a demo of that), and manual implementations, particularly for the Hessian, will be faster if they are thoughtful enough. But what I mean to emphasize here is that in general you should *not* be doing manual chain rule or derivative computations of your covariance function itself. Let the AD handle that for you and enjoy the power that Julia's composability offers.

Limitations

For the moment there are two primary limitations:

**AD compatibility with ****ForwardDiff.jl**** only**. The issue here is that in one particular case I use a different function branch of one is taking a derivative with respect to `v`

or just evaluating `besselk(v, x)`

. The way that is currently checked in the code is with `if (v isa AbstractFloat)`

, which may not work properly for other methods.

**Only derivatives up to the second are checked and confirmed accurate.** The code uses a large number of local polynomial expansions at slightly hairy values of internal intermediate functions, and so at some sufficiently high level of derivative those local polynomials won't give accurate partial information.

Also consider: `Bessels.jl`

This software package was written with the pretty specific goal of computing derivatives of Kᵥ(x) with respect to the order using `ForwardDiff.jl`

. While it is in general a bit faster than AMOS, we give up a few digits of accuracy here and there in the interest of better and faster derivatives. If you just want the fastest possible Kᵥ(x), then you would probably be better off using `Bessels.jl`

. At the time of writing it only offers Kᵥ(x) for integer orders, but non-integer orders will be available soon enough I'm sure. While differentiability is on the roadmap, they more explicitly target writing the fastest possible base Kᵥ(x), and what they offer is seriously fast.

There is and will be some cross-pollination between the two software projects, and at some point I expect to switch `adbesselk`

to use `Bessels.besselk`

where possible instead of `SpecialFunctions.besselk`

. And at some point if the order derivatives become available there might not be much reason to use this package instead of that one, although I think for the moment if you want to fit a Matern covariance function you probably need to be here.

On the topic, the following methods are lifted directly from `Bessels.jl`

so that we can go fast in the meantime:

- Integer order
`\nu`

when`\nu isa AbstractFloat`

.

Implementation details

See the reference for an entire paper discussing the implementation. But in a word, this code uses several routines to evaluate Kᵥ accurately on different parts of the domain, and has to use some non-standard to maintain AD compatibility and correctness. When `v`

is an integer or half-integer, for example, a lot of additional work is required.

The code is also pretty well-optimized, and you can benchmark for yourself or look at the paper to see that in several cases the `ForwardDiff.jl`

-generated derivatives are faster than a single call to `SpecialFunctions.besselk`

. To achieve this performance, particularly for second derivatives, some work was required to make sure that all of the function calls are non-allocating, which means switching from raw `Tuple`

s to `Polynomial`

types in places where the polynomials are large enough and things like that. Again this arguably makes the code look a bit disorganized or inconsistent, but to my knowledge it is all necessary. If somebody looking at the source finds a simplification, I would love to see it, either in terms of an issue or a PR or an email or a patch file or anything.

A to-do item (written 2022/07/27), I think, is to re-organize the code a bit so that there is a function `_besselk_vdual`

that only gets called when `v isa ForwardDiff.Dual`

and a function `_besselk_abstractfloat`

when `v isa AbstractFloat`

. For the initial release, `adbesselk`

always defaulted to `SpecialFunctions.besselk`

where possible to give people what they expected and every digit possible. But as `Bessels.jl`

matures, I think lifting at least a few of those routines in the interim is appealing but means that there is awkwardly a lot of control flow in `BesselK._besselk`

as well as `BesselK.adbesselk`

now. Probably better to compartmentalize those two domain partitionings. Defaulting to `Bessels.besselk`

when `v isa AbstractFloat`

is probably a good intermediate goal once it's ready for all arguments.

Citation

If you use this package in your research that gets compiled into some kind of report/article/poster/etc, please cite this paper:

```
@misc{GMSS_2022,
title={Fitting Mat\'ern Smoothness Parameters Using Automatic Differentiation},
author={Christopher J. Geoga and Oana Marin and Michel Schanen and Michael L. Stein},
year={2022},
eprint={2201.00090},
archivePrefix={arXiv},
primaryClass={stat.CO}
}
```

While this package ostensibly only covers a single function, putting all of this together and making it this fast and accurate was really a lot of work. I would *really* appreciate you citing this paper if this package was useful in your research. Like, for example, if you used this package to fit a Matern smoothness parameter with second order optimization methods.

Also, if you're reading this a few months into 2022 or later, we would also really appreciate it if you check back here or even open an issue/email to ask if there is an official journal reference by that point. Thanks in advance!

**Download Details: **

Author: cgeoga

Source Code: https://github.com/cgeoga/BesselK.jl

License: MIT

#julia

1612595276

**Purchase Now !!! Snap on the Link beneath for more data. Rush !!!

**

Official Website:- http://wintersupplement.com/fast-fit-keto/

Fast Fit Keto Reviews – Everyone ought to lessen their weight. On the off chance that you could get thinner in a couple of days without contributing energy or exertion, you would. That is the reason incalculable individuals are taking Fast Fit Keto pills to consume fat quicker and simpler than at any other time. With this extraordinary keto formula, your body will get just the fixings it needs to become accustomed to ketosis so you can begin getting more fit immediately. In the primary month, you can shed five pounds or more. Come these lines through our Fast Fit Keto audit to discover how this astounding ketogenic weight reduction supplement can assist you with getting in shape quicker and simpler than at any other time in late memory. Something else, click on the example underneath to check whether you can ensure a 40% Discounted offer of the top rated ketogenic pills for weight reduction before the arrangement closures or supplies run out.

**What is Fast Fit Keto audits? **

Getting the best and flawless shape has been the normal longing for everyone The world has been encountering a gigantic transition of getting a hot shape, yet an awful way of life and numerous different things influence their cravings. Yet, there are supplements like Body Fast Fit Keto surveys a nature-based thing which has discernibly bring back the lost gracefulness of the body by managing unfortunate fats from the body. This thing has various properties and can be utilized in different issues.

Fast Fit Keto Reviews cost In bygone eras when there were not strong helpful focuses available, this plant has been used to treat heart issues and sometimes in excessively touchy conditions. It is local and generally, used as a piece of Ayurveda treatment. As demonstrated by experts this thing constructs the immunity, endurance, seethes fat, and augmentation slant mass. This enhancement show rapidly after use and starts dissolving the gathering of extra fat present on the body. The two guys and females can use this thing to make a slim and engaging body. Consequently you should go for this thing and endeavor to change your personality.

http://wintersupplement.com/fast-fit-keto/

https://www.stageit.com/fastfitketobuy

https://dribbble.com/fastfitketobuy

https://linktr.ee/fastfitketoreviews

https://www.startus.cc/company/fast-fit-keto-shark-tank

https://secure.aspca.org/team/fast-fit-keto-reviews

https://www.facebook.com/sharktankdietsreviews/posts/1496584900547209

https://thenevadaview.com/fast-fit-keto/

https://k12.instructure.com/eportfolios/20408/

https://twitter.com/FastFitKetoSha1

https://www.facebook.com/supplementsworldofficial/videos/134442571858804/

https://zenodo.org/record/4506017#.YBzp0fnhUdU

https://www.completefoods.co/diy/recipes/fast-fit-keto-update-2021-user-exposed-truth-read-now

https://gocrowdera.com/US/other/fast-fit-keto/

https://sites.google.com/view/fast-fit-keto-shark-tank/

https://talknchat.net/read-blog/5805_fast-fit-keto-shark-tank-final-verdict-2021.html

http://snomoto.com/fast-fit-keto-reviews-pills-shark-tank-scam-where-to-buy/

https://www.docdroid.net/IoNNGnO/fast-fit-keto-shark-tank-pdf

https://www.docdroid.net/g8hM6Ww/fast-fit-keto-reviews-pdf

#fast fit keto shark tank #fast fit keto reviews #fast fit keto #fast fit keto reviews 2021

1608778496

FastSwap A decentralized exchange for erc20 Token and cross-chain swap powered by Polkadot. FastSwap is a bundle of different dapps in one place, from token swap to p2p, nft, vaults etc. Just like Sushiswap Fastswap share trading fees with Fast Holders.

FastSwap is a decentralized protocol for automated liquidity provision on Ethereum, Tron Network, BSC etc. + Cross-Chain Swap through Parachain on Polkadot.

**Would you like to earn many tokens and cryptocurrencies right now! ☞ CLICK HERE**

*Looking for more information…*

☞ Website

☞ Explorer

☞ Source Code

☞ Social Channel

☞ Coinmarketcap

Thank for visiting and reading this article! I’m highly appreciate your actions! Please share if you liked it!

#blockchain #bitcoin #crypto #fastswap #fast

1660370580

Marvin N. Wright

ranger is a fast implementation of random forests (Breiman 2001) or recursive partitioning, particularly suited for high dimensional data. Classification, regression, and survival forests are supported. Classification and regression forests are implemented as in the original Random Forest (Breiman 2001), survival forests as in Random Survival Forests (Ishwaran et al. 2008). Includes implementations of extremely randomized trees (Geurts et al. 2006) and quantile regression forests (Meinshausen 2006).

ranger is written in C++, but a version for R is available, too. We recommend to use the R version. It is easy to install and use and the results are readily available for further analysis. The R version is as fast as the standalone C++ version.

To install the ranger R package from CRAN, just run

```
install.packages("ranger")
```

R version >= 3.1 is required. With recent R versions, multithreading on Windows platforms should just work. If you compile yourself, the new RTools toolchain is required.

To install the development version from GitHub using `devtools`

, run

```
devtools::install_github("imbs-hl/ranger")
```

To install the C++ version of ranger in Linux or Mac OS X you will need a compiler supporting C++11 (i.e. gcc >= 4.7 or Clang >= 3.0) and Cmake. To build start a terminal from the ranger main directory and run the following commands

```
cd cpp_version
mkdir build
cd build
cmake ..
make
```

After compilation there should be an executable called "ranger" in the build directory.

To run the C++ version in Microsoft Windows please cross compile or ask for a binary.

For usage of the R version see ?ranger in R. Most importantly, see the Examples section. As a first example you could try

```
ranger(Species ~ ., data = iris)
```

In the C++ version type

```
./ranger --help
```

for a list of commands. First you need a training dataset in a file. This file should contain one header line with variable names and one line with variable values per sample (numeric only). Variable names must not contain any whitespace, comma or semicolon. Values can be seperated by whitespace, comma or semicolon but can not be mixed in one file. A typical call of ranger would be for example

```
./ranger --verbose --file data.dat --depvarname Species --treetype 1 --ntree 1000 --nthreads 4
```

If you find any bugs, or if you experience any crashes, please report to us. If you have any questions just ask, we won't bite.

Please cite our paper if you use ranger.

- Wright, M. N. & Ziegler, A. (2017). ranger: A fast implementation of random forests for high dimensional data in C++ and R. J Stat Softw 77:1-17. https://doi.org/10.18637/jss.v077.i01.
- Schmid, M., Wright, M. N. & Ziegler, A. (2016). On the use of Harrell's C for clinical risk prediction via random survival forests. Expert Syst Appl 63:450-459. https://doi.org/10.1016/j.eswa.2016.07.018.
- Wright, M. N., Dankowski, T. & Ziegler, A. (2017). Unbiased split variable selection for random survival forests using maximally selected rank statistics. Stat Med 36:1272-1284. https://doi.org/10.1002/sim.7212.
- Nembrini, S., König, I. R. & Wright, M. N. (2018). The revival of the Gini Importance? Bioinformatics. https://doi.org/10.1093/bioinformatics/bty373.
- Breiman, L. (2001). Random forests. Mach Learn, 45:5-32. https://doi.org/10.1023/A:1010933404324.
- Ishwaran, H., Kogalur, U. B., Blackstone, E. H., & Lauer, M. S. (2008). Random survival forests. Ann Appl Stat 2:841-860. https://doi.org/10.1097/JTO.0b013e318233d835.
- Malley, J. D., Kruppa, J., Dasgupta, A., Malley, K. G., & Ziegler, A. (2012). Probability machines: consistent probability estimation using nonparametric learning machines. Methods Inf Med 51:74-81. https://doi.org/10.3414/ME00-01-0052.
- Hastie, T., Tibshirani, R., Friedman, J. (2009). The Elements of Statistical Learning. Springer, New York. 2nd edition.
- Geurts, P., Ernst, D., Wehenkel, L. (2006). Extremely randomized trees. Mach Learn 63:3-42. https://doi.org/10.1007/s10994-006-6226-1.
- Meinshausen (2006). Quantile Regression Forests. J Mach Learn Res 7:983-999. http://www.jmlr.org/papers/v7/meinshausen06a.html.
- Sandri, M. & Zuccolotto, P. (2008). A bias correction algorithm for the Gini variable importance measure in classification trees. J Comput Graph Stat, 17:611-628. https://doi.org/10.1198/106186008X344522.
- Coppersmith D., Hong S. J., Hosking J. R. (1999). Partitioning nominal attributes in decision trees. Data Min Knowl Discov 3:197-217. https://doi.org/10.1023/A:1009869804967.

Author: imbs-hl

Source Code: https://github.com/imbs-hl/ranger

1592056080

Whether it is a click on an ad, a card swipe, or an IoT sensor detecting an anomaly, real-time events are everywhere. Organizations need to react to such events in-the-moment as customers demand action within a span of a few minutes or even seconds. Legacy data strategies like Big Data and batch processing are no longer enough to meet modern data requirements.

The same study concludes that when it comes to growing profitability, better revenues and increased customer satisfaction, current data strategies are not fully supporting these needs. While speed has become extremely critical for managing data arriving from multiple sources, the existing fast data technology is not supporting enterprises to the extent that they should.

#big data and fast data #business insights #ml # ai and data engineering #fast data #fast data analytics