jj12345

Thanks for the reference!

Not sure if you'd be willing, but I'd love a quick rundown of the high level takeaways if you'd be willing to drop them here.

Are you talking about more than one experimental design in terms of comparing the exp/control distributions or something else?

Can you speak to how useful you've found the pattern/paradigm? Sort of an ambiguous question, but I've sat through some intro Rx stuff at Microsoft seminars and I've yet to deliberately reference it when writing code. This isn't to say it's without merit, I'm just looking for inspiration.

Edit: Further clarification - I think I'm unfairly generalizing this to a mix between coroutines and an Observer pattern.

This is done occasionally in algo books to encourage their adoption in cirricula (e.g. Dasgupta, etc.).

As a sibling comment mentions, it's relatively easy to verify your answer for correctness in some cases. The downside of this is that it becomes difficult to assess whether students are actually learning. One way to mitigate this is to withhold answers and assist with other teaching resources like TAs. This also helps teach the aforementioned 'verification' step.

These are good questions, but I'd also be curious to hear of some more concrete examples. In the interest of continuing the discussion, OP might be referring to some hybrid approaches like Backbone/Knockout where they aren't trying to solve some of the more interesting problems (e.g. bundling, dependency management, etc.). Of course, this ignores those problems and you could argue that different SPAs could be reduced to different "controllers" or some other framework specific abstraction.

I'm just now starting to crack open some Lisp tutorials, coming from the OOP side of the fence, so please excuse the ignorance. For my learning purposes, would you be open to explaining how symbolic expressions would circumvent the need for a file system?

In addition to the scarcity of what I'd call "deep dive" materials, companies like Facebook and Google are frequently trying to encourage platform adoption.

MOOCs for purely pedagogical reasons are sometimes hard to find in ML, not only for the aforementioned reasons, but creating a MOOC is simply resource intensive. It follows that many of the producers that truly value education are actual universities. Hybrid models like Coursera and Udacity are still trying to figure out how to get out of the red.

All of this to say that I'm still very grateful for content creators who go beyond simple framework tutorials.

Definitely biased, but here are some anecdotes/thoughts:

- I've found the rigor to be significantly more than most MOOCs, inline with other traditional grad courses I've taken.

- Some classes are hybrid, sharing the term with on-campus students.

- Not having finished the degree, my work as a data scientist has significantly benefited from the coursework. This is not to say that it wouldn't have benefited from other, non-GT coursework.

Forgot my /s tag for my obnoxious comment :[

I'm not sure what you mean. If you simply take the chapter titles and google them, you end up at Head First Python [1], which seems like a great book that doesn't require $250 a year. It's probably safe to assume that this was the author's intention.

[1] https://www.safaribooksonline.com/library/view/head-first-py...

Thanks for sharing this video.

When she's discussing Compensations she mentions that the Transaction (T_i) can't have an input dependency on T_i-1. What are some things I should be thinking about when I have hard, ordered dependencies between microservice tasks? For example, microservice 2 (M2) requires output from M1, so the final ordering would be something like: M1 -> M2 -> M1.

Currently, I'm using a high-level, coordinating service to accomplish these long-running async tasks, with each M just sending messages to the top-level coordinator. I'd like to switch to a better pattern though, as I scale out services.

I'm a fan of Kibana, but AnyChart does support some more templates (not that you couldn't accomplish the same chart in either). There's a million of these visualization libraries now and it seems like all of them are basically extensions of D3, so the selling point is the opinionated integrations.

That being said TimeLion has been great for doing some basic exploratory work.

To the first point, the paper mentions that "the covariance is calculated after applying the Gaussian Copula to that table". The experiments seem to conclude that, for their datasets, the 2D projections seem to work alright. I think that the surprising conclusion is that this works so well for any dataset at all.

Just thinking out loud here:

The typical case where a low dimensional representation would fail you is if you had dependencies (e.g. bimodal relations) that weren't represented by a datatype or foreign key. Recall that the simulation of data still occurs within each table, so the higher the non-represented inter-table dimensionality is, the supplied distributions can measure it. It's might be that, for the most part, the raw columns (not from child tables) have much more bearing on the merit of the table covariance. This seems natural, due to the semantic nature of RDBMS structures.

It's probably an important caveat that typical RDBMS structures are created to optimize the user's understanding of the data through semantic structure. Since the claim of the paper was only that they could provide a useful abstraction for simulation, I think it's OK to proceed with the assumption that Gaussians can never be fully sufficient in modeling highly dimensional data without help.

There are existing non-parametric models that attempt to do a similar thing for relational data that I think are more promising. One drawback of current solutions like BayesDB is that you're still dealing with the original table structure, which this paper tries to get around. It would be nice to bridge the gap for something like PyMC3 where we find a cute way to flatten the data, like this paper.

[1] Probabilistic Search for Structured Data via Probabilistic Programming and Nonparametric Bayes. https://arxiv.org/pdf/1704.01087.pdf

[2] http://probcomp.csail.mit.edu/bayesdb/

[3] http://docs.pymc.io/index.html

Just finished the paper, so let me take a stab:

Peeling back the mystery a bit, what is happening is:

1. From each child table upwards, model each column as a simple distribution (e.g. Gaussian) and covariance matrix.

2. Given those child table distribution parameters, pass them back as row values to their respective parent tables.

What you end up with is a "flattened" version of each parent table that has the information (in an "information theoretic" sense) of all child relations. Sampling from distributions is straight forward. The stats methods are outlined in section 3 of the paper.

Things of note:

- The paper makes heavy use of Copula transformations to normalize data whenever it passes around the distribution parameters.

- It deals with missing values by adding something like a dummy column.

- The key insight is that columns must be represented by parameterized distributions, but they don't have to be Gaussian. The Kolmogrov-Smirnov test is used to choose the "best fit" CDF to model.

To your question about the role of the data scientists: they are using the resulting simulations to solve more complex tasks. The goal of the experiment was to see how well the sample data would perform against Kaggle competitions. So I guess the idea was that if winners were indistinguishable, the simple/hierarchical distributions would be considered robust enough for complex tasks. In the end, I'm sure shipping the underlying is preferable for consumers.

To add to this answer: the methods outlined in the paper allow for perfect reconstruction of the underlying data in many cases, as the simulation of data is simply sampling from fitted distributions.

Thanks, these are great responses! Also, I apologize for not fixing my own formatting sooner, which makes the questions almost impossible to read. You answered my last question about stochastic traces by explaining the de/activation function relationships with Lmin.

Thanks again!

Thanks for the paper link! I've been digging into PAC learning so I'm taking anything I can get.

On the paper, I was hoping you could help me understand a few things: - It seems that the main finding is that any k-CNF form, like Thomas' Boolean Regulatory Network, can be expressed by PAC learning bounds. In section 4 of the abstract [1], you mentioned that "when the dimension increases... the PAC learning algorithm can leverage available prior knowledge...". Are you referring to the time dimension adding more clauses to the k-CNF? - I'm having trouble reconciling the PAC term "h" with "model confidence" in section 5.2. Is this allowed because the PAC learning "delta" (probability) [2] parameter is dropped for the k-CNF adaptation? - In this concrete case, is the learning portion just the mapping the stochastic traces to outputs (i.e. lookups)? I'm missing some understanding on how such a mapping handles stochasticity.

You'll have to forgive me, as I'm still trying to understand the paper. It's incredibly interesting to me, so thanks for writing it!

[1] Abstract - http://mlsb.cc/2017/abstracts/MLSB_2017_paper_11.pdf

[2] PAC Learning - https://en.wikipedia.org/wiki/Probably_approximately_correct...

Maybe an expert will chime in here, but I recall learning that several concepts in ML are derived from or in parallel to the BIC. Many use feature AIC/BIC measures for feature selection.

On a separate note, AIC/BIC are prevalent in linear regression models because they are extremely well-behaved in comparison to some other models. This has generated enormous amounts of field-specific experimental literature. For instance, economists can form expectations for AIC/BIC measurements dependent on the study-type.

Additionally, we already have some decent tools for regularization (albeit model-dependent ones). Counting the nodes of a NN to establish an AIC may not lead to a proper understanding of the free parameters.

This wasn't meant to be an apologists take on why I'm not using AIC/BIC for model selection. If we're talking about "deep learning", then it's definitely a worthwhile goal to examine how to optimize network topologies. The link below mentions using reinforcement learning to learn architecture.

https://research.googleblog.com/2017/05/using-machine-learni...

It's a hard problem. One person's scam is another person's business opportunity. I, for one, want to learn more about this amazing spell-casting.

I was looking at this as well, but I'm willing to suspend my disbelief because the normal vaguely looks like it has a good deal of information (in a basic fidelity sense).

As someone going into the field, can you explain what this means? Specifically, I'd assume we're trying to isolate some outliers that are causing a funky bias in the learner. In what way would you automate their discovery (what does it mean to "discover" the outliers in this scenario?)?

Just looking for clarification because I feel like I should know this. Trying to couch the problem in terms I'm more familiar with.

Thanks for the nice, condensed article. Generating features from BeautifulSoup isn't something that I've considered before.

I'm still going through Yoshua Bengio's new book on DL, but if anyone is free to comment: what are the justifications for the general architecture? Why use LSTMs with the Glove embeddings?

As someone just now getting into the basics of NLP, thank you for this brief summary.