H2O VS julia

I would use H20 if I were you. You can try out LLMs with a nice GUI. Unless you have some familiarity with the tools needed to run these projects, it can be frustrating. https://h2o.ai/

Here is the transcribed portion of what you sent: Within this project, or another example, for some examples of maybe encountering resistance or someone who's just like a specific person who seemed really opposed to your ideas that you had to influence or win over, and how you approach that sort of personality-based problem. Yeah, great question. So, at Lineate, I mentioned earlier that I helped to kind of upscale the entire workforce. We're talking 200 engineers, marketing folks, sales folks, account managers. And I had just, so in an effort to kind of upscale this and identify opportunities for machine learning, I followed Andrew Ng's framework for approaching ML in the enterprise. Basically, it's like one-pagers, where I define the problem statement. Do we have access to the data? Do we have data privacy or regulation concerns? What are some risk assumptions, success criteria, all that stuff. So, I put together like 20 plus one-pagers across all the different opportunities, and I generated a successful proof of concept with the team after it was a failure, of course, at first, but we turned it into a success. And part of this Andrew Ng framework in AI in the enterprise, it's like you want to generate a center of AI excellence, where it's like you share best practices with the rest of the organization. So, nobody told me that I had to do this, but this is kind of like something that I aspire towards. And in the process of trying to be inclusive with the 200 engineers, there was one engineer who was unwilling to participate. There was a phase two of his project that had an AI component that used the same tool that we used in Google Cloud. And I opened a Slack channel with our team and himself to try to get him to share what he's working with so that my team can also share what learnings we had with that tool. He just wasn't willing to participate. I just couldn't understand. It's like, how can you not? I mean, this isn't your benefit. This is a team. You got to be a team player. So, my first reaction was like, seek to understand, what's the context here? What's the background? I asked around. I talked to engineers who worked with him. I talked to higher ups without kind of like mentioning that this person was problematic, but just to understand what the nature is. And it turns out he doesn't report to the director of Solution Architecture Engineering. Instead, he reports directly to the CEO. I was like, oh, that's interesting. It turns out he came into the company through an acquisition. He was like a startup founder. So, he's used to running the show. So, when it comes to working with a team of 200 engineers, he's a superstar in terms of performance, but maybe team play-wise, not so much. So, understanding that context really helped me understand where he's coming from. And the next thing I did was I tried to anticipate, what are some of his needs? What can I do to help him reach his goals? And he wanted to, of course, do well on his project because he's a high performer. He wants to be aware of any risks early on. So, what I did was I got a hold of a sample dataset from the work that he was doing. And since I had access to some tools that he did not have, like h2o.ai, DataRobot, I took some of his data samples, put it into these tools, ran different algorithms on them, like GBM, different neural networks, to get a sense of what does a confusion matrix look like? What is this two by two matrix of true positive, false positive, and stuff like that. So, I was able to deliver some of these confusion matrices to him so that he's aware of it. And another thing is, I said, the tool that you're using is the same tool that we used. Well, guess what? It doesn't do so well in a sub-10 millisecond environment, which is one of the needs of your project. You might want to consider SageMaker endpoint where you can deploy artifact there so that this latency requirement is not a problem. So, I kind of anticipated where his needs are, being proactive to help him, offer advice where I anticipated that he needed help and extra guidance. He started kind of like more open up. And guess where I shared some of these insights? I shared it in the channel that he originally did not want to participate in. And I said, I'm going to share it in this channel. So, then he takes a look there and he starts replying to that. So, now I kind of like, kind of guided him to take one step into like this channel. So, now whatever reply he says, then my engineers can see that reply. And now it's like we have a team spirit going on now. So, that's like how I kind of got him from not wanting to participate to now participating. And on top of that, I also did like these company wide webinars where I showcase our teams. I put their profile pictures on the front slide. So, when everybody dials in, then they could see like, these are the people on my team. Here's what we're working on. And I asked him, you're really good at what you do. I would love to include you in this team in the next meeting. Are you okay with it if I put your profile picture on the front page? And he said, yes, right away. So, like helping to kind of like, because it's not like I need the credit. I just distribute some of the visibility to some of these star engineers and kind of like in exchange, you get like better collaboration. And that goal of the AI Center for Excellence for better kind of sharing best practices and learnings. So, I think by doing that, I was able to kind of like turn an icky situation into something that became a team effort. That's awesome. Love it.

H2O.ai

Thanks for the input. To clarify, I am more focused on choosing the modeling framework(s) that makes the most sense to use for future production. For example, is h2o.ai a good framework for training models for later deployment (through something like elastic beanstalk, Flask API's etc.)? I came across a number of mentions of Tensorflow, however it is focused on neural nets while I also want to use classic models such as random forests, etc.

I've also initialised an instance of H2O.ai, so I can parse into the server each product, by store, segmented. It can then train the models, determine which model is the most performant, and then save it. Because the variability of different product SKU, at different hospitals, is substantial.

H2O.ai H2O is a deep learning tool built in Java. It supports most widely used machine learning algorithms and is a fast, scalable machine learning application interface used for deep learning, elastic net, logistic regression, and gradient boosting.

H20

Built and founded various web3 projects for last 2 years such as OpenArt and 8RealmDojo for last 2 years as well as being high performing student in CTU in Prague and SeoulTech. Was offered internships in Amazon and H2O.ai. Created robots assistants using robots from SoftBank.

34. Julia - $74,963

I don't believe there is any official documentation on this, but https://github.com/JuliaLang/julia/pull/49430 for example added prefetching to the marking phase of a GC which saw speedups on x86, but not on M1.

3. dispatch on all the arguments

the first solution is clean, but people really like dispatch.

the second makes calling functions in the function call syntax weird, because the first argument is privileged semantically but not syntactically.

the third makes calling functions in the method call syntax weird because the first argument is privileged syntactically but not semantically.

the closest things to this i can think of off the top of my head in remotely popular programming languages are: nim, lisp dialects, and julia.

nim navigates the dispatch conundrum by providing different ways to define free functions for different dispatch-ness. the tutorial gives a good overview: https://nim-lang.org/docs/tut2.html

lisps of course lack UFCS.

see here for a discussion on the lack of UFCS in julia: https://github.com/JuliaLang/julia/issues/31779

so to sum up the answer to the original question: because it's only obvious how to make it nice and tidy like you're wanting if you sacrifice function dispatch, which is ubiquitous for good reason!

https://github.com/JuliaLang/julia/blob/release-1.10/NEWS.md

Visit official site: https://julialang.org/

No. It runs natively on ARM.

julia> versioninfo() Julia Version 1.9.3 Commit bed2cd540a1 (2023-08-24 14:43 UTC) Build Info: Official https://julialang.org/ release

https://github.com/JuliaLang/julia/issues/51086#issuecomment...

So while this "fixes" the issue, it'll introduce a confusing time delay between you freeing the memory and you observing that in `htop`.

But according to https://jemalloc.net/jemalloc.3.html you can set `opt.muzzy_decay_ms = 0` to remove the delay.

Still, the musl author has some reservations against making `jemalloc` the default:

https://www.openwall.com/lists/musl/2018/04/23/2

> It's got serious bloat problems, problems with undermining ASLR, and is optimized pretty much only for being as fast as possible without caring how much memory you use.

With the above-mentioned tunables, this should be mitigated to some extent, but the general "theme" (focusing on e.g. performance vs memory usage) will likely still mean "it's a tradeoff" or "it's no tradeoff, but only if you set tunables to what you need".

I have asked about Julia's reproducibility story on the Guix mailing list in the past, and at the time Simon Tournier didn't think it was promising. I seem to recall Julia itself didnt have a reproducible build. All I know now is that github issue is still not closed.

https://github.com/JuliaLang/julia/issues/34753

I don't really know what kind of rebuttal you're looking for, but I will link my HN comments from when this was first posted for some thoughts: https://news.ycombinator.com/item?id=31396861#31398796. As I said, in the linked post, I'm quite skeptical of the business of trying to assess relative buginess of programming in different systems, because that has strong dependencies on what you consider core vs packages and what exactly you're trying to do.

However, bugs in general suck and we've been thinking a fair bit about what additional tooling the language could provide to help people avoid the classes of bugs that Yuri encountered in the post.

The biggest class of problems in the blog post, is that it's pretty clear that `@inbounds` (and I will extend this to `@assume_effects`, even though that wasn't around when Yuri wrote his post) is problematic, because it's too hard to write. My proposal for what to do instead is at https://github.com/JuliaLang/julia/pull/50641.

Another common theme is that while Julia is great at composition, it's not clear what's expected to work and what isn't, because the interfaces are informal and not checked. This is a hard design problem, because it's quite close to the reasons why Julia works well. My current thoughts on that are here: https://github.com/Keno/InterfaceSpecs.jl but there's other proposals also.

Doesn't musl have the same issue? https://github.com/JuliaLang/julia/issues/34726#issuecomment...

I also wonder about OSX's libc. Newer versions seem to have some sort of locking https://github.com/apple-open-source-mirror/Libc/blob/master...

but older versions (from 10.9) don't have any lockign: https://github.com/apple-oss-distributions/Libc/blob/Libc-99...