flow.js | synchron , asynchron control flow javascript library | BPM library

The accepted answer from this thread guided me to solve this: Webpack Externals Configuration for a Local Library

I just needed to lookup how popperjs was referenced in tippyjs and use the same alias:

The error is straightforward, you are using an activation swish that is not defined. You can have a look at these answers here and there

This error disappeared when I restarted my computer and reloaded the webpage.

Found out that if I just flat down the array of data, it should work out aswell

To prevent this error you should instantiate each optimizer separately:

Why is this the case?

Because you haven't instructed the promise chain to wait for an asynchronous result from the catch handler. You'd need to return a promise from there for that.
Stepping into the then handler doesn't happen "before the catch block is resolved", the catch handler did already execute and did return undefined - that's what the promise chain continues with.

Why doesn't the control move to the bottom of the then block where we would output "Why are we not here..."?

Because right after logging undefined, you access res1.length, which causes the exception TypeError: Cannot read property 'length' of undefined. This rejects the promise, which is not handled anywhere, leading to the warning.

Now onto the real question: how to do this properly? You should avoid the Promise constructor antipattern! The .then() and .catch() calls already return a promise for the result of the handler, which you can and should use - no need to manually resolve or reject a promise, and no unhandled promise rejections because some inner promise is rejected but you fail to propagate this failure outside (notice the "Inside result..." handler should have been called when res1.length errored). Also I recommend to use .then(…, …) instead of .then(…).catch(…) (or .catch(…).then(…)) for conditional success/error handling.

I was able to solve the issue by using s3a. EMRFS libs used in the emr are not public and cannot be used outside EMR. Hence I used S3AFileSystem to access hbase on S3 from my ecs cluster. Add hadoop-aws and aws-java-sdk-bundle maven dependencies corresponding to your hadoop version. And add the below property in my core-site.xml.

You have pointed out the two methods that you can use to performing predictions for your ML/DL model. I will list down the steps needed for each and my own personal recommendations.

Here you would have to build and train the model using Tensorflow and Python. Then to use the model on your web application you would need to convert it to the correct format using tfjs-converter. For example, you would get back a model.json and group1-shard1of1.bin file which you can then use to make predictions on data from the client side. To improve performance you can quantize the model when converting it.

1. I find it easier this way to make predictions as the whole process is not difficult.
2. Model is always on the client side so it should be the best option if you are looking for very quick predictions.
3. Security wise, if this model is being used in production then no user data will ever be passed to the server side so users do not have to worry about their data being used inappropriately. For example, if you are in the European Union you would have to abide by the General Data Protection Regulation (GDPR) which really complicates things.
4. If you want to improve the model then you would need to train a new model followed by an update on the web application to change the model files. You are unable to perform online-learning(training the model on new data it sees and improving it on the fly).

Here you would have to use some sort of library for making REST API's. I would recommend FastAPI which is quite easy to get up and running. You would need to create routes for you to POST data to the model. You create routes that you make POST request to where these request receive the data from the client side and then using the model you have perform predictions on the data. Then it will send back the predictions in the request's body. The API and the code for making predictions would have to be hosted somewhere for you to query it from the client side, you could use Heroku for this. This article goes over the entire process.

1. Process is convoluted in comparison to the local method.
2. Data needs to be sent to the server so if you need very fast predictions on a lot of data this will be slower compared to the local method.
3. For production use-cases this is the preferred method unless the user data cannot be sent to the server.
4. These are REST API's so get it to work with GraphQL you would have to wrap the REST API's with GraphQL using the steps detailed here.
5. You can continuously improve the model without having to touch the client side code.

I dont want to get rid of the awesome JS libraries like GraphQL, but i dont want to sacrifice the Python performance. I know I can use Tensorflow.js, but as I said, in terms of performance, Python is way better.

One thing I would like to point out is that the prediction speed for the model is going to be the same regardless if you use Python or Javascript. The only way you can improve it is by quantization, which reduces the model size while also improving CPU and hardware accelerator latency, with little degradation in model accuracy as all that you are doing is making predictions using the model. Unless you are sending huge amounts of data to the endpoint in an area with slow internet speeds the differences between using either method is negligible.

The correct Dockerfile would be: