Matthijs Snel

Here is a geeky post after a while (and long overdue)! This recent paper ( https://lnkd.in/eX7rKSvS ) about a new neural net as an alternative to the oldest NN, the MLP caught my attention: Kolmogorov-Arnold Networks (KANs) have learnable activation functions, compared to Multi-Layer Perceptrons (MLPs) with fixed activation functions. According to the paper, this architectural modification makes KANs significantly outperform MLPs in terms of accuracy, avoids catastrophic forgetting, and importantly makes them interpretable. The catch? Learning time is 10x slower and requires more computational resources (basically optimization in a higher-order space takes longer!) The KAN code is at https://lnkd.in/eA3-Nam4 . I might just try this out in my spare time!

38

3 commentaren

Two of my favorite things: machine learning and turbulence. Interesting read by Rik, Wouter, and Daan Crommelin. "Fully resolving turbulent flows is computationally expensive. Therefore, we typically work with under resolved simulations with added turbulence model. Recently, Neural Networks are being used as turbulence model with as target to reproduce the fully resolved flow field. This is a high dimensional problem. However, scientists are often only interested in a few quantities which are derived from these flow fields, such as the average energy. We propose a simple method which only uses these quantities as "target", resulting in a much lower dimensional problem. We compare this method with convolutional neural networks and find that both can successfully correct long-term simulations." Read here: https://lnkd.in/etBe9BnX Aside, if you are interested in this overlap of CFD/AI and want to get started in your learning journey -> checkout my book I have written on this topic: https://geni.us/JaXp #turbulence #ai #machinelearning #datascience #aerospace #aerodynamics #cfd #cae

96

1 commentaar

TLDR: eigenlijk was Niels Bohr een hopeloze filosofische prutser 🤓 On the Relative Nature of Quantum Individuals | by Christian de Ronde et al. | ArXiv In this work we argue against the interpretation that underlies the "Standard" account of Quantum Mechanics (SQM) that was established during the 1930s by Niels Bohr and Paul Dirac. Ever since, following this orthodox narrative, physicists have dogmatically proclaimed -- quite regardless of the deep contradictions and problems -- that the the theory of quanta describes a microscopic realm composed of elementary particles (such as electrons, protons and neutrons) which underly our macroscopic world composed of tables, chairs and dogs. After critically addressing this atomist dogma still present today in contemporary (quantum) physics and philosophy, we present a new understanding of quantum individuals defined as the minimum set of relations within a specific degree of complexity capable to account for all relations within that same degree. In this case, quantum individuality is not conceived in absolute terms but -- instead -- as an objectively relative concept which even though depends of the choice of bases and factorizations remain nonetheless part of the same invariant representation. https://lnkd.in/eMCASmDN #quantum #mechanics #physics #SQM #Copenhagen #interpretation #Bohr #atomism #dogma #elementary #particles #elementaire #deeltjes #individuality #science #philosophy

4

The whole field of prompt engineering can be reduced to these 6 techniques I use almost daily when using ChatGPT (or other LLMs). Here they are ↓

1

Just read Farquhar et al's Nature paper on detecting hallucinations in large language models using semantic entropy. Interesting result on quantifying uncertainty in LLMs. When you ask an LLM a question, its answers may look correct, but be made up - a confabulation. For example, the LLM may answer incorrectly that the STARD10 protein is a "negative regulator of the mTOR pathway" instead of its true role as a lipid transfer protein. When an answer is confabulated, multiple subsequent generations will have different meanings. For example, a second answer of the LLM may incorrectly say that STARD10 is a "negative regulator of the meiotic recombination process". The variability in meaning can be quantified using semantic entropy, which measures variability over multiple generated answers. Higher entropy suggests greater variability and potential confabulation. The LLM can then refuse questions with high semantic entropy. To calculate semantic entropy, you generate 5-10 answers. You then cluster the answers based on semantic meaning using bi-directional entailment. Two answers are part of the same cluster if they entail - or imply - each other (e.g. "Joe buys a red apple" implies "A red apple was bought by Joe" and vice-versa). The entailment is calculated using another, possibly less powerful LLM, so it's an interesting applications of using language models to correct other language models. After clustering, the probabilities of each cluster are calculated from the output probabilities of the LLM, and then the resulting entropy. Thresholding the entropy can classify a question as likely to produce confabulations with an AUROC of around 0.75. Link to paper below.

63

2 commentaren

Apollo Research released a new mechanistic interpretability approach. They use the loss landscape to identify computationally relevant features and interactions. Then, they build a full interaction graph and interpret it. Theory: arxiv.org/abs/2405.10927 Experimental: arxiv.org/abs/2405.10928 In the theory paper, they modify singular learning theory to study the loss landscape for interpretability. They find 3 ways that parts of the network can end up being irrelevant to performance. Networks that generalize well are likely to have lots of this irrelevant structure! They introduce the Local Interaction Basis (LIB) as a way to remove this irrelevant structure and to find the most computationally relevant features. They also connect the loss landscape to modularity, deriving a formula for finding modules inside a network. In the second paper, they then empirically test LIB. LIB is a coordinate transform into a basis where interactions are as sparse as possible. Intuitively, it’s like a fancy PCA where we orthogonalize the features and their interactions at the same time. After identifying the LIB features, they use integrated gradients to build a graph of feature interactions. They use the derived modularity metric to search for modules in the graph. On small models, e.g. a modular addition transformer and a CIFAR MLP, LIB graphs are smaller, more sparsely activated and more interpretable than a PCA baseline, with identifiable modules that correspond to separate computation. Code 👉 https://lnkd.in/dksJWb-X #machinelearning

1

Apparently, someone (maybe KPMG) is running a supply chain due diligence on pydantic on behalf of NASA. The thread is interesting. I link in the comment, but I summarise in a couple of points: - "This is so dumb. Do they know what OSS is?" Dumbness is not an issue in regulations. There was literally a supply chain attack recently on Linux, and if successful, a state actor would have gained access to half the internet (which makes you wonder what else is happening out there). You can read more about this if you search "hacker news xz," which is a fascinating story; I might write about it. - "KPMG ripping of NASA and the taxpayers" Maybe the astronauts and the rocket scientists don't want to spend their time on this? Outsourcing these are pretty standard to those poor people whose entire job is just this. (Shed a tear for their souls) - "Can you do it for free for NASA?" Why would he? They have an enormous budget. Pydantic must have a good place for that money. - "Did not OSS maintainers suffer enough?" They can ignore the request, and NASA will have no other choice but to either fork pydantic or recreate it from scratch. They have no other choice. They are not doing this because they have nothing better to do. - "AI will replace these people, can't wait for it." That's just mean. - "This is so dumb." They plan to send people to the Moon, not exactly a "move fast and break things" mission. Look at what happened when this principle was ignored at Boeing. NASA wants to ensure that if there is a bug or issue with pydantic, someone will be there to fix it. They also want to ensure that no nefarious actors have a chance to take down anything serious or at least have a contained blast radius. This is a negotiation. How much the maintainer can charge for this? What is the alternative? Recreate pydantic from scratch? How many lines of code? How many engineers and how much time to recreate? How much time does it take to review a fork and maintain compatibility? This will provide a BATNA ("Best Alternative to Negotiated Agreement) that you can use as a baseline. On the other hand, you have your costs to actually fulfil the above agreement. Some quoted lowball numbers, which indicate that the entire deal can be done in 1-2 weeks. It won't, and you will regret accepting the deal. There is a huge crisis in OSS, especially with single-person maintainers. Huge companies rely on these softwares, but because there is no business behind them, the individual probably can't or doesn't want to deal with the commercial side. They started doing it in their spare time and now things go out of hand. [continued in comments]

89

40 commentaren

LoLCATs: Demystifying Linearized Attention in Large Language Models In their recent blog post "How to Linearize LLMs for Me and You", researchers from Hazy Research introduced LoLCATs, a groundbreaking method to efficiently scale large language models by linearizing attention mechanisms. Large language models (LLMs) like GPT have achieved great success, but they can be extremely computationally expensive, primarily due to the self-attention mechanism, which grows quadratically with the input size. Enter LoLCATs (Learnable Linearized Attention Transformers), a new approach to make LLMs faster and more scalable. Let’s break down LoLCATs, including how they linearize attention, why this is important, and how it works in practice. Self-Attention: Why It’s Powerful but Expensive Traditional self-attention works by comparing every word in a sequence with every other word. In mathematical terms, this creates an N×N attention matrix, where N is the length of the sequence. If you have 1,000 words in a sentence, this requires 1,000,000 comparisons. As sequences get longer, the model has to perform exponentially more work, making it slow and resource-intensive. Linearized Attention: Making Attention Faster LoLCATs linearize attention by approximating this full pairwise comparison process. Instead of calculating all N^2 comparisons, LoLCATs reduce the complexity to O(N). Here’s how: Low-Rank Approximation: Rather than calculating the full attention matrix, LoLCATs decompose it into smaller, more manageable matrices. This low-rank approximation allows the model to compute relationships between tokens without comparing every pair. Factorized Attention: LoLCATs modify the attention mechanism to compute attention scores in two steps: First, it projects the inputs into the query and key spaces using efficient transformations (often kernel-based). Then, instead of computing the full QK^T product, it computes an approximate dot product between queries and keys, reducing the number of operations. The result is that instead of building a full attention map, LoLCATs compress the attention process, maintaining essential relationships without all the heavy computation. Learnable Linear Attention: LoLCATs introduce a learnable linear attention mechanism, allowing the model to improve its approximations over time through training. This makes the system adaptable and able to fine-tune its understanding of relationships between words as the model trains on more data. Why is This Important? By reducing attention complexity to linear time, LoLCATs make it feasible to handle much larger models and longer sequences. For instance, in traditional models, scaling to sequences of 10,000 or 100,000 tokens becomes practically impossible due to resource demands. LoLCATs, by comparison, handle these sequences much more efficiently, reducing both memory usage and processing time. Reference: https://lnkd.in/eJ9XGBmQ

8

2 commentaren

A new paper of mine was published in the Journal of Open Source Software! The paper introduces MarSwitching.jl - The first package for estimating Markov Switching models in The Julia Language. This class of models (and a package) may come in handy if you want to model time-variation or a regime change in the model parameters. I also encourage you to check-out a github repository with the documentation of the package: https://lnkd.in/e3TeNKs5 or a blogpost by Bogumił Kamiński about the package: https://lnkd.in/efd5DCqz

26

This paper introduces Wav-KANs (Wavelet Kolmogorov-Arnold Networks), a novel type of neural network that leverages wavelet functions for enhanced data analysis. Let's break down what sets Wav-KANs apart from traditional Artificial Neural Networks (ANNs) and explore why they might be the future of neural networks. What Are Wav-KANs? At its core, Wav-KANs integrate wavelet functions into the Kolmogorov-Arnold Networks (KAN) architecture. This might sound a bit technical, so let’s simplify: wavelets help the network break down data into different frequency components. Imagine a piece of music: wavelets help the network separate the high-frequency details (like sharp notes) from the low-frequency trends (like the underlying beat). This decomposition enhances the network's ability to learn and interpret complex patterns. The Role of Frequency Traditional ANNs process data as a whole, often missing out on intricate details. Wav-KANs, however, analyze both the fine details and broader trends within the data. For example, in image processing, a Wav-KAN can simultaneously capture the sharp edges (high-frequency) and smooth areas (low-frequency), leading to better performance. Efficiency and Size Wav-KANs tend to be more efficient than traditional ANNs. By capturing essential patterns with fewer parameters, they can achieve higher accuracy with potentially smaller models. This means less computational power and faster training times, which is a win-win for anyone working with large datasets. Improved Interpretability One of the standout features of Wav-KANs is their improved interpretability. By using wavelet functions, these networks make it clearer why a particular prediction is made. For instance, if a Wav-KAN is used to diagnose a medical condition, it can highlight which parts of the signal (high or low frequency) were most influential, providing valuable insights to healthcare professionals. https://lnkd.in/gZbH8ZMA

5

🔓 How Open Are "Open" AI Models? 🤔 A new study from Radboud University sheds light on the varying degrees of openness among AI models marketed as "open." 📊 The researchers evaluated 40 large language models and 6 text-to-image generators based on 14 characteristics across three categories: - Availability of source code, pretraining data, weights, and licensing - Documentation of code, architecture, papers, model cards, and datasheets - Access to downloadable packages and open APIs Key findings: - OLMo 7B Instruct from Allen Institute for AI scored highest among language models - Stable Diffusion was the most open text-to-image generator - Some prominent "open" models like Meta's Llama 2 Chat and Llama 3 Instruct scored poorly As the AI landscape evolves, clear definitions of "open-source AI" are crucial for innovation, business, and regulation. The Open Source Initiative is leading efforts to establish firm standards. 📜 This framework provides valuable guidance for developers and policymakers seeking clarity in an increasingly complex field. 🧭 #AI #OpenSource #MachineLearning #LanguageModels #TextToImage

1

This paper https://lnkd.in/eGaCaD7s shows that calibrating LLMs to the distribution of their training set always leads to hallucination, at a probability lower bounded by Good-Turing frequency estimation. Good-Turing frequency estimation https://lnkd.in/ewrh3RZC was developed to estimate the frequency of discovering a new species. Assuming the discovery of new species follows i.i.d., then its frequency can be reasonably estimated by the historical discovery rate, which is N_1 / N​, where N_1​ is the number of species observed only once (a.k.a., new discoveries), and N is the total number of observations. Now, calibrating LLMs forces them to emit only in-distribution facts (known species) and zeros out the probability of out-of-distribution facts (unknown species). Therefore, calibrated LLMs will hallucinate when the question is OOD, at a rate of N_1 / N​​. And there is no cure, as non-calibrated LLMs can be even worse. #artificialintelligence #machinelearning #deeplearning

208

18 commentaren

A very useful checklist to follow when you have to put in production Transformer based models

5

Does Fine-tuning Increase Hallucinations? Perhaps... From this paper: https://lnkd.in/gMZUUwVg "We demonstrate that large language models struggle to acquire new factual knowledge through fine-tuning, as fine-tuning examples that introduce new knowledge are learned significantly slower than those consistent with the model's knowledge." Okay, this is what we expect, more or less. And then there's this: 👉 "However, we also find that as the examples with new knowledge are eventually learned, they linearly increase the model's tendency to hallucinate" Uh-oh - fine-tuning can increase hallucinations! What's the takeaway? Anyone paying attention to LLMs should realize by now that your evaluation strategy and effective search for an optimal solution is vital to success. Following a formula, like "RAG + Fine-tuning = My-domain LLM" is merely a starting point. Experiments have consistently shown that "out of the box", such formulations can perform very badly even though they give the impression, upon initial inspection, of being incredibly powerful. Don't be fooled by "demo wow-factor-ness"!

2

Closing thoughts on PyData Eindhoven, data scientists have a very good understanding regarding good uses cases for Generative AI, and, as well, use cases that don't really fit Generative AI and are better served by other approaches. For those use cases, the discussion is about monitoring, quality control and management of AI applications. My talk was the first talk in the back-up list, however, none of the titular roster speakers needed to excuse him/her self, so it would be next year. For those wondering what my talk was to be about, check the following repo :) https://lnkd.in/ehwC7h4H

12

Using your M4 iPad Pro as an external GPU/Neural Processor for your AI models ... a follow-up to the Apple MLX post about Apple being the value solution for training and inference from a few weeks ago ... With the release of Apple's M4, the listed specs for the included Neural engine increased TOPS (trillions of operations per second) by about 5% when using INT8 precision. But direct benchmarking tells a little bit of a different story because Key Value caching is faster on the M4 and that can improve model performance more than increased TOPS in the M4 chip's neural processor. The only way to target models to run on the Neural Engine is to use CoreML (coremltools) or reverse engineer CoreML models yourself from the coremltools source. It's an open source tool written by Apple to port a model from various toolkits like PyTorch, Tensorflow, SciKit, etc. To force a model to run on ANE (the Neural Engine), target the output to run on CPU+ANE (and not GPU). Unlike an Nvidia GPU, Apple doesn't document how to directly observe CoreML and Neural Engine performance metrics. When you build for an Apple handheld, you have to iteratively benchmark different approaches on different hardware to make choices about model, cache, stepwise iteration, and other algorithmic approaches. MLX, Apple's tool to allow multi-Mac neural networking inference and training through Thunderbolt chained systems, doesn't support the use of the Neural Processor. But a quick decomposition of MLX shows that it is possible to use the MLX approach for training/inference on multiple systems with a mixture of ANE, CPU, and GPU on each system. It's hard to use ANE because it is so opaque. But some algorithms will benefit from using ANE for interim inference steps. It is a good exercise for a student to expand and write about multi-machine usage of ANE within the MLX framework. So, for clarity, it is possible for students and other value seeking ML developers to use an iPad Pro as an external GPU and Neural Processor during algorithmic development by using a modified version of MLX. I may show an example, but I hope someone beats me to the punch with a more generalized version of MLX.

13

Kolmogorov-Arnold networks, rooted in the Kolmogorov-Arnold representation theorem, provide a sophisticated mathematical approach to decomposing high-dimensional functions into more manageable sub-functions. This capability is a game-changer compared to traditional neural networks, which often struggle with dimensionality and computational complexity. Comparative Advantages: - Efficiency: These networks handle high-dimensional data more efficiently, reducing the computational burden while maintaining high accuracy. - Interpretability: Unlike deep learning models that act as "black boxes," Kolmogorov-Arnold networks offer greater transparency in their operations, a key advantage in financial applications where understanding the decision-making process is critical. - Scalability: They scale more gracefully with increasing data size and complexity, a crucial factor in dynamic environments like banking. Why is this shift important? ◾Enhanced Risk Management: We achieve more accurate risk assessments, essential for maintaining financial stability. ◾Deeper Customer Insights: These networks help us parse complex customer data sets, enabling more targeted and personalized services. ◾ Operational Improvements: Streamlined data processing leads to cost reductions and improved service delivery. For a deeper into KANs, including theoretical discussions and practical examples, the full article is below: https://lnkd.in/d9SddzqP

20

https://lnkd.in/eyt9tKfN Interesting variation of non causal approach to teaching structured problems to llms

2