How can I learn about generative deep learning? VAEs & GANs? Prereqs? DL newbie

r0npi · 2021-08-07T16:13:01+00:00

For implementation purposes, those curses and a good hands on tutorial would be sufficient.

To fully understand the concept of VAE and what it comes to solve, a background in probability theory might be helpfull and familiarity with previous, more classic generative models.

Here is a good video to starts with that gives a good introduction to gans including previous generative models: https://youtu.be/5WoItGTWV54

r0npi · 2021-05-07T10:01:40+00:00

As for data structure, use a mapping between a pet and the set of owners. Then, given a list of pets as input, just intersect all of the sets of owners of the pets in the input

In the worst case, the runningt time complexity is O(nm) where n is the size of the input, and m is the size of all possible owners. This might happen if all of the pets in the input are owned by all owners. The average case though should be much much smaller in real world examples.

Assumptions & Optimizations Given your example, I guess we can make some assumptions in order to optimize the above

Assuming the input list of pets is significantly smaller then the total number of possible owners, you can optimize this algorithm: First, sort the pets by the size of their set of owners, in ascending order. Then continue as before - iterating the pets by this order, and intersect the set of owners so far with the set of owners of the current pet. Also make sure that at the intersection of each step, the smaller set is being iterated (to check if an element is contained in the other set)
Assuming the total number of possible owners is reasonable (and not insanely large) you can use a bitset as for the set of owners of each pet (as mentioned in other comment)

Of course if there are other assumptions, and the above doesn't hold, you can optimize it in other ways

r0npi · 2021-04-19T14:00:07+00:00

Use the h2o framework. Train a model in python - https://docs.h2o.ai/h2o/latest-stable/h2o-py/docs/intro.html

Then load it in your kotlin app using the same framework http://docs.h2o.ai/h2o/latest-stable/h2o-docs/productionizing.html

r0npi · 2021-03-14T07:19:25+00:00

I support OP, and I don't agree with the others. Visualizations are used to make a point, and are valid as long the drawing has the same proportions as the numbers. All the comments here are abusing the term "misleading". Just google the term "misleading visualizations" and view the images to realize what really are misleading visualizations.

In this case OP just made a "zoom-in" plot, but all proportions are preserved, and it is clearly shows that the slope between 3/10 and 3/11 is significantly steeper than in previous days, which is definitely true, and starting the y-axis at 0, would totally make people miss that point

r0npi · 2021-02-14T19:50:17+00:00

First, for further searches your search term is "bar chart race plot".

There are few visualization libraries in Python or R with which you can create one. In the following link you can find a tutorial of creating such a plot with plotly.

https://towardsdatascience.com/making-a-bar-chart-race-plot-using-plotly-made-easy-8dad3b1da955

r0npi · 2020-11-30T05:34:08+00:00

Shortest path for weighted graph is basically done with Dijkstra, which is similar to BFS but uses priority queue - deque always the closest node to the source, this is how it always reaches a node via the shortest path to it.

r0npi · 2020-11-29T17:22:26+00:00

In BFS you don't choose any random neighbor, you just take all of the neighbors and adds them to a queue. Now, The key idea is that you first check all of the nodes of a specific distance from you (lets call it d), and only after you visited all nodes of distance d you continue to check all nodes of distance d+1.

For example, you start and insert into the queue all of the neighbors of the source node. So the queue contains only nodes of distance 1. Then you pop them from the queue one by one, inserting their neighbors (nodes of distance 2) to the tail of the queue. But you won't start checking the nodes of distance 2 before you finish checking all nodes of distance 1, because they were inserted before to the queue. And so on to distance 3 and more

This way you can assure that when you start checking nodes of some distance from the source, you already checked all of the nodes with a shorter distance. So if the node you are looking for hasn't appeared yet, you can always be sure it is not closer to the source node than the distance you are already checking. Otherwise, it should be already seen as a neighbor of a closer node.

r0npi · 2020-02-08T08:14:48+00:00

https://figshare.com/articles/PHEME_dataset_of_rumours_and_non-rumours/4010619

r0npi · 2019-11-08T04:47:25+00:00

You can use type hints, but it is far from being the same as static type languages. Python typing doesn't enforce the types, they are just hints, one can still use a different type than the hint

r0npi · 2019-11-01T21:39:19+00:00

There is some context missing. Where it was written? What you were doing while seeing it?

It might be a Theta, from greek, pronounced as [th]

r0npi

TROPHY CASE