hazrmard

Does the peak starting in mid-2020 correspond to mass speculative / adversarial / bandwagon hiring by tech companies during the pandemic?

Looks fun, but I don't quite understand this product:

  - Do the buttons map to configurable skills / prompts?
  - Is it meant to be used remotely with some independence (like codex remote), or is it a peripheral like a trackpad?

You'd be right to be surprised by lack of mention of quaternions. I (blog author) was not too familiar with them when I did the work this post is based on. With the benefit of hindsight, I may yet revise the post.

Hello, blog author here. I agree the math appears overkill. I wrote this as a learning aid for myself with the benefit of hindsight of having worked with some drone sims. I wanted to dispel any doubt in my mind that I could derive drone physics from basic principles, instead of copy-pasting state equations. I went further and tried to motivate transport theorem, rotational analog of F=ma etc from scratch.

In summary: I take F=ma and extend it for rotational motion. (1) Calculating linear motion when the vehicle containing sensors is rotating. (2) Calculating rotation of the vehicle itself due to thrust/yaw force acting about its center of mass.

I'll echo what the other commenter said: this is no way PhD math. It may appear so - but I'm only being verbose with simpler concepts like cross products and rotation matrices.

It's my blog. Bartosz Ciechanowski's work was my inspiration!

Good work! I wonder if meta-learning can play a better role here compared to heuristics or hindsight. MAML requires hessians, but first-order MAML or Reptile variants could help apply layer-wise adjustments to learning rates.

These day's I'm super-into information theory and entropy, so I liked the connection made at the end. I'm a visual person, and I found this schematic of SVD on the wikipedia page very insightful [1].

[1] https://en.wikipedia.org/wiki/Singular_value_decomposition#/...

This is very impressive! I researched fault-tolerant octorotor control using RL in grad school for a NASA project. Perhaps this may be helpful[1, see section 8.3]! The field is moving fast, so there may be better or more suitable approaches out there now.

For folks who are interested in UAV physics, I wrote up an explainer[2].

[1] https://drive.google.com/file/d/1RTEVRd0XCWLuDXY2nkbmYuOaa5x...

[2] https://iahmed.me/post/drone-physics/

Check my understanding & follow-up Qs:

An auto-encoder is trained on [activation] -AV-> [text] -AR-> [activation], where [activation] belongs to one layer in the LLM model M.

Architecture.:

    Model being analyzed (M): >|||||>  
    Auto-Verbalizer (AV) same as M, with tokens for activation: >|||||>  
    Auto-Reconstructor (AR) truncated up to the layer being analyzed: ||>

The AR is trained on a simple reconstruction loss.

The AV is trained using an RL objective of reconstruction loss with a KL penalty to keep the verbalizations similar to the initial weights (to maintain linguistic fluency).

- Authors acknowledge, and expect, confabulations in verbalizations: factually incorrect or unsubstantiated statements. But, the internal thought we seek is itself, by definition, unsubstantiated. How can we tell if it is not duplicitous?

- They test this on a layer 2/3 deep into the models. I wonder how shallow and deep abstractions affect thought verbalization?

Very cool! Interesting how the choice of solver affects the solution. Euler doesn't handle misbehaved equations very well. You can see this in the Helix setup where the bodies just fly off.

I should read up on Tailscale more. I have been using ddclient[1] or the router's built-in dynamic DNS[2] to set up my servers / homelab. This leaves the endpoints exposed to the public internet, as the author says.

    [1]: https://github.com/ddclient/ddclient  
    [2]: https://kb.netgear.com/1058/What-is-Dynamic-DNS-DDNS

cue the bell curve meme for learning autonomy:

                 ____.----.____
          ______/              \______
    _____/                            \_____
    ________________________________________

    (simulations)  (real world data)  (simulations)

We started with physics-based simulators for training policies. Then put them in the real world using modular perception/prediction/planning systems. Once enough data was collected, we went back to making simulators. This time, they're physics "informed" deep learning models.

    https://iahmed.me

Github Pages deployment.

Here's my first website from when I was in college and had no experience in web dev. I still keep it on for nostalgia:

    https://iahmed.me/old_www/

This reflects my experience. Yet, I feel that getting reliability out of LLM calls with a while-loop harness is elusive.

For example

- how can I reliably have a decision block to end the loop (or keep it running)?

- how can I reliably call tools with the right schema?

- how can I reliably summarize context / excise noise from the conversation?

Perhaps, as the models get better, they'll approach some threshold where my worries just go away. However, I can't quantify that threshold myself and that leaves a cloud of uncertainty hanging over any agentic loops I build.

Perhaps I should accept that it's a feature and not a bug? :)

The paper finds:

- For LLM-assisted output, the more complex the LLM-writing is, the less likely the paper is to be published. From eyeballing, at WC=-30, both have similar chances of publication (~46%). At the upper range of WC=25, LLM-assisted papers are ~17% less likely to be published.

- LLM-assisted authors produced more preprints (+36%).

I wonder:

- What is the distribution of writing complexity?

  * Does the 17% publication deficit at WC=25 correspond to 17% of the 36% excess LLM-assisted papers being WC=25, thus nullifying the effect? Although, it puts extra strain on the review process.

I can vouch for this with my experience.

Back in grad school, I was out making new friends. I was playing tennis 4-5 times a week. I'd invite players for post-game coffees (in the morning) and dinner (evenings) at every game. Consistency mattered. I'd ask every time. Slowly we had our regulars. Our coffee times became an institution in and of themselves.

People are busy, yes. But, people also want to be in demand. People also don't want to be rejected. And, people also don't want to be left out.

Asking around, I was exposing myself to rejection. Some folks appreciated their time being demanded. More still joined because they didn't want to be left out.

Do I understand this right?

A light-weight speculative model adapts to usage, keeping the acceptance rate for the static heavy-weight model within acceptable bounds.

Do they adapt with LoRAs?

This takes me down a memory lane! For my undergrad capstone project, we made a cubesat tracker for our university's satellite using a RPi/Arduino/Software-defined-radio to receive transmissions every time it passed over us. I cringe a little looking at the code now - but it worked!

I agree, cubsats are a wonderful way, for college students even, to tinker with space(-adjacent) tech.

https://github.com/hazrmard/SatTrack

I am working on a budgeting app!

Features:

  - Local. No internet connection needed.  
  - Manual. Every transaction is added by the user.
  - One-off or arbitrarily recurring transactions.  
  - No lock-in. Check out your data any time.  
  - Arbitrary metrics to track performance. 
  - Hosting on the cloud for mobile access. 

I've been using Google sheets + forms for the last 8 years to track my finances. It's worked well, except for minor inconveniences. This app is my answer to my own problems.

Thank you very much! I had been reading up on effect of diet for treatment & management. I like the focus on citations.

Thank you. This is great. I also appreciated the linked code for MinRL (https://github.com/10-OASIS-01/minrl).

Having done research in RL, a big problem with incremental research was to reproduce comparative works, and to validate my own contributions. A simple library like this, with built-in tools for visualization and a gridworld sandbox where I can validate just by observation, is very helpful!

It's great to see proliferation of models in other languages!

Shoutout to Alif, a finetune of Llama 3 8b on Urdu datasets: https://huggingface.co/large-traversaal/Alif-1.0-8B-Instruct

It'd be great to see a comparison.

Good read! I am developing PINNs at work and this certainly helped me recall important concepts. This post used deepxde library [2] to compose the PINN. Can anyone comment on how NVIDIA's modulus [2] compares to this? Modulus appears to be much more verbose and poorly documented.

[1] https://github.com/lululxvi/deepxde [2]: https://github.com/nvidia/modulus

Anomaly detection (AD) can arguably be a value-add to any industry. It may not be a core product, but AD can help optimize operations for almost anyone.

* Manufacturing: Computer vision to pick anomalies off the assembly line.

* Operation: Accelerometers/temperature sensors w/ frequency analysis to detect onset of faults (prognostics / diagnostics) and do predictive maintenance.

* Sales: Timeseries analyses on numbers / support calls to detect up/downticks in cashflows, customer satisfaction etc.

I studied bond graphs in modeling & simulation courses in college. I thought they were so cool! The utility knife of understanding mechanical phenomena.

Until I discovered Hamiltonian physics :)

MATLAB/Simulnk is imperative. They have signal flow/causal approach. So you should know ahead of time which variable causes another variable to change i.e. which is defined first.

Modelica is acausal. You define the variables and how they are related (equations). The compiler handles variable dependencies and resolution internally.

There are pros & cons of each. Both are used for simulating cyber-physical systems.

From the website:

Modelica is a high-level declarative language for describing mathematical behavior. It is typically applied to engineering systems...

We use Modelica quite a bit in HVAC industry. In my case (controls engineer), I can request FMUs of various components from systems engineers for optimization work. (Functional Mockup Unit (FMU)[1]: stand-alone binary representing a dynamical system that can be driven by another application). My background is in Reinforcement learning/Model predictive control/python. Having a physics-driven model written in a domain-specific language which I can embed into my python workflow [2] is convenient.

I will say, Modelica requires a different perspective from "regular" imperative programming (python/matlab). It is a declarative language: you define equations, variables, constraints for a system, regardless of order. The compiler decides how to run the simulation; which variables to solve first etc.

While OpenModelica[3] has come a long way towards making an open source implementation of the language standard, proprietary applications (Dymola) still have an edge in the industry.

[1] https://fmi-standard.org/

[2] https://fmpy.readthedocs.io/en/latest/

[3] https://openmodelica.org/

I agree with the author. My work involves designing simulations for control. Yesterday, I asked GPT-4o to write a python-only simulation for a HVAC system (cooling tower, chiller on the water side, and multiple zones with air handling units on the air side).

It wrote functions to separately generate differential equations for water/air side, and finally combined them into a single state vector derivative for integration. Easy peasy, right?

No. On closer inspection, the heat transfer equations had flipped signs, or were using the wrong temperatures. I'd also have preferred to have used structured arrays for vectors, instead of plain lists/arrays.

However, the framework was there. I had to tweak some equations, prompt the LLM to re-write state vector representations, and there it was!

AI-assisted coding is great for getting a skeleton for a project up. You have to add the meat to the bones yourself.

Very cool. Something similar is Streamline Analyst [1]. It automates preprocessing and model development from an uploaded dataset.

This is great for a more technical user (or student) who want to parse generated code and hack away. Instead [1] generates a dashboard app which is faster to use, but sacrifices interpretability.

[1] https://github.com/Wilson-ZheLin/Streamline-Analyst

I've read the huggingface blog on quantization, and a plethora of papers such as `bitsandbytes`. This was an approachable agglomeration of a lot of activity in this space with just the right references at the end. Bookmarked!