Microservices architecture (or SOA) work well with ML applications. This is because their interfaces are usually very narrow, while the functionality provided quite comprehensive. Hence, drawing the boundaries of responsibilities is more straightforward in the case of ML services than in the case of more traditional business applications. For this reason, it is common to have a tree of models (preferably wrapped in GreatAI instances) communicating with each other.
+Although regular HTTP POST requests could be sent to each service's /predict endpoint, great-ai comes with two convenience functions: call_remote_great_ai and call_remote_great_ai_async to wrap this request. These provide you with some level of robustness and deserialisation.
Inside notebooks
+The async variant, call_remote_great_ai_async, requires a running event loop while the synchronous variant disallows other running event-loops. Therefore, when running inside a Jupyter Notebook, always call call_remote_great_ai_async.
+Let's create two processes: a server and a client.
+from great_ai import GreatAI
+from asyncio import sleep
+
+@GreatAI.create
+async def slow_greeter(your_name):
+ await sleep(2)
+ return f'Hi {your_name}!'
+++Run this in development mode by executing
+great-ai server.pyorpython3 -m great_ai server.pyif you're on Windows andgreat-aiis not in yourPATH.
from great_ai import call_remote_great_ai
+
+names = ['Olivér', 'Balázs', 'András']
+
+results = [
+ call_remote_great_ai(
+ 'http://localhost:6060',
+ {
+ 'your_name': name
+ }
+ ).output #(1)
+ for name in names
+]
+
+print(results)
+++Run this script as a regular Python script by executing
+python3 client.py.
As you can see, everything worked as expected. There is one way to improve it though.
+async example#Let's send multiple requests at the same time to speed up the overall execution time. To do this, we will use the call_remote_great_ai_async function.
+Note, that in server.py, the inference function is declared async. This means that multiple "copies" of it can run at the same time in the same thread. Since, there is no CPU-bottleneck, the server has a quite large throughpout (requests responded to per second), but its latency will stay around 2 seconds due to the async sleep command.
If your great-ai server is not async, higher throughput can be achieved by running multiple instances of it, either manually, or by running it with multiple uvicorn workers like this: ENVIRONMENT=production great-ai server.py --worker_count 4
from great_ai import call_remote_great_ai_async
+import asyncio
+
+names = ['Olivér', 'Balázs', 'András']
+
+async def main():
+ futures = [
+ call_remote_great_ai_async(
+ 'http://localhost:6060',
+ {
+ 'your_name': name
+ }
+ ) for name in names
+ ]
+
+ results = await asyncio.gather(*futures)
+ print([r.output for r in results])
+
+asyncio.run(main())
+++Replace
+client.pywith this async client. Note that even though async support is significantly more streamlined in recent Python versions, it still requires a bit more boilerplate than its synchronous counterpart.
This also works, and in some use cases might be considerably quicker.
The functions save_model and @use_model wrap LargeFile instances. Hence, besides configuring LargeFile, users have few reasons to use this.
+The functions save_model and @use_model wrap LargeFile instances. Hence, besides configuring LargeFile, users have few reasons to use LargeFile-s directly.
Oftentimes, especially when working with data-heavy applications, large files can proliferate in a repository. Version controlling them is an obvious next step, however, GitHub's git LFS implementation doesn't support deleting large files, making it easy for them to eat-up the LFS quota and explode the size of your repos.
+DVC is a viable alternative, however, it requires users to learn to use one more CLI tool.
LargeFile doesn't require users to learn too much new. It is a nearly exact copy of the built-in open() function of Python with which users are certainly already familiar.
from great_ai.large_file import LargeFileS3
@@ -984,7 +986,7 @@
-This way, both regular files and folders can be handled. The uploaded file is called folder-of-my-bert-model, the local name is ignored.
+This way both regular files and folders can be handled. The uploaded file is called folder-of-my-bert-model, the local name is ignored.
Lastly, all version of the remote object can be deleted by calling LargeFileS3("my-file").delete(). It will still reside in your local cache afterwards, its deletion will happen next time your local cache has to be pruned.
@@ -1026,7 +1028,7 @@
Last update:
- July 12, 2022
+ July 13, 2022
@@ -1063,13 +1065,13 @@
-
+
IBB1Iui!1*7&?nuE^zNx(2Up
za8-osBQNu(!{3+1&JN`I+?s*SFH)z(8(#rnf~d`U%|wK>lVDUV;ePh(T65;?19n*4
zyj}Mq^-Y(=ti7Yw6JeM86|e*Z>$Bk_@a4#K;q3X#7a1un9J&4;xwG#!g-r{jQj)bV
z5xbq