DataFrames.jl VS scikit-learn

I don't think we've seen the final state of it though. v1.9 really gives people the proper tools for solving latency problems. Before, invalidations hurt a little, but it was also kind of a wash because LLVM code didn't precompile, so you could spend time setting up a Snoopprecompile and fix some invalidations and end up LLVM bound saving 1 second out of 20. But with package images it's almost always better to fix precompilation. The only thing hampering time much now is the `using` time went up, but as mentioned in the Reddit post there's a lot of ideas for what to do there. The other thing is package extensions, which cut down the amount of code to load. There's tons of PRs floating around the ecosystem turning things into extensions, and thus cutting down the overall code that is actually ran and loaded.

This means that in a few months, people will start to see some major tangible benefits from following the compilation improvement practices laid out here and https://sciml.ai/news/2022/09/21/compile_time/. I think then you'll have a lot more people start to take all of these new tools seriously and it will be standard to incorporate them into packages. Right now they are still kind of niche things for packages with known TTFX problems, but I think come v1.9 you'll see every major package use all of these methods.

> Different packages are affected differently

I think this is one of the pieces that's effected by this. I don't think "Julia has become optimised for running Plots.jl" is quite correct. Julia's compilation and runtime is much more optimized for well-inferred code, which Plots.jl is not. However, the compiler developers have been using Plots.jl as a test case for all of these new tools, and therefore its SnoopPrecompile and invalidations have gotten some dramatic improvements because those required ecosystem changes I mentioned are being done by the compiler team for this specific package. Plots.jl had things like precompilation snooping way back before there was even a package for it, the earliest I know of was around v1.0. Meanwhile, DataFrames.jl only setup its precompilation snooping 7 months ago (https://github.com/JuliaData/DataFrames.jl/pull/3182), which I would presume was just in time for the v1.8 mark on your plot and is one of the big reasons for having a sudden drop (which continues into v1.9 because of package images).

What I mean to say then is that, I think all packages will get the improvements we've seen from Plots.jl, but package authors will need to update their packages in order for that to happen. Some packages have already done this, many have not.

IJulia also supports viewing and manipulating tables. To create a table, first install the DataFrames.jl package by running the following command in a new cell:

It were just a few percents of all possible manipulations that you can do with data using DataFrames.jl library. Read more about it in the documentation.

DataFrames.jl

DataFrames.jl and XLSX.jl for JSON, CSV, and XLSX files

Julia also has the CSV.jl library for reading/writing csv files, the DataFrames.jl library for manipulating data like pandas, and Images.jl for image processing/analysis. However, since Julia is so much newer than Python, the Julia libraries are almost never as feature rich as their Python counterparts.

Looks like it's single threaded according to this open issue: https://github.com/JuliaData/DataFrames.jl/issues/2626

Online Courses: Coursera: "Machine Learning" by Andrew Ng edX: "Introduction to Machine Learning" by MIT Tutorials: Scikit-learn documentation: https://scikit-learn.org/ Kaggle Learn: https://www.kaggle.com/learn Books: "Hands-On Machine Learning with Scikit-Learn, Keras & TensorFlow" by Aurélien Géron "The Elements of Statistical Learning" by Trevor Hastie, Robert Tibshirani, and Jerome Friedman By understanding the core concepts of logistic regression, its limitations, and exploring further resources, you'll be well-equipped to navigate the exciting world of machine learning!

Thank you for your interest. There are some interesting examples in the SWE-bench-lite benchmark which are resolved by AutoCodeRover:

- From sympy: https://github.com/sympy/sympy/issues/13643. AutoCodeRover's patch for it: https://github.com/nus-apr/auto-code-rover/blob/main/results...

- Another one from scikit-learn: https://github.com/scikit-learn/scikit-learn/issues/13070. AutoCodeRover's patch (https://github.com/nus-apr/auto-code-rover/blob/main/results...) modified a few lines below (compared to the developer patch) and wrote a different comment.

There are more examples in the results directory (https://github.com/nus-apr/auto-code-rover/tree/main/results).

sklearn is adding support through the dataframe interchange protocol (https://github.com/scikit-learn/scikit-learn/issues/25896). scipy, as far as I know, doesn't explicitly support dataframes (it just happens to work when you wrap a Series in `np.array` or `np.asarray`). I don't know about PyTorch but in general you can convert to numpy.

Wow, from the upvotes on this comment, it really seems like a lot of people think that this is the correct behavior! I have to say I disagree, but if that's what you think, don't just sit there upvoting comments on Reddit; instead go to this PR and tell the Scikit-Learn maintainers not to "fix" this "bug", which they are currently planning to do!

I was in a similar boat to yours - Worked in data science and since then have made a move to data engineering and software engineering for ML services.

I would recommend you look into the Design Patterns book by the Gang of Four. I found it particularly helpful to make extensible code that doesn't break specially with abstract classes, builders and factories. I would also recommend looking into the book The Object Oriented Thought Process to understand why traditional OOP is build the way it is.

You can also look into the source code of popular data science libraries such as sklearn (https://github.com/scikit-learn/scikit-learn/tree/main/sklea...) and see how a lot of them have Base classes to define shared functionality between object of the same nature.

As others mentioned, I would also encourage you to try and implement design patterns in your everyday work - maybe you can make a Factory to load models or preprocessors that follow the same Abstract class?

It looks like you've been the victim of some misinformation. As Dr_Birdbrain said, an SVM is a convex problem with unique global optimum. sklearn.SVC relies on libsvm which initializes the weights to 0 [0]. The random state is only used to shuffle the data to make probability estimates with Platt scaling [1]. Of the random_state parameter, the sklearn documentation for SVC [2] says

Controls the pseudo random number generation for shuffling the data for probability estimates. Ignored when probability is False. Pass an int for reproducible output across multiple function calls. See Glossary.

[0] https://github.com/scikit-learn/scikit-learn/blob/2a2772a87b...

[1] https://en.wikipedia.org/wiki/Platt_scaling

[2] https://scikit-learn.org/stable/modules/generated/sklearn.sv...

Scikit-learn Documentation

Firstly, we need a connection to Memgraph so we can get edges, split them into two parts (train set and test set). For edge splitting, we will use scikit-learn. In order to make a connection towards Memgraph, we will use gqlalchemy.