Turning Open Source project into Product with Redis Enterprise

Fri, 19 Aug 2022 00:00:00 +0000

Turning Open Source project into Product with Redis Enterprise</h1>

Overview</h1>

Background</h1>

History</h2>
Last year, my reference project, "The Pattern", was the hackathon winner 2021 and got a bit of publicity and, in total, seven forks. But as with many open source projects, it is now stale. Time to revive "The Pattern" with new features and GitHub sponsors or Patreon patrons to help and inspire developers and creatives. In return, it's common to provide sponsor-only features and articles. Nevertheless, how can we do it with a large Redis-based machine learning pipeline?

Overall architecture overview</h1>

flowchart LR id1(User) --> flask_login(Flask Login API)--> github(GitHub OAuth2) github-->flask_callback(Flask API callback)-->GitHubGraphQL(GitHub GraphQL)</div>

Add Github oauth2 to Rest API</h2>

There are a number of API's that GitHub offers to help developers, but the GitHub Authentication API is one of the most popular. This API allows you to log in to GitHub using your username and password, or OAuth token.

A login button with a standard OIDC/OAuth2 dance is one of the most common ways for a user to authenticate to an API. Below is code taken from this gist</a> and is very common for OAuth2 flows:

import </span>os 
</span>client_id </span>= </span>os.</span>getenv</span>(</span>'GITHUB_CLIENT_ID'</span>)
</span>client_secret </span>= </span>os.</span>getenv</span>(</span>'GITHUB_SECRET'</span>)
</span>@app.</span>route</span>(</span>'/'</span>, </span>methods</span>=</span>[</span>'GET'</span>, </span>'POST'</span>])
</span>def </span>index</span>():
</span>    url </span>= </span>'https://github.com/login/oauth/authorize'
</span>    params </span>= </span>{
</span>        </span>'client_id'</span>: client_id,
</span>
</span>        </span>'scope'</span>: </span>'read:user,read:email'</span>,
</span>        </span>'state'</span>: </span>str</span>(</span>uuid4</span>().hex),
</span>        </span>'allow_signup'</span>: </span>'true'
</span>    }
</span>    url </span>= </span>furl</span>(url).</span>set</span>(params)
</span>    </span>return </span>redirect</span>(</span>str</span>(url), </span>302</span>)
</span></code></pre>
where GITHUB_CLIENT_ID and GITHUB_SECRET are client/secret GitHub Oauth2 apps. Register for following process on GitHub</a></p>

On callback:

Fetch username, email, and other profile information- in case we need to contact them</li>
get the status of the user - if they are sponsor of the organisation

if they are sponsor </li>
add the username to the set of sponsors in Redis</li>
</ul>
</li>
</ul>
</li>
</ul>
org_name</span>=</span>"applied-knowledge-systems"
</span>@app.</span>route</span>(</span>'/oauth2/callback'</span>)
</span>def </span>oauth2_callback</span>():
</span>
</span>    code </span>= </span>request.args.</span>get</span>(</span>'code'</span>)
</span>    access_token_url </span>= </span>'https://github.com/login/oauth/access_token'
</span>    payload </span>= </span>{
</span>        </span>'client_id'</span>: client_id,
</span>        </span>'client_secret'</span>: client_secret,
</span>        </span>'code'</span>: code,
</span>        </span># 'redirect_uri':
</span>        </span>'state'</span>: </span>str</span>(</span>uuid4</span>().hex)
</span>    }
</span>    r </span>= </span>requests.</span>post</span>(access_token_url, </span>json</span>=</span>payload, </span>headers</span>=</span>{</span>'Accept'</span>: </span>'application/json'</span>})
</span>    access_token </span>= </span>json.</span>loads</span>(r.text).</span>get</span>(</span>'access_token'</span>)
</span>    </span>print</span>(access_token)
</span>    
</span>    access_user_url </span>= </span>'https://api.github.com/user'
</span>    response </span>= </span>requests.</span>get</span>(access_user_url, </span>headers</span>=</span>{</span>'Authorization'</span>: </span>'token ' </span>+ </span>access_token})
</span>    data</span>=</span>response.</span>json</span>()
</span>    user_email</span>=</span>data[</span>"email"</span>]
</span>    user_login</span>=</span>data[</span>"login"</span>]
</span>    user_id</span>=</span>data[</span>"id"</span>]
</span>    </span># response=redirect(url_for('login',next=redirect_url()))
</span>    </span># response.set_cookie('user_id', str(user_id))
</span>    </span># response.set_cookie('user_login', str(user_login))
</span>    </span># return response
</span>    query </span>= </span>"""
</span>        {
</span>        viewer {
</span>            sponsorshipsAsSponsor(first: 100) {
</span>            nodes {
</span>                sponsorable {
</span>                ... on User {
</span>                    id
</span>                    email
</span>                    url
</span>                }
</span>                ... on Organization {
</span>                    id
</span>                    email
</span>                    name
</span>                    url
</span>                }
</span>                }
</span>                tier {
</span>                id
</span>                name
</span>                monthlyPriceInDollars
</span>                monthlyPriceInCents
</span>                }
</span>            }
</span>            }
</span>        }
</span>        }
</span>        """
</span>    response_graphql </span>= </span>requests.</span>post</span>(</span>'https://api.github.com/graphql'</span>, </span>json</span>=</span>{</span>'query'</span>: query}, </span>headers</span>=</span>{</span>'Authorization'</span>: </span>'token ' </span>+ </span>access_token})
</span>    response_graphql_data</span>=</span>response_graphql.</span>json</span>()[</span>"data"</span>]
</span>    </span>if </span>isinstance </span>(response_graphql_data[</span>"viewer"</span>][</span>"sponsorshipsAsSponsor"</span>][</span>"nodes"</span>], list):
</span>      </span>if </span>response_graphql_data[</span>"viewer"</span>][</span>"sponsorshipsAsSponsor"</span>][</span>"nodes"</span>][</span>0</span>][</span>"sponsorable"</span>][</span>"name"</span>]</span>==</span>org_name:
</span>          </span># if user is a sponsor of Applied Knowledge System add them to set of sponsors
</span>         redis_client.</span>sadd</span>(</span>f</span>'sponsors:</span>{org_name}</span>'</span>,user_id)
</span>    </span># if RedisJSON enabled:
</span>    </span># redis_client.json().set(f"user_details:{user_id}", '$', {
</span>    </span>#     'email': user_email,
</span>    </span>#     'id': user_id,
</span>    </span>#     'user_login': user_login,
</span>    </span>#     'graphql': response_graphql_data,
</span>    </span># }) 
</span>    </span>#if not
</span>    redis_client.</span>hset</span>(</span>f</span>"user_details:</span>{user_id}</span>"</span>, </span>mapping</span>=</span>{
</span>        </span>'email'</span>: user_email,
</span>        </span>'id'</span>: user_id,
</span>        </span>'user_login'</span>: user_login
</span>    })
</span>    </span>return </span>jsonify</span>({
</span>        </span>'status'</span>: </span>'success'</span>,
</span>        </span>'email'</span>: user_email,
</span>        </span>'id'</span>: user_id,
</span>        </span>'user_login'</span>: user_login
</span>    })
</span></code></pre>
The API we are using for our sponsor-only feature is straightforward:</p>
@app.</span>route</span>(</span>'/exclude'</span>, </span>methods</span>=</span>[</span>'POST'</span>,</span>'GET'</span>])
</span>def </span>mark_node</span>():
</span>    </span>if </span>request.method </span>== </span>'POST'</span>:
</span>        </span>if </span>'id' </span>in </span>request.json:
</span>            node_id</span>=</span>request.json[</span>'id'</span>]
</span>    </span>else</span>:
</span>        </span>if </span>'id' </span>in </span>request.args:
</span>            node_id</span>=</span>request.args.</span>get</span>(</span>'id'</span>)
</span>    user_id </span>= </span>session.</span>get</span>(</span>'user_id'</span>)
</span>    </span>log</span>(</span>f</span>"Got user </span>{user_id}</span> from session"</span>)
</span>    </span>if not </span>user_id:
</span>        user_id </span>= </span>request.cookies.</span>get</span>(</span>'user_id'</span>)
</span>        </span>log</span>(</span>f</span>"Got user </span>{user_id}</span> from cookie"</span>)
</span>    redis_client.</span>sadd</span>(</span>"user:</span>%s</span>:mnodes" </span>% </span>user_id,node_id)
</span>    response </span>= </span>jsonify</span>(</span>message</span>=</span>f</span>"Finished </span>{node_id}</span> and </span>{user_id}</span>"</span>)
</span>    </span>return </span>response
</span></code></pre>
And the only purpose of this API is to mark nodes as unimportant for the given user by adding nodes to RedisSet, and those nodes will be excluded from search API output. So far, everything was pretty standard: basic flask API and GitHub Social login flow. Now let's add Redis Enterprise and synchronise sponsors preferences.</p>
Add Redis Enterprise</h1>
Why not use Redis Enterprise directly for everything? 
The project is memory-heavy, with a lot of data and machine learning inside Redis. This allows to achieve state-of-the-art performance, but it also takes over 120 GB RAM (or as much RAM as you can give it), and 128 GB Redis Enterprise instance will exceed my budget for open-source project. Obviously if there will be enough sponsors we can move more functionality into Redis Enterprise, but for that we need to finish building basic blocks. Register on Redis.com</a> cloud and create a database with the subscription.</p>

Take a note host, port and password for Redis Enterprise and create docker enviroment file: </p>
cat</span> .env.gears 
</span>REDISENT_PWD</span>=</span>"123"
</span>REDISENT_PORT</span>=</span>"13444"
</span>REDISENT_HOST</span>=</span>"hostname.cloud.redislabs.com"
</span></code></pre>
and create a docker compose with section passing .env.gears. Mine looks like this:</p>
  redisgraph:
</span>    image: redislabs/redismod
</span>    container_name: redisgears
</span>    hostname: redisgears
</span>    env_file:
</span>      - ./.env.gears
</span>    ports:
</span>      - 127.0.0.1:9001:6379
</span>
</span></code></pre>
Synchronize Redis OSS to Redis Enterprise using RedisGears</h1>
Synchronize all user preferences</h2>
First flow:
We will be using RedisGears to synchronize all preferences with Redis Enterprise</p>
flowchart LR
    id1(User Preferences Redis OSS) --> redis_gears1(Redis Gears)--> redise(Redis Enterprise)</div>
If you are new to RedisGears, there is a pattern rgsync</a> that covers exacly this use case, but I already have RedisGears, so I am going to build it step by step:</p>
# gears_sync_preferences.py
</span>rconn</span>=</span>None
</span>
</span>def </span>connecttoRedisEnterise</span>():
</span>    </span>import </span>redis 
</span>    </span>import </span>os 
</span>    </span>log</span>(</span>str</span>(os.environ))
</span>    </span># Get environment variables
</span>
</span>    </span>HOST </span>= </span>os.</span>getenv</span>(</span>'REDISENT_HOST'</span>)
</span>    </span>PASSWORD </span>= </span>os.</span>getenv</span>(</span>'REDISENT_PWD'</span>)
</span>    </span>PORT </span>= </span>os.</span>getenv</span>(</span>'REDISENT_PORT'</span>)
</span>
</span>    redis_client</span>=</span>redis.</span>Redis</span>(</span>host</span>=</span>HOST</span>,</span>port</span>=</span>PORT</span>,</span>charset</span>=</span>"utf-8"</span>, </span>password</span>=</span>PASSWORD</span>, </span>decode_responses</span>=</span>True</span>)
</span>    </span>return </span>redis_client
</span>
</span>def </span>sync_users</span>(</span>record</span>):
</span>    </span>global </span>rconn
</span>    </span>if not </span>rconn:
</span>        rconn</span>=</span>connecttoRedisEnterise</span>()
</span>    </span># Uncomment logs to check 
</span>    </span># log(str(record['key']))
</span>    </span># log(str(record['value']))
</span>
</span>    rconn.</span>hset</span>(record[</span>'key'</span>],</span>mapping</span>=</span>record[</span>'value'</span>])
</span>
</span>gb </span>= </span>GB</span>()
</span>gb.</span>foreach</span>(sync_users)
</span>gb.</span>count</span>()
</span>gb.</span>run</span>(</span>'user_details:*'</span>)
</span></code></pre>
this is a "batch" mode for RedisGears, which is easier to debug than streams. Install gears-cli](https://github.com/RedisGears/gears-cli) with pip install gears-cli</code> run above script:</p>
gears-cli</span> run</span> --host</span> 127.0.0.1</span> --port</span> 9001 gears_sync_preferences.py</span> --requirements</span> req_sync.txt
</span></code></pre>
where req_sync.txt</p>
redis</span>==</span>3.5.3
</span></code></pre>
This RedisGears will copy all user's profiles into RedisEnterprise. Now let us add sponsors:</p>
# gears_sync_sponsors.py
</span>rconn</span>=</span>None
</span>
</span>def </span>remove_prefix</span>(</span>text</span>, </span>prefix</span>):
</span>    </span>return </span>text[text.</span>startswith</span>(prefix) </span>and </span>len</span>(prefix):]
</span>
</span>def </span>connecttoRedisEnterise</span>():
</span>    </span>import </span>redis 
</span>    </span>import </span>os 
</span>    </span>log</span>(</span>str</span>(os.environ))
</span>    </span># Get environment variables
</span>
</span>    </span>HOST </span>= </span>os.</span>getenv</span>(</span>'REDISENT_HOST'</span>)
</span>    </span>PASSWORD </span>= </span>os.</span>getenv</span>(</span>'REDISENT_PWD'</span>)
</span>    </span>PORT </span>= </span>os.</span>getenv</span>(</span>'REDISENT_PORT'</span>)
</span>    </span>log</span>(</span>HOST</span>)
</span>    </span>log</span>(</span>PORT</span>)
</span>    </span>log</span>(</span>PASSWORD</span>)
</span>    redis_client</span>=</span>redis.</span>Redis</span>(</span>host</span>=</span>HOST</span>,</span>port</span>=</span>PORT</span>,</span>charset</span>=</span>"utf-8"</span>, </span>password</span>=</span>PASSWORD</span>)
</span>    </span>return </span>redis_client
</span>
</span>
</span>
</span>def </span>sync_sponsors</span>(</span>record</span>):
</span>    </span>global </span>rconn
</span>    </span>if not </span>rconn:
</span>        rconn</span>=</span>connecttoRedisEnterise</span>()
</span>
</span>    </span>log</span>(</span>str</span>(record[</span>'key'</span>]))
</span>    values</span>=</span>execute</span>(</span>'SMEMBERS'</span>,record[</span>'key'</span>])
</span>    </span>log</span>(</span>str</span>(values))
</span>    </span>for </span>each_value </span>in </span>values:    
</span>        rconn.</span>sadd</span>(record[</span>'key'</span>],each_value)
</span>
</span>gb </span>= </span>GB</span>(</span>'KeysReader'</span>)
</span>gb.</span>foreach</span>(sync_sponsors)
</span>gb.</span>count</span>()
</span>gb.</span>run</span>(</span>'user:*'</span>)
</span></code></pre>
But this one will sync all user's preferences, but we only need sponsors - let us add another feature of RedisGears - filter:</p>
rconn</span>=</span>None
</span>
</span>def </span>remove_prefix</span>(</span>text</span>, </span>prefix</span>):
</span>    </span>return </span>text[text.</span>startswith</span>(prefix) </span>and </span>len</span>(prefix):]
</span>
</span>def </span>connecttoRedisEnterise</span>():
</span>    </span>import </span>redis 
</span>    </span>import </span>os 
</span>    </span>log</span>(</span>str</span>(os.environ))
</span>    </span># Get environment variables
</span>
</span>    </span>HOST </span>= </span>os.</span>getenv</span>(</span>'REDISENT_HOST'</span>)
</span>    </span>PASSWORD </span>= </span>os.</span>getenv</span>(</span>'REDISENT_PWD'</span>)
</span>    </span>PORT </span>= </span>os.</span>getenv</span>(</span>'REDISENT_PORT'</span>)
</span>
</span>    redis_client</span>=</span>redis.</span>Redis</span>(</span>host</span>=</span>HOST</span>,</span>port</span>=</span>PORT</span>,</span>charset</span>=</span>"utf-8"</span>, </span>password</span>=</span>PASSWORD</span>, </span>decode_responses</span>=</span>True</span>)
</span>    </span>return </span>redis_client
</span>
</span>def </span>filter_sponsors</span>(</span>record</span>):
</span>    org_name</span>=</span>"applied-knowledge-systems"
</span>    user_id </span>= </span>remove_prefix</span>(record[</span>'key'</span>],</span>'user:'</span>)
</span>    sponsor</span>=</span>execute</span>(</span>'SISMEMBER'</span>,</span>f</span>'sponsors:</span>{org_name}</span>'</span>,user_id)
</span>    </span>return </span>bool</span>(sponsor</span>==</span>True</span>)
</span>
</span>def </span>sync_sponsors</span>(</span>record</span>):
</span>    </span>global </span>rconn
</span>    </span>if not </span>rconn:
</span>        rconn</span>=</span>connecttoRedisEnterise</span>()
</span>
</span>    </span>log</span>(</span>str</span>(record[</span>'key'</span>]))
</span>    values</span>=</span>execute</span>(</span>'SMEMBERS'</span>,record[</span>'key'</span>])
</span>    </span>log</span>(</span>str</span>(values))
</span>    </span>for </span>each_value </span>in </span>values:    
</span>        rconn.</span>sadd</span>(record[</span>'key'</span>],each_value)
</span>
</span>gb </span>= </span>GB</span>()
</span>gb.</span>filter</span>(filter_sponsors)
</span>gb.</span>foreach</span>(sync_sponsors)
</span>gb.</span>count</span>()
</span>gb.</span>run</span>(</span>'user:*'</span>)
</span></code></pre>
Fetch sponsor's preferences back to Redis OSS from Redis Enterprise</h2>
Then we are going to use Key miss events</a> from Redis Gears to fetch data for all users:</p>
flowchart LR
    redise(Redis Enterprise)
    redis_gears2(Redis Gears)--key miss--->redise
    redis_gears2-->redisOSS[Redis OSS]</div>
and it's very easy, right from key miss example:</p>

</span>def </span>fetch_data</span>(</span>r</span>):
</span>    key </span>= </span>r[</span>'key'</span>]
</span>    </span>global </span>rconn
</span>    </span>if not </span>rconn:
</span>        rconn</span>=</span>connecttoRedisEnterise</span>()
</span>    values</span>=</span>rconn.</span>smembers</span>(record[</span>'key'</span>])
</span>    </span>log</span>(</span>str</span>(values))
</span>    </span>for </span>each_value </span>in </span>values:    
</span>        </span>execute</span>(</span>'SADD'</span>,record[</span>'key'</span>],each_value)
</span>
</span>GB</span>().</span>foreach</span>(fetch_data).</span>register</span>(</span>prefix</span>=</span>'user:*'</span>, </span>commands</span>=</span>[</span>'smember'</span>],</span>eventTypes</span>=</span>[</span>'keymiss'</span>], </span>mode</span>=</span>"async_local"</span>)
</span></code></pre>
There is one more option - to turn fetch_data into the async call, by wrapping it into async/await, but Redis Enterprise is fairly fast, and I don't think it's worth adding an async call in this case. For curiosity, see the example code</a> in The Pattern repository.</p>
Conclusion</h1>
In this article, we walked through steps on how to create sponsor-specific "nanoservices" using RedisOSS, RedisGears and Redis Enterprise. This allows us to leverage the best of all worlds open source Redis, high availability and persistence with Redis Enterprise and RedisGears as the glue which holds everything together.</p>
This post is in collaboration with Redis.</p>
References</h1>


How to use GitHub Sponsors to help monetize your software</a></p>
</li>

Who sponsors this user?</a></p>
</li>

Check sponsors.go - query whether a GitHub user is your sponsor at a given tier (dollar amount)</a></p>
</li>

GitHub OAuth2 Gist</a> </p>
</li>

GraphQL explorer</a></p>
</li>
</ul>

Benchmarks for BERT Large Question Answering inference for RedisAI and RedisGears

Thu, 16 Jun 2022 00:00:00 +0000

Summary of the article</h2>
This article will explore the challenges and opportunities of deploying a large BERT Question Answering Transformer model(bert-large-uncased-whole-word-masking-finetuned-squad) from inside Huggingface, where RedisGears</a> and RedisAI</a> perform heavy lifting while leveraging in-memory datastore Redis.

Why do we need RedisAI?</h2>

In data science load, you want to load high-performance hardware as close to 100% as possible </li>
In user-facing load, you want to be able to distribute the load evenly, so it never reaches 100%, and client-facing servers can perform additional functions</li>
In data science, you prefer re-calculate results</li>
In a client-facing application, you prefer to cache results of calculation and fetch data from the cache as fast as possible to drive a seamless customer experience</li> </ul>
Some numbers for inspiration and why to read this article:
`python3 transformers_plain_bert_qa.py airborne transmission of respiratory infections is the lack of established methods for the detection of airborne respiratory microorganisms 10.351818372 seconds </code></pre>`
`time curl -i -H "Content-Type: application/json" -X POST -d '{"search":"Who performs viral transmission among adults"}' http://localhost:8080/qasearch real 0m0.747s user 0m0.004s sys 0m0.000s </code></pre>`
Background</h1>
BERT Question Answering inference works where the ML model selects an answer from the given text. In other words, BERT QA "thinks" through the following: "What is the answer from the text, assuming the answer to the question exists within the paragraph selected."
So it's important to select text potentially containing an answer. A typical pattern is to use Wikipedia data to build Open Domain Question Answering</a>.
Our QA system is a medical domain-specific question/answering pipeline, hence we need a first pipeline that turns data into a knowledge graph. This NLP pipeline is available at Redis LaunchPad, is fully open source</a>, and is described in a previous article</a>. Here is a 5 minute video</a> describing it, and below you will find an architectural overview:

BERT Question Answering pipeline and API</h1>
In the BERT QA pipeline (or in any other modern NLP inference task), there are two steps:

Tokenize text - turn text into numbers</li>
Run the inference - large matrix multiplication</li> </ol>
With Redis, we have the opportunity to pre-compute everything and store it in memory, but how do we do it? Unlike with the summarization ML learning task, the question is not known in advance, so we can't pre-compute all possible answers. However, we can pre-tokenize all potential answers (i.e. all paragraphs in the dataset) using RedisGears:
def parse_sentence(record): import redisAI import numpy as np global tokenizer if not tokenizer: tokenizer=loadTokeniser() hash_tag="{%s}" % hashtag() for idx, value in sorted(record['value'].items(), key=lambda item: int(item[0])): tokens = tokenizer.encode(value, add_special_tokens=False, max_length=511, truncation=True, return_tensors="np") tokens = np.append(tokens,tokenizer.sep_token_id).astype(np.int64) tensor=redisAI.createTensorFromBlob('INT64', tokens.shape, tokens.tobytes()) key_prefix='sentence:' sentence_key=remove_prefix(record['key'],key_prefix) token_key = f"tokenized:bert:qa:{sentence_key}:{idx}" redisAI.setTensorInKey(token_key, tensor) execute('SADD',f'processed_docs_stage3_tokenized{hash_tag}', token_key) </code></pre>
See the full code on GitHub</a>.
Then for each Redis Cluster shard, we pre-load the BERT QA model by downloading, exporting it into torchscript, then loading it into each shard:
def load_bert(): model_file = 'traced_bert_qa.pt' with open(model_file, 'rb') as f: model = f.read() startup_nodes = [{"host": "127.0.0.1", "port": "30001"}, {"host": "127.0.0.1", "port":"30002"}, {"host":"127.0.0.1", "port":"30003"}] cc = ClusterClient(startup_nodes = startup_nodes) hash_tags = cc.execute_command("RG.PYEXECUTE", "gb = GB('ShardsIDReader').map(lambda x:hashtag()).run()")[0] print(hash_tags) for hash_tag in hash_tags: print("Loading model bert-qa{%s}" %hash_tag.decode('utf-8')) cc.modelset('bert-qa{%s}' %hash_tag.decode('utf-8'), 'TORCH', 'CPU', model) print(cc.infoget('bert-qa{%s}' %hash_tag.decode('utf-8'))) </code></pre>
The full code is available on GitHub</a>.
And when a question comes from the user, we tokenize and append the question to the list of potential answers before running the RedisAI model:
token_key = f"tokenized:bert:qa:{sentence_key}" # encode question input_ids_question = tokenizer.encode(question, add_special_tokens=True, truncation=True, return_tensors="np") t=redisAI.getTensorFromKey(token_key) input_ids_context=to_np(t,np.int64) # merge (append) with potential answer, context - is pre-tokenized paragraph input_ids = np.append(input_ids_question,input_ids_context) attention_mask = np.array([[1]len(input_ids)]) input_idss=np.array([input_ids]) num_seg_a=input_ids_question.shape[1] num_seg_b=input_ids_context.shape[0] token_type_ids = np.array([0]num_seg_a + [1]*num_seg_b) # create actual model runner for RedisAI modelRunner = redisAI.createModelRunner(f'bert-qa{hash_tag}') # make sure all types are correct input_idss_ts=redisAI.createTensorFromBlob('INT64', input_idss.shape, input_idss.tobytes()) attention_mask_ts=redisAI.createTensorFromBlob('INT64', attention_mask.shape, attention_mask.tobytes()) token_type_ids_ts=redisAI.createTensorFromBlob('INT64', token_type_ids.shape, token_type_ids.tobytes()) redisAI.modelRunnerAddInput(modelRunner, 'input_ids', input_idss_ts) redisAI.modelRunnerAddInput(modelRunner, 'attention_mask', attention_mask_ts) redisAI.modelRunnerAddInput(modelRunner, 'token_type_ids', token_type_ids_ts) redisAI.modelRunnerAddOutput(modelRunner, 'answer_start_scores') redisAI.modelRunnerAddOutput(modelRunner, 'answer_end_scores') # run RedisAI model runner res = await redisAI.modelRunnerRunAsync(modelRunner) answer_start_scores=to_np(res[0],np.float32) answer_end_scores = to_np(res[1],np.float32) answer_start = np.argmax(answer_start_scores) answer_end = np.argmax(answer_end_scores) + 1 answer = tokenizer.convert_tokens_to_string(tokenizer.convert_ids_to_tokens(input_ids[answer_start:answer_end],skip_special_tokens = True)) log("Answer "+str(answer)) return answer </code></pre>
Checkout the full code, available on GitHub</a>.
The process for making a BERT QA API call looks like this:

Here I use two cool features of RedisGears: capturing events on key miss and using async/await to run RedisAI on each shard without locking the primary thread - so that Redis Cluster can continue to serve other customers. For benchmarks, caching responses from RedisAI is disabled</a>. If you are getting response times in nanoseconds on the second call rather then milliseconds, check to make sure the line linked above is commented out.
Running the Benchmark</h1>
Pre-requisites for running the benchmark:
Assuming you are running Debian or Ubuntu and have Docker and docker-compose installed (or can create a virtual environment via conda), run the following commands:
`git clone --recurse-submodules https://github.com/applied-knowledge-systems/the-pattern.git cd the-pattern ./bootstrap_benchmark.sh </code></pre> The above commands should end with a curl call to the qasearch API, since Redis caching is disabled for the benchmark. Next, invoke curl like this:`
`time curl -i -H "Content-Type: application/json" -X POST -d '{"search":"Who performs viral transmission among adults"}' http://localhost:8080/qasearch </code></pre> Expect the following output, or something similar based on your runtime environment:`
HTTP/1.1 200 OK Server: nginx/1.18.0 (Ubuntu) Date: Sun, 29 May 2022 12:05:39 GMT Content-Type: application/json Content-Length: 2120 Connection: keep-alive {"links":[{"created_at":"2002","rank":13,"source":"C0001486","target":"C0152083"}],"results":[{"answer":"adenovirus","sentence":"The medium of 40 T150 flasks of adenovirus transducer dec CAR CHO cells yielded 0 5 1 my of purified msCEACAM1a 1 4 protein","sentencekey":"sentence:PMC125375.xml:{mG}:202","title":"Crystal structure of murine sCEACAM1a[1,4]: a coronavirus receptor in the CEA family"}] OUTPUT_REDUCTED} </code></pre> I modified the output of API for the benchmark to return results from all shards - even if the answer is empty, in the run above five shards return answers, overall API call response under second with all additional hops to search in RedisGraph. I modified the output of the API for the benchmark to return results from all shards - even if the answer is empty. In the run above five shards return answers. The overall API call response takes less than one second with all additional hops to search in RedisGraph! 
Deep Dive into the Benchmark</h1>
Let's dig deeper into what's happening under the hood:
You should have a sentence key with shard id, which you get by looking at the "Cache key" from `docker logs -f rgcluster</code>. In my setup the cache key is, "bertqa{6fd}_PMC169038.xml:{6fd}:33_Who performs viral transmission among adults". If you think it looks like a function call it's because it is a function call. It is triggered if the key isn't present in the Redis Cluster, which for the benchmark will be every time since if you remember we disabled caching the output.`
`One more thing to figure out from the logs is the port of the shard corresponding to the hashtag, also known as the shard id</code>. It is the text found in betweeen the curly brackets – looks like {6fd}</code> above. The same will be in the output for the export_load</code> script. In my case the cache key was found in "30012.log", so my port is 30012.`
`Next I run the following command:`
`redis-cli -c -p 300012 -h 127.0.0.1 get "bertqa{6fd}_PMC169038.xml:{6fd}:33_Who performs viral transmission among adults" </code></pre> and then run the benchmark:`
redis-benchmark -p 30012 -h 127.0.0.1 -n 10 get "bertqa{6fd}_PMC169038.xml:{6fd}:33_Who performs viral transmission among adults" ====== get bertqa{6fd}_PMC169038.xml:{6fd}:33_Who performs viral transmission among adults ====== 10 requests completed in 0.04 seconds 50 parallel clients 3 bytes payload keep alive: 1 10.00% <= 41 milliseconds 100.00% <= 41 milliseconds 238.10 requests per second </code></pre> If you are wondering, -n</code> = number of times. In this case we run the benchmark 10 times. You can also add: – csv</code> if you want to output in CSV format – precision 3</code> if you want more decimals in the ms
`More information about the benchmarking tool can be found on the` `redis.io Benchmarks page</a>.`
`if you don't have redis-utils installed locally, you can use Docker as follows:`
docker exec -it rgcluster /bin/bash redis-benchmark -p 30012 -h 127.0.0.1 -n 10 get "bertqa{6fd}_PMC169038.xml:{6fd}:33_Who performs viral transmission among adults" ====== get bertqa{6fd}_PMC169038.xml:{6fd}:33_Who performs viral transmission among adults ====== 10 requests completed in 1.75 seconds 50 parallel clients 99 bytes payload keep alive: 1 host configuration "save": host configuration "appendonly": no multi-thread: no Latency by percentile distribution: 0.000% <= 243.711 milliseconds (cumulative count 1) 50.000% <= 987.135 milliseconds (cumulative count 5) 75.000% <= 1577.983 milliseconds (cumulative count 8) 87.500% <= 1662.975 milliseconds (cumulative count 9) 93.750% <= 1744.895 milliseconds (cumulative count 10) 100.000% <= 1744.895 milliseconds (cumulative count 10) Cumulative distribution of latencies: 0.000% <= 0.103 milliseconds (cumulative count 0) 10.000% <= 244.223 milliseconds (cumulative count 1) 20.000% <= 409.343 milliseconds (cumulative count 2) 30.000% <= 575.487 milliseconds (cumulative count 3) 40.000% <= 821.247 milliseconds (cumulative count 4) 50.000% <= 987.135 milliseconds (cumulative count 5) 60.000% <= 1157.119 milliseconds (cumulative count 6) 70.000% <= 1497.087 milliseconds (cumulative count 7) 80.000% <= 1577.983 milliseconds (cumulative count 8) 90.000% <= 1662.975 milliseconds (cumulative count 9) 100.000% <= 1744.895 milliseconds (cumulative count 10) Summary: throughput summary: 5.73 requests per second latency summary (msec): avg min p50 p95 p99 max 1067.296 243.584 987.135 1744.895 1744.895 1744.895 </code></pre> The platform only has 20 articles and 8 Redis nodes (4 masters + 4 slaves), so relevance would be wrong and it doesn't need a lot of memory. AI.INFO</h2> Now let's check how long our RedisAI model runs on the {6fd}</code> shard: 127.0.0.1:30012> AI.INFO bert-qa{6fd} 1) "key" 2) "bert-qa{6fd}" 3) "type" 4) "MODEL" 5) "backend" 6) "TORCH" 7) "device" 8) "CPU" 9) "tag" 10) "" 11) "duration" 12) (integer) 8928136 13) "samples" 14) (integer) 58 15) "calls" 16) (integer) 58 17) "errors" 18) (integer) 0 </code></pre> bert-qa{6fd}</code> is the key of the actual (very large) model saved. The AI.INFO</code> command gives us a cumulative duration of 8928136 microseconds and 58 calls, which is approximately 153 milliseconds per call. Let's double-check to make sure that's right by resetting the stats and then re-runnning the benchmark. First, reset the stats: 127.0.0.1:30012> AI.INFO bert-qa{6fd} RESETSTAT OK 127.0.0.1:30012> AI.INFO bert-qa{6fd} 1) "key" 2) "bert-qa{6fd}" 3) "type" 4) "MODEL" 5) "backend" 6) "TORCH" 7) "device" 8) "CPU" 9) "tag" 10) "" 11) "duration" 12) (integer) 0 13) "samples" 14) (integer) 0 15) "calls" 16) (integer) 0 17) "errors" 18) (integer) 0 </code></pre> Then, re-run the benchmark: redis-benchmark -p 30012 -h 127.0.0.1 -n 10 get "bertqa{6fd}_PMC169038.xml:{6fd}:33_Who performs viral transmission among adults" ====== get bertqa{6fd}_PMC169038.xml:{6fd}:33_Who performs viral transmission among adults ====== 10 requests completed in 1.78 seconds 50 parallel clients 99 bytes payload keep alive: 1 host configuration "save": host configuration "appendonly": no multi-thread: no Latency by percentile distribution: 0.000% <= 188.927 milliseconds (cumulative count 1) 50.000% <= 995.839 milliseconds (cumulative count 5) 75.000% <= 1606.655 milliseconds (cumulative count 8) 87.500% <= 1692.671 milliseconds (cumulative count 9) 93.750% <= 1779.711 milliseconds (cumulative count 10) 100.000% <= 1779.711 milliseconds (cumulative count 10) Cumulative distribution of latencies: 0.000% <= 0.103 milliseconds (cumulative count 0) 10.000% <= 189.183 milliseconds (cumulative count 1) 20.000% <= 392.191 milliseconds (cumulative count 2) 30.000% <= 540.159 milliseconds (cumulative count 3) 40.000% <= 896.511 milliseconds (cumulative count 4) 50.000% <= 996.351 milliseconds (cumulative count 5) 60.000% <= 1260.543 milliseconds (cumulative count 6) 70.000% <= 1456.127 milliseconds (cumulative count 7) 80.000% <= 1606.655 milliseconds (cumulative count 8) 90.000% <= 1692.671 milliseconds (cumulative count 9) 100.000% <= 1779.711 milliseconds (cumulative count 10) Summary: throughput summary: 5.62 requests per second latency summary (msec): avg min p50 p95 p99 max 1080.454 188.800 995.839 1779.711 1779.711 1779.711 </code></pre> Now check the stats again: AI.INFO bert-qa{6fd} 1) "key" 2) "bert-qa{6fd}" 3) "type" 4) "MODEL" 5) "backend" 6) "TORCH" 7) "device" 8) "CPU" 9) "tag" 10) "" 11) "duration" 12) (integer) 1767749 13) "samples" 14) (integer) 20 15) "calls" 16) (integer) 20 17) "errors" 18) (integer) 0 </code></pre> Now we get 88387.45 microseconds per call ~0.088387 seconds, which is pretty fast! Also, considering we started with 10 seconds per call, I think the benefits of using RedisAI in combination with RedisGears are pretty obvious. However, the trade-off is high memory usage. There are many ways to optimize this deployment. For example, you can add a FP16 quantization and ONNX runtime. If you would like to try that, this script</a> will be a good starting point. Using Grafana to monitor RedisGears throughput, CPU, and Memory usage</h1> Thanks to the contribution of Mikhail Volkov</a>, we can now observe RedisGears and RedisGraph throughput and memory consumption using Grafana. When you cloned repository it started Graphana Docker, which has pre-build templates to monitor RedisCluster, including RedisGears and RedisAI, and Graph - which is Redis with RedisGraph. "The Pattern" dashboard provides an overview, with all the key benchmark metrics you care about: This post is in collaboration with Redis.

Building a Pipeline for Natural Language Processing using RedisGears

Sat, 28 May 2022 00:00:00 +0000

Goal</h2>
Disclaimer originally published in collaboration with Ajeet Raina</a> on Developer.Redis.Com</a>
In this tutorial, you will learn how to build a pipeline for Natural Language Processing(NLP) using RedisGears</a>. For this demonstration, we will be leveraging the Kaggle CORD19 datasets. The implementation is designed to avoid running out of memory, leveraging Redis Cluster and RedisGears, where the use of RedisGears allows for processing data on storage without the need to move data in and out of the Redis Cluster—using Redis Cluster as data fabric. Redis Cluster allows for horizontal scalability up to 1000 nodes, and together with RedisGears, provides a distributed system where data science/ML engineers can focus on processing steps, without the worry of writing tons of scaffoldings for distributed calculations.

This project was built with the aim to make it easier for other people to contribute and build better information and knowledge management products.

Why data scientists uses RedisGears?</h2>
RedisGears</a> have enormous potential, particularly for text processing—you can process your data “on data” without needing to move them in and out of memory. Summary of the important points: 

In Memory storage (Horizontally scalable if it’s Redis cluster)</li>
Processing of data (on data) without need to move in and out</li>
Gears - like Spark on Hadoop, process data intelligently on storage(in-memory) without need to move data in and out</li>
Redis in cluster mode with RedisGears and python enabled takes 20 MB RAM. Think how much more data you can shuffle into your laptop or server.</li> </ul>
What is a knowledge graph?</h2>
Today, we live in the world of new systems that operate not just files, folders, or web pages, but entities with their properties and relationships between them, organized into hierarchies of classes and categories. These systems are used everywhere from the military-industrial complex to our everyday lives. Palantir, Primer, and other data companies enable massive intelligence and counterintelligence projects in military and security forces, Quid and RecordedFuture enable competitive analytics, Bottlenose and similar enterprises enable online reputation analytics. Microsoft Graph enables new kinds of productivity apps for the enterprises, Google Knowledge Graph and Microsoft’s Satori enable everyday search queries, and together with Amazon Information Graph they power corresponding AI assistants by enabling them to answer questions about the world facts
All these (and many other more specialized) systems are used in different domains, but all of them use Knowledge Graphs as their foundation.
Knowledge graphs are one of the best ways to connect and make sense out of information from different data sources, following the motto of one of the vendors— “It’s about things not strings”</a>. 
Knowledge Graph consists of thesaurus, taxonomy and ontology. In this pipeline I assume knowledge is captured in medical metathesaurus UMLS</a> and concepts in text are related if they are part of the same sentence, therefore concept become node, their relationship becomes edge:

Concepts have CUI (Concept Unique Identifiers) and those will be primary keys in nodes, linked to UMLS thesaurus. For example, if you search, “How does temperature and humidity affect the transmission of 2019-nCoV?” on the demo website http://thepattern.digital/</a> and move slider to 1996, there is an edge-connecting transmission (C5190195) and birth (C5195639) and the part of sentence matched, “the rate of transmission to an infant born to,” from the report titled, “Afebrile Pneumonia in infants.”

RedisGears for NLP pre-processing</h2>
Overall Architecture Overview (Components Diagram)</h3>

Intake step - is very simple put all JSON records into RedisCluster, then NLP pipeline starts processing all records, code is here</a>.
How does the NLP pipeline steps fit into RedisGears?</h3>

For each record — detect language (discard non English), it’s filter</a> </li>

Map paragraphs into a sentence — flatmap</a> </li>

Sentences spellchecker — it’s map</a> </li>

Save sentences into hash — processor</a> </li> </ol>
Step 1. Pre-requisite</h3>
Ensure that you install virtualenv in your system
Step 2. Clone the repository</h3>
git clone --recurse-submodules https://github.com/applied-knowledge-systems/the-pattern.git cd the-pattern </code></pre>
Step 3. Bring up the application</h3>
docker-compose -f docker-compose.dev.yml up --build -d </code></pre>
Step 4. Apply cluster configuration settings</h3>
You can deploy PyTorch and spacy to run on RedisGears.
bash post_start_dev.sh </code></pre> For Data science-focused deployment, RedisCluster should be in HA mode with at least one slave for each master. One need to change a few default parameters for rgcluster to accommodate the size of PyTorch and spacy libraries (each over 1GB zipped), gist with settings.
Step 5. Create or activate Python virtual environment</h3> cd ./the-pattern-platform/ </code></pre> Step 6. Create new environment</h3> You can create it via conda create -n pattern_env python=3.8 </code></pre> or Alternatively, you can activate by using the below CLI: source ~/venv_cord19/bin/activate #or create new venv pip install -r requirements.txt </code></pre> Step 7. Run pipeline</h3> bash cluster_pipeline.sh </code></pre> Step 8. Validating the functionality of the NLP pipeline</h3> Wait for a bit and then check: Verifying Redis Graph populated:</h3> redis-cli -p 9001 -h 127.0.0.1 GRAPH.QUERY cord19medical "MATCH (n:entity) RETURN count(n) as entity_count" redis-cli -p 9001 -h 127.0.0.1 GRAPH.QUERY cord19medical "MATCH (e:entity)-[r]->(t:entity) RETURN count(r) as edge_count" </code></pre> Checking API responds:</h3> curl -i -H "Content-Type: application/json" -X POST -d '{"search":"How does temperature and humidity affect the transmission of 2019-nCoV"}' http://localhost:8080/gsearch </code></pre> Walkthrough</h2> While RedisGears allows to deploy and run Machine Learning libraries like spacy</a> and BERT transformers</a>, the solution above uses simpler approach: gb = GB('KeysReader') gb.filter(filter_language) gb.flatmap(parse_paragraphs) gb.map(spellcheck_sentences) gb.foreach(save_sentences) gb.count() gb.register('paragraphs:*',keyTypes=['string','hash'], mode="async_local") </code></pre> This is the overall pipeline: those 7 lines allow you to run logic in a distributed cluster or on a single machine using all available CPUs - no changes required until you need to scale over more 1000 nodes. I use KeysReader registered for namespace paragraphs for all strings or hashes. My pipeline would need to run in async mode. For data scientists, I would recommend using gb.run to make sure gears function work and it will run in batch mode and then change it to register - to capture new data. By default, functions will return output, hence the need for count() - to prevent fetching the whole dataset back to the command issuing machine (90 GB for Cord19). Overall pre-processing is a straightforward - full code</a> is here. Things to keep in mind: Node process can only save locally - we don't move data, anything you want to save should have hashtag, for example to add to the set of processed_docs:</li> </ol> execute('SADD','processed_docs_{%s}' % hashtag(),article_id) </code></pre> Loading external libraries into the computational threat, for example, symspell requires additional dictionaries and needs two steps to load:</li> </ol> """ load symspell and relevant dictionaries """ sym_spell=None def load_symspell(): import pkg_resources from symspellpy import SymSpell, Verbosity sym_spell = SymSpell(max_dictionary_edit_distance=1, prefix_length=7) dictionary_path = pkg_resources.resource_filename( "symspellpy", "frequency_dictionary_en_82_765.txt") bigram_path = pkg_resources.resource_filename( "symspellpy", "frequency_bigramdictionary_en_243_342.txt") # term_index is the column of the term and count_index is the # column of the term frequency sym_spell.load_dictionary(dictionary_path, term_index=0, count_index=1) sym_spell.load_bigram_dictionary(bigram_path, term_index=0, count_index=2) return sym_spell </code></pre> Scispacy is a great library and data science tool, but after a few iterations with deploying it I ended up reading data model documentation for UMLS Methathesaurus and decided to build Aho-Corasick automata directly from UMLS data. (MRXW_ENG.RRF contains all terms form for English mapped to CUI). Aho-Corasick allowed me to match incoming sentences into pairs of nodes (concepts from the medical dictionary) and present sentences as edges in a graph, Gears related code is simple:</li> </ol> bg = GearsBuilder('KeysReader') bg.foreach(process_item) bg.count() bg.register('sentence:*', mode="async_local",onRegistered=OnRegisteredAutomata) </code></pre> OnRegisteredAutomata will perform similarly to symspell example above except it will download pre-build Aho-Corasick automata (30Mb). Aho-Corasick is a very fast matcher and allows to perform >900 Mb text per second even on commodity laptop, RedisGears cluster makes a very smooth distribution of data and ML model and matching using available CPU and Memory. Full matcher code</a>. Output of the matcher: nodes and edges are candidates to use another RedisGears pattern rgsync where you can write fast into Redis and RedisGears are going to replicate data into slower storage using RedisStreams. But I decided to use streams and handcraft the population of the RedisGraph database, which will be focus of the next blog post. Output of the matcher: nodes and edges are candidates to use another RedisGears pattern rgsync</a> where you can write fast into Redis and RedisGears are going to replicate data into slower storage using RedisStreams, while this demo uses streams and populates RedisGraph database with nodes and edges calculating rank of each. Call to action</h2> We took OCR scans in JSON format and turned them into Knowledge Graph, demonstrating how you can traditional Semantic Network/OWL/Methathesaurus technique based on Unified Medical Language System. Redis Ecosystem offers a lot to the data science community, and can take place at the core of Kaggle notebooks, ML frameworks and make deployment and distribution of data more enjoyable. The success of our industry depends on how our tools work together — regardless of whether they are engineering, data science, machine learning and organisational or architectural. With the collaboration of RedisLabs and community, the full pipeline code is available via https://github.com/applied-knowledge-systems/the-pattern-platform. In case, you want to try it locally, then you can find a Docker Launch script in the root of the repository along with short quickstart guide. PR and suggestions are welcome. The overall goal of the project is to allow other to build their more interesting pipeline on top of it. References</h3> Covid19 - Redis Knowledge Graph in 3D</a></li> COVID-19 Open Research Dataset Challenge (CORD-19)</a></li> Source Code for NLP pipeline based on RedisGears </a></li> </ul>

Synchronize Redis OSS to Redis Enterprise using RedisGears</h1>

Overall Architecture Overview (Components Diagram)</h3>
</p>
Intake step - is very simple put all JSON records into RedisCluster, then NLP pipeline starts processing all records, code is here</a>.</p>

Step 8. Validating the functionality of the NLP pipeline</h3>
Wait for a bit and then check:</p>

References</h3>

Covid19 - Redis Knowledge Graph in 3D</a></li>
COVID-19 Open Research Dataset Challenge (CORD-19)</a></li>
Source Code for NLP pipeline based on RedisGears </a></li> </ul>

Community</h1>
Join our community on Discord</a> or post on GitHub Discussions</a>](https://github.com/applied-knowledge-systems/the-pattern/discussions)</p>

Donate</h1>

</a></li>
</a></li>
</a></li> </ul>

Ingest documents</h1>
Example script</a> parses documents taking out body_text and saves under paragraphs in Redis cluster.</p>

Applied Knowledge Systems Ltd

Turning Open Source project into Product with Redis Enterprise

Turning Open Source project into Product with Redis Enterprise</h1>

Overview</h1>

Background</h1>

Benchmarks for BERT Large Question Answering inference for RedisAI and RedisGears

Announcing Reference Architecture for AI

Building a Pipeline for Natural Language Processing using RedisGears

Metadata Management

Contribution Guidelines

The Pattern: Machine Learning Natural Language Processing meets VR/AR

Support project by contributing

For Individuals</h1>
This is a begging of an exciting, incredible new journey; support open source projects by donating or contributing.</p>

Data Acquisition

Extended Shortcodes

Applied Knowledge Systems Ltd

Turning Open Source project into Product with Redis Enterprise

Turning Open Source project into Product with Redis Enterprise</h1>

Overview</h1>

Background</h1>

Synchronize Redis OSS to Redis Enterprise using RedisGears</h1>

Synchronize all user preferences</h2> First flow: We will be using RedisGears to synchronize all preferences with Redis Enterprise</p>

Benchmarks for BERT Large Question Answering inference for RedisAI and RedisGears

Background</h1> BERT Question Answering inference works where the ML model selects an answer from the given text. In other words, BERT QA "thinks" through the following: "What is the answer from the text, assuming the answer to the question exists within the paragraph selected."</p>

BERT Question Answering pipeline and API</h1> In the BERT QA pipeline (or in any other modern NLP inference task), there are two steps:</p> Tokenize text - turn text into numbers</li>

AI.INFO</h2> Now let's check how long our RedisAI model runs on the {6fd}</code> shard:</p>

Announcing Reference Architecture for AI

Building a Pipeline for Natural Language Processing using RedisGears

Overall Architecture Overview (Components Diagram)</h3> </p>

Step 3. Bring up the application</h3> </span>docker-compose -f</span> docker-compose.dev.yml up</span> --build -d </span></code></pre> Step 4. Apply cluster configuration settings</h3> You can deploy PyTorch and spacy to run on RedisGears.</p>

Step 4. Apply cluster configuration settings</h3> You can deploy PyTorch and spacy to run on RedisGears.</p>

Step 8. Validating the functionality of the NLP pipeline</h3> Wait for a bit and then check:</p>

Metadata Management

Contribution Guidelines

The Pattern: Machine Learning Natural Language Processing meets VR/AR

Support project by contributing

For Individuals</h1> This is a begging of an exciting, incredible new journey; support open source projects by donating or contributing.</p>

For Organisations</h1> Becomes a sponsor and promote Reference Architecture for AI.</p> The ask is </p>

Data Acquisition

Extended Shortcodes

Overall Architecture Overview (Components Diagram)</h3>
</p>
Intake step - is very simple put all JSON records into RedisCluster, then NLP pipeline starts processing all records, code is here</a>.</p>

Step 8. Validating the functionality of the NLP pipeline</h3>
Wait for a bit and then check:</p>

For Individuals</h1>
This is a begging of an exciting, incredible new journey; support open source projects by donating or contributing.</p>