IterE | Iteratively Learning Embeddings and Rules for Knowledge | Graph Database library

For example:

Your code is a long-running, non-suspendable task. It blocks whatever thread it runs on for its entire lifetime. When you block the UI thread, it causes the UI to freeze, and after a timeout Android kills such a misbehaving application.

If you use any dispatcher that uses its own thread pool, for example IO, the task will block a non-UI thread.

so one thing is that for programs like using web apis where they are I/O bound (here where the performance hit taking is waiting on requests from another machine/server/etc), the more general approach is to using async programming. a good library for async http requests is httpx (there are others as well). you'll find interface of these libraries similar to requests along with allowing to be able to do async or sync, so should be easy transition to use. from there will want to learn about async pogramming in python. the quickstart and async along with other good tutorials can find via google on general python async programming.

can see that this is approach other python http wrapper libraries do like asyncpraw

Just as quick note on why async is nice vs multiprocessing. is that:

1. async essentially allows with a single process/thread executes other parts of program as other pars on waiting on output, so basically feels as if all of the code is executing in parrellel
2. multiprocessing is actually kicking off separate processes (i am paraphrasing a bit but thats the gist) and likely wont get same performance gains like would in async.

The way to approach the problem is going through the errors one by one.

The first error is from a test that checks whether the response of adding a new student is the HTTP code 201 (Created), but instead your code returns 200 (Ok). The reason your code returns 200 is because that's the default of Flask if you do not specify anything else (and if there are no errors in processing the request). To solve this one, search the web for how to return custom http codes in Flask.

The second error comes from a test that expects this one previously added student to come up when querying all students. Technically this test depends on the first test that first adds the student. The reason this test fails is because in your add function there is no interaction with the database. Check the methods on StudentModel and try to use the request data to create a new entry in your database. Good google keywords here are "SQLAlchemy insert" or "SQLAlchemy save new object to database".

Once you fix the second error, the third error should also go away. It also tests whether the user was added, but goes one step further by using the API to get the users, and it also checks whether the correct user data was used.

The remaining tests work very similarly, just for teachers rather than students.

std::vector is the fastest STL container for linear iterations like in your scenario. This is simply because memory is contiguously allocated and therefore can benefit of caching mechanisms. A vector iterator just increments a pointer internally.

You might improve performance further by trying to use a smaller type than int when possible.

In your case I think parallelization/SIMD would give largest performance boost for reduction. This might be achieved by auto vectorization (check project compiler settings).

You could also try OMP to do this like this (not tested)

Your problem seems to be working with gradient free methods, but not with gradient based one. Hence it's a safe bet that there is a problem with the derivatives.

I'm going to assume that since you're using VSP and AVL, that you're doing finite differences. You likely need to set up different FD settings to get decent derivative approximations. You probably want to use the [appox_totals][1] method at the top level of your problem.

You will likely need to experiment with larger FD steps sizes and absolute vs relative steps. You can get a visualization of what your intial jacobian looks like using the OpenMDAO scaling report. Your problem doesn't look badly scaled at first glance, but the jacobian visualization in that report might be helpful to you as you test FD step sizes.

At this moment ignite-spring-data incompatible with spring data 2.5 and higher. It's known issue which will be fixed in one of the upcoming releases. https://issues.apache.org/jira/browse/IGNITE-16124

I am not sure if this is what you want, but I suspect that the problem occurs because of the structure of year that has repeated values and gaps.

It works (technically) if we use a continuous time variable:

The error is mentioning a circular reference, which is where you try to reference the object that you are inside of. You do this when you write: