July the 9th 2020
Summer is here and so is vacation season in Finland. Things haven't slowed down quite yet, but July is the traditional off-season for more or less all of Finland, including Aito. Let's see what we're going to be up to during this month. Here's, however, what we've been up to in June.
- There's been several bug fix releases during June and early July, with a bunch of mostly minor or almost insignificant bugs fixed.
- Renaming and moving tables is now possible (since v2020-06-03.1562). Check out https://aito.ai/docs/api for details
- We've further improved the performance. It's most significant for small samples of hundreds to a few thousands of data points, or very large ones with >1M data points. The middle ground, well, it works more or less just as before (as of v2020-06-29.1618)
- Write speeds have also been improved slightly. This is best visible when running the file uploads. (as of v2020-06-29.1618)
- There was a nasty stackoverflow-bug, which occured if there were huge
$or-propositions. It occurred with thousands of items in one
$or, but can happen with programmatic built queries. (as of v2020-06-29.1618)
- We had a type conversion bug, which prevented integers to be accepted as decimals. Not very (artificially) intelligent. This regression had been fixed, but we now upped our test sets to run these as part of the normal suite as well. (as of v2020-06-29.1618)
- The python tools are getting their own release 0.3.0 as well. It's currently in RC-phase. In order to keep friends closer, we've decided to automate the release notes for the tools here. The detailed docs can be found in readthedocs.io. Please stay tuned for the final release.
- A long-pending issue, which has been swept aside so far, has been the lack of encryption-at-rest for the data. No it has been fixed! And not only that, bu at the same time performance has improved quite significantly! This feat has been achieved by some serious work on the infrastructure for the past few months. Rollout happens within the next few weeks, and one environment at a time. The change should be fully transparent to the users, besides the improved write- and query-speeds. A larger blog-post is coming up about the details, but first the slow rollout, to catch any surprises with it. It's been running for a while now in test, but prod is prod, as we all know.
May 25th 2020
Larger pieces of work on pricing, tiers, and payments has kept and is still going to keep us busy, in a good way.
- The query format has been tweaked to be more terse. Aito Query now supports multiple propositions in an object clause and combines these propositions using the
- Table name validation was improved. For some reason we’ve blundered and removed the original table name validation. It led to situations where it was way too easy to create an invalid schema. This has now been fixed. You can't use special chars like
/".$ in the table names.
- Aito used to delete zero-frequency features in linked tables. Even if it sounds useful, it actually had a negative effect when using match or recommend. This is fixed.
- Aito needs to manage a lot of resources in order to be able to provide immediate predictions. Managing those can also become complex, but we’ve improved the garbage collection and delete performance significantly. You can now add even more tables in an Aito schema. How many, you ask? Well, a lot, since we tried it with hundreds and it just works.
- There were some “interesting” issues with environment setup. A crashing instance might, as a result of a number of race-conditions, never come back online. This has hopefully been fixed now.
- We’re going to change the domains of all (new) environments. We’ve been preparing this for a while, but now it’s time! All is visible in Console, so no need to memorise. We’re rolling this out in phases, so starting this week
- all instances will now primarily reside under the
- new instances are created (only) in
- old environments will still keep the old
api.aito.ai address as an alias, so no immediate changes are needed in your code
- The console has received lots of love, bug fixes and improvements related to the sandbox-changes.
CLI, SDK, Integrations
- Python SDK has been updated to version 0.2.1. Remember, just
pip install aitoai and you have all the goodness!
upload_entries function now accepts generators as well as lists to feed in new entries to Aito database.
upload_entries_by_batches has been deprecated. The same functionality is available in the
upload_entries function, which lets your define the batch size, with a default of 1000 entries.
- Improvements of error messages and handling here and there.
There is a robot, too
- Working with our customers Robotic Process Automation teams, we felt that we need to try these RPA platforms ourself, too. And who would not want to have a robot! Name-to-be-decided, so if you have a good suggestion, let us know. Anyway, the robot is now the main responsible for setting up new customer instances. When you request an instance in the console, robot goes to work. You should blame it if something goes wrong. :) We made it with Qentinel Pace, that is based on Robot Framework open source automation framework. We also joined the Robot Framework Foundation recently to give it our support.
May the 4th Be With You (2020)
The long-pending pricing and instance tiers update is finally live. Phew! I can reveal that there were a few things to change, also outside the pricing-page on the website. ;)
- A lot of work was put in on the infrastructure to make the new pricing tiers possible. Please head over to the console to check it out. Please also report any bugs you find directly to us. We’ve put in some long hours to make things work under all circumstances, but I’m sure there are still issues lurking in there somewhere.
- Fixed a bug, which under certain circumstances could lead to live-lock. We are ashamed to say that we probably added some extra CO2 to the atmosphere, while debugging the issue and all CPUs being red hot, but now it’s been squashed.
- We made major query performance improvements via smarter sampling, extra caches and numerous algorithmic optimizations. Most queries are now as fast or faster than they were before concept learning. There was also a database loading speed improvement that reduced the post-write latency and made the evaluate queries faster. One tested evaluate-query took now 5 seconds instead of the old 25 seconds.
- There have been major improvements in the exclusive predicting accuracy and probability-correctness as the exclusiveness assumption is now more strongly taken into account in mathematics. As a consequence: Aito now often provides not just faster, but also significantly better predictions.
April 14th 2020
After a really busy few sprints we took a short breath to fix some of the bugs we’ve introduced in the rush. Fortunately most of them were caught internally, so not many of you have hopefully been affected. New work is, of course, ongoing as well, but more about that later!
- There were some issues with the getting started page, when fetching the API-keys to be able to execute the functionality. This has now been fixed and optimised, so it should be less of an issue.
CLI, SDK, Integrations
- The Python SDK got some proper love and care: we’ve fixed bugs and improved the documentation. We are improving the docs all the time, but would love to hear feedback from you. Also, if there are things that need clarification, we’d be happy to fix it or add it to the docs.
- The funding demo that we've created to demonstrate some of the advanced Aito features has been improved, so the evaluations now reflect the situation with Concept learning in place. The explanations now take into account combined concepts manifested by different features.
March 27th 2020
Busy weeks. So busy, in fact, that the release notes seemed to have gone MIA. But here they are, a bit late.
- Get-started in Console has received some more TLC. Bugs have been squashed, and the overall flow is improved. Hopefully for you as well, as these were some quite tricky ones related to synchronising things.
- Concept learning is by now rolled out to all customer environments. There are a few exceptions to this, since we’re investigating the situation with certain sets of data type and volume. You know if you’re among this selected group, so a non-issue for anyone else.
- EvaluatePredict now accepts the ‘$on’-proposition. Lack of this easily caused confusion between test- and train-sets of data, leading to wrong results. This has now been added.
- Error messages for jobs have been improved. Previously the asynchronous nature caused some ugly warts in the form of server errors. Warts mostly removed now.
- Propositions didn’t have adequate validation for existing/missing field names, leading to ugly error messages, or worse, bad results due to zero occurrence of such a feature. These warts have also received some attention.
- Validation has also been improved for the internal type casting. It should no longer be as easy to make the error of comparing apples to oranges, or indeed even airplanes.
- We released our first demonstration of how to use Aito within UiPath. This demonstrates some new avenues of use, as you can do the “external integration” to some third party system without having to change those nasty legacy systems to integrate directly with Aito. This is one example only, so although the activity is available for UIpath, the way it works could be replicated anywhere.
March 16th 2020
As most other companies in this domain, the ongoing pandemic made us switch to working mostly from home within the last sprint. It’s been an interesting experiment, as having e-meetings with 11 people, everyone at a different location, takes some getting used to. On the other hand, it’s easier to focus on individual tasks, while being able to mute every possible channel. Please stay safe and remember to wash your hands.
Here is all the goodness from our latest sprint.
- The usage-stats in Console were broken. The immediate issue was fixed, but the gathering of stats still needs some bigger overhaul. This will be rolled out with regular updates. If you’re seeing inconsistencies, please let us know. Don’t worry, we know what’s going on in your environment, even if we’re failing to show the right figures on the console.
- We added the “Get started”-section to the console. It’s like our earlier “Upload CSV”, injected with some serious steroids. Now you can upload a CSV of your choice, and Aito will not only create the table for you, but also show you an initial Predict-query you can start playing with. Please try it out and let us know what you think, or (knock on wood) should you find a bug there.
Console goes getting started
- The work on Concept Learning has been finished. We are rolling out the changes within a week (starting on Monday the 23rd of March). This really does put the second I in Aito.ai, as Aito will now group features into higher-level concepts. This will improve accuracy, performance, as well as make the explanations better. This will introduce some breaking changes, so please check out our migration guide and "why this matters" blog post. The migration guide is for you if you’re using _relate endpoiint or relying on $why in the response.
- The file upload used to show timeouts when asking for the status. This was a problem with the scheduling of the status call and has now been fixed.
- String- and Text-fields in the API were similar but not the same. We’ve changed them to behave in a consistent way. They will eventually be merged, but now both work and can be considered synonyms.
March 3rd 2020
This one combines two sprints of new stuff. During the time we had a few hours maintenance break, as there were some significant improvements to our networking infra allowing us to grow faster.
Here is all the goodness.
- The biggest single thing we’ve been working on is the quick CSV upload straight from the console UI. The feature allows you to get started with Aito by dragging-and-dropping almost any CSV to your environment. The schema is inferred (using the Aito SDK!), which will give you a fast start at exploring the interesting bits, namely the different queries and results. Point your eyes in the bottom right corner of the screenshot below.
Console dragndrop screenshot
CLI, SDK, Integrations
As a reminder, you can perform various tasks in Aito using the Python SDK (and some with CLI). Data upload, querying, running jobs, you name it. All of this is implemented in Python, and it’s open source’d so you can both see what’s under the hood as well as contribute. Some changes here.
- We fixed a bug when converting or uploading a file in Windows due to tempfile permissions
- Mac OSX ODBC driver instructions updated for building your database with an SQL query. SDW now works with Postgres. MySQL not supported yet.
- We added and tested the compatibility with Python 3.7 and 3.8.
- We did a big overhaul of the networking infrastructure. We were uncomfortably close to some AWS limitations, and the changes were needed to give us more flexibility for the future.
- The keenest of the readers might have noticed the small changed address at the bottom of the page. Yes, we have moved to a new office! The address change on the website was easy, while the physical change of address took a bit more effort. But now it’s done, and arriving by train is even easier than before. We’re just some 15 meters away from the Helsinki central railway station!
- We added a new Showcases page. The motivation behind was to provide examples with data and code that you can replicate yourself, not just vague fewliners.
February 3rd 2020
It’s been a busy few weeks at Aito. Busy enough to never get as far as to write down what we’ve been up to. So here we go again.
Soon-to-be-available-to-everyone Aito Console:
- Instances are now being grouped by team. This might be a non-issue at the moment for most of you, but once you ramp up more teams and instances, believe me, you will appreciate this change. See screenshot below.
- The browsing experience has been made smoother by several small changes. Now after login from invite links you should end up in the proper place. Also, there’s better linking between parts of the UI, so there should be fewer clicks required to get your business done.
- The API docs are now easier to browse, as we’ve added a lot of cross-linking between the descriptions. You should no longer get lost, we hope. Let us know if you do, though.
- Our own dogfooding project aka “funding demo” that uses Kickstarter campaign data has been given some TLC. It predicts the success of fundraising campaigns, and why they succeed. We added a short tutorial on how to use it. We also made Aito estimation accuracy for the past months visible. Check out the ‘Evaluations’, and find out yourself how good we’re doing. Executive summary: Quite good!
- Knowing whether you’re objectively doing good or bad is hard, but when it comes to Aito results, there’s a tool for that. Read about Aito's API endpoint Evaluate in Maria’s blog post.
- We’ve supported something called Jobs in Aito for a while already, but since the feature has been slightly experimental, it’s only been used by a selected few of our users. It’s also described in more detail in the aforementioned blog post. This is now documented for y'all.
December 20th 2019
We are working through the waitlist of users that have requested access to Aito, still at a rather modest rate as we want to ensure everyone has the best possible experience. We are also still limiting the new instance provision in Console by reviewing the requests. Next couple of weeks of holiday season means things progress a bit slower. Hang in there, your turn will come soon!
Should you have questions or need help, the team is best reached through our public Slack channel.
Soon-to-be-public Aito Console:
- We realised that we’re too deep into our own work. Some stuff was no longer obvious, so we’ve added some hints and tips on the way, to make it a bit easier to find your way around.
- We don’t store any passwords. Ever. It’s a promise. We’re using Auth0 for login, which allows you to sign in using your Google account as well as by creating a username/password. It’s, of course, possible to combine those, but that caused an embarrassing bug where you could no longer log in at all after combining the logical accounts. It’s been fixed now.
- Google logins now also work for non-Aito accounts. The default setting had not been changed, and we didn’t test this with enough different emails.
- Emails sent by the Console did not actually get sent. This was the case with Auth0-verification emails. We’ve tuned the settings now.
- The email content is also a bit more human now, as we started thinking more in lines of people than computers.
Aito CLI and integrations:
- The CLI documentation is getting some TLC as well. It’s on Github, so this will keep on improving all the time.
- The CLI is getting initial support for SQL-2-Aito. We’re starting off with Mysql and Postgresql, but plan to add support for other databases as well. We’re using ODBC-drivers for this, so it’s mostly a testing bandwidth issue to add more technologies here.
- With all the stuff going on with the website, we figured we’re having a hard time staying on top of everything ourselves. We started using BugHerd that adds a small “Send feedback” button on the right bottom corner. Please use it and tell us where we’re failing. Please. - We’ll make sure to fix them ASAP. It’s on Console too.
On that note, we changed the website to make the structure easier to traverse. Things should be easier to find now.
- We’ve had a long-running stability issue, where massive writing cause environments to start failing health checks. We finally found and squashed the bug! Yeah! The root cause was starvation of the request threads, while all capacity was being used for writing. The change is being rolled out to everyone, everywhere during the normal cycle.
- Another nasty database bug was the fact that deletions were not complete. Features with zero frequency were never removed. This would’ve been an issue most likely only in our stress testing, but it’s nice to know this won’t happen to you, our dear users.
December 6th 2019
We are getting readier than ever for publicly rolling out the Aito Console, which means our users can manage their teams and API keys as well as see usage stats online. While loads of the work lately has gone to the Console, we were also putting together some educational content and as a result, tadaaa, Aito is now on Youtube! Head over to check the content our amazing Customer Success Engineer Maria has been putting together to help you take the first steps with Aito.
Soon-to-be-public Aito Console:
- We’ve moved the Terms of Service to the console. This way you can read and accept the terms without physical contract hassle that has been a bit of a burden lately. We’re of course still available for questions, should there be any.
- You can now request new instances right from the main page, with less clicks. Note, we are for the time being still limiting the creation of new instances, as we want to ensure the best experience and performance to those who already use Aito.
Aito CLI and integrations:
- We have started collecting still experimental tools under aito-python-tools repository, where we have for example super useful Aito CLI tool that allows you to infer schema and quickly add data to Aito from JSON, CVS and XLS files.
- There was an embarrassing bug where you could try to do a modulo-query on a string field and get rewarded with an Internal Server Error. Ooops! It’s been fixed now, though.
- We’ve squashed a massive number of bugs in the console. Even before you saw them.
November 22nd 2019
- We’ve added a new comprehensive example for showing Aito in action: the Kickstarter funding prediction. It’s available online at https://funding-demo.aito.ai, live at Slush or in meetings with your favourite Aito people
- The Aito self-service experience is function-complete. We will be rolling out access to the people in the waiting line soon, and general availability will happen within a few weeks. Stay tuned for more details.
- We improved the update process, so we can now roll out changes and security fixes much smoother than before
- We have improved the validation during the schema creation. Unknown analyzers are now reported correctly rather than throwing an exception
- Representation learning is now one step closer. Basically this will allow Aito to group statistically related features automatically. As a result, the query results will improve and the explanations will get better. In short Aito will become smarter. This is a big improvement, but also a huge change. Thus, we’re rolling out the feature in selected use-cases, and step by step. There will be more details in our blog later.
October 3rd 2019
- Better support for numeric data
- With $numeric proposition, Aito can now detect proximity between input values
September 9th 2019
Back to developer docs