What is Neural Microservices (™)?

Neural Microservices (™) are like semantic search on steroids. They are contextual AI-driven services that can search vast quantities of data and provide the answers you need without you having to ask the exact question in a rigid, structured format that today’s computers require.

As computing power continues to increase beyond our comprehension and AI systems are embedded in all systems around us, AI is becoming the interface between how we express our needs and desires and how computers process that information to provide us with the contextual answers we seek.

Neural Microservices (™) use the power of AI iterative Models to search and refine the required query and attempts to surface an appropriate answer that may not have been obvious at first.

Diagram courtesy of QuantaMagazine

As an example, we are working on a service called Article Neural Micro Service (ANMS). You give the parameters such as number of pages, grammar voice, language complexity, target audience and article style and then specify your query and possible data sources to search and reference. The ANMS will then start searching using initial keywords and assumptions and then refine the answer using iterative models to summarize key points and structure the results in the format requested.

Here is a typical deep question to ask our ANMS bot:

“How long have humans been on Earth, in the form we understand as Hominids but using tools and language and considering factors such as Earth events like ice ages and population density and growth and possible distances travelled or migration routes. Start by using the documented records from the period 1270 b.c.e where the Egyptians and the Hittites fought in the battle of Kadesh with approximately 70,000 soldiers. From this data extrapolate how many generation it would take to stand such an army based on the average age of a soldier and take into consideration the environmental factors queried above that may have influenced population growth. Furthermore refine the answer from generations required to possible years using ballpark figures. Go do it”

This may seem a daunting complex question but to a computing device it is simply a set of queries that can be searched. The difference between yesterday and tomorrow in terms of computing power is the ability to contextualize the answer by iterative models where the question and answer is continually evaluated against known acceptable answers. What an age we live in!

The model could start with the following to get a ball park answer. It could make some assumptions as variables to start:

Average Lifespan = 1 to 100
Family size = 1 to 10
Sex = male to female split
Male = family size times percentage of strong males. So 20% strong up to 60% strong
Weather conditions = 10% (fair) to 90% (harsh)
Abundance = 10% (difficult) to 90% (easy)
Natural disasters = 10% (fair) 80% bad)
Longevity = family size times weather conditions times abundance times disasters

From here it could do initial calculations and spit out an answer in “whiteboard” speak to make iterative changes:

1. Calculate the male factor:
   maleFactor = malePercentage * 0.01 * familySize
2. Calculate the longevity:
   longevity = averageLifespan * familySize * weatherConditions * 0.01 * abundance * 0.01 * disasters * 0.01
   longevity = longevity * maleFactor
3. Calculate the size of each generation:
   generationSize = longevity * familySize
4. Calculate the number of generations required to get back to generation 0:
   generations = initialPopulation / generationSize
5. Calculate the number of years required to get back to generation 0:
   years = generations * averageLifespan
6. Return the result:
   return years

Or in computer speak:

function calculateLongevity(averageLifespan, familySize, malePercentage, weatherConditions, abundance, disasters) {
maleFactor = malePercentage * 0.01 * familySize
longevity = averageLifespan * familySize * weatherConditions * 0.01 * abundance * 0.01 * disasters * 0.01
longevity = longevity * maleFactor
return longevity
}

Or:

function calculateGenerations(averageLifespan, familySize, malePercentage, weatherConditions, abundance, disasters, initialPopulation) {
maleFactor = malePercentage * 0.01 * familySize
longevity = averageLifespan * familySize * weatherConditions * 0.01 * abundance * 0.01 * disasters * 0.01
longevity = longevity * maleFactor
generationSize = longevity * familySize
generations = initialPopulation / generationSize
years = generations * averageLifespan
return years
}

Next the variables can be altered to suit the question better:

averageLifespan = 30
familySize = 5
malePercentage = 100 (assumes all members of the army are male)
weatherConditions = 50 (fair)
abundance = 50 (average)
disasters = 50 (average)
initialPopulation = 10,000

The first answer back could be:

1. Calculate the male factor:
   maleFactor = 100 * 0.01 * 5 = 5
2. Calculate the longevity:
   longevity = 30 * 5 * 50 * 0.01 * 50 * 0.01 * 50 * 0.01 * 5
   longevity = 30 * 0.125 * 5 = 22.5
3. Calculate the size of each generation:
   generationSize = 22.5 * 5 = 112.5
4. Calculate the number of generations required to get back to generation 0:
   generations = 10,000 / 112.5 = 89.28
5. Calculate the number of years required to get back to generation 0:
   years = 89.28 * 30 = 2678.4

So the initial answer is 2678 years or 89 generations.

If we increase the army to 70,000 as documented and as a sanity check ask Google’s Bard for the answer this is what we get:

Python
average_lifespan = 30
family_size = 5
male_fertility_rate = 0.5
weather_conditions_factor = 0.9
abundance_factor = 0.8
disasters_factor = 0.9
initial_population = 70000

male_factor = male_fertility_rate * 0.01 * family_size
longevity = average_lifespan * family_size * weather_conditions_factor * 0.01 * abundance_factor * 0.01 * disasters_factor * 0.01 * male_factor
generation_size = longevity * family_size
generations = initial_population / generation_size
years = generations * average_lifespan

print(generations)
print(years)

And Bards answer is:

Sure. If we increase the army to 70,000 warriors, then it would take 3005.56 generations and 90,166.8 years to get back to generation 0, given the same assumptions as in your previous calculation.

Now ANMS can start searching using environmental variables such as the ice age that ended around 25,000 years abo but started a 100,000 years ago so the generations needed will be in the ice age. Surely that will slow down any hominid!

The point is that this is a pyramid problem. As you extrapolate one set of answers your are presented with more questions and as humans we may get overwhelmed but for an AI based on Neural Micro Services (™) it simply digs deeper.

So to simplify, what is our Neural Micro Services (™)? It is the human contextual interface driven by descriptive and explorative language as the primary input with the output being what was requested or a continuous stream of “informational nuggets” as they are uncovered.