rhdunn

The following should be compatible with both approaches:

    .masonry {
      display: grid;
      display: grid-lanes;
      grid-template-columns: repeat(auto-fill, minmax(180px, 1fr));
      grid-template-rows: masonry;
    }

Firefox and browsers supporting the old syntax will ignore the `display: grid-lanes` as it doesn't recognize it and fall back to the grid+masonry.

Browsers supporting the new syntax will override the `display: grid` with `display: grid-lanes` and ignore the `grid-template-rows: masonry` syntax.

Using texts upto 1913 includes works like The Wizard of Oz (1900, with 8 other books upto 1913), two of the Anne of Green Gables books (1908 and 1909), etc. All of which read modern.

The Victorian era (1837-1901) covers works from Charles Dickens and the like which are still fairly modern. These would have been part of the initial training before the alignment to the 1900-cutoff texts which are largely modern in prose with the exception of some archaic language and the lack of technology, events, and language drift post that time period.

And, pulling in works from 1800-1850 you have works by the Bronte's and authors like Edgar Allan Poe who was influential in detective and horror fiction.

Note that other works around the time like Sherlock Holmes span both the initial training (pre-1900) and finetuning (post-1900).

AI is a broad term going back to 1955. It covers many different techniques, algorithms, and topics. The first AI chess programs (DeepBlue, et. al.) were using tree search algorithms like alpha-beta pruning that are/were classified as AI techniques.

Machine translation is a research topic in AI because translating from one language to another is something humans are good at while computers are not traditionally.

More recently, the machine learning (ML) branch of AI has become synonymous with AI as have the various image models and LLMs built on different ML architectures.

We are still in the exploratory phase of what features are useful or not.

I could see describing images useful for blind or vision impaired people. Publishers often have a large back catalogue of documents where it is both impractical and too costly/time consuming to get all the images in those described with alt tags. This is one area where the publishers would be considering using AI.

Text-to-speech and speech recognition also fall under the category of AI and these have proven useful for blind/visually impaired people and for people with injuries that make it difficult to use a mouse and keyboard.

On the search side it would be interesting to see if running the user's query through an encoder and using that to help find the documents would help improve finding search results. This would work like current TF-IDF (Term Frequency, Inverse Document Frequency) techniques work.

Plus simple caching to not redownload the same file/page multiple times.

It should also be easy to detect a forejo, gitea, or similar hosting site, locate the git URL and clone the repo.

If you are finetuning the model you need to replicate the training conditions so you don't remove those capabilities. If you just finetune a multi-modal model on text it will lose some of the vision capabilities as the text part of the model will drift from the vision, audio, etc. models. A similar thing happens with finetuning reasoning models.

Even if you did finetune the models with text and images then you could run into issues with using different descriptions for images to what it was trained with. Though you could probably work around that by getting the model to describe the images, but you'll still need to audit the results to correct any issues or add what you are training for.

You can also run into overfitting if your data does not include enough variations along a given training set that the original model had access to.

Using different training parameters could also affect the models capabilities. Just knowing things like the input context isn't enough.

I have a ssh-switch script that runs `ssh-add -D` and `ssh-add $KEY_FILE` so I can do `ssh-switch id_github`, etc. This is coupled with a `/etc/profile.d/ssh-agent.sh` script to create a ssh agent for a terminal session.

The safetensors file format is a header length, JSON header, and serialized tensor weights. [1]

[1] https://github.com/huggingface/safetensors

Re 2 I was wondering if there may be some GR effect as well, as the element's nucleus would have some effect on spacetime curvature and the electrons would be close to that mass and moving very fast.

For geostationary orbits I was thinking of things like how you need to use both special and general relativity for GPS when accounting for the time dilation between the satellite and the Earth (ground). I was wondering if similar things would apply at a quantum level for something QM related so that you would have both QM and GR at play.

So it may be better to have e.g. entangled particles with them placed/interacting in a way that GR effects come into play and measuring that effect.

But yes, devising tests for this would be hard. However, Einstein thought that we wouldn't be able to detect gravitational waves, so who knows what would be possible.

The testable predictions would be at the places where QM and GR meet. Some examples:

1. interactions at the event horizon of a black hole -- could the theory describe Hawking radiation?

2. large elements -- these are where special relativity influences the electrons [1]

It's also possible (and worth checking) that a unified theory would provide explanations for phenomena and observed data we are ascribing to Dark Matter and Dark Energy.

I wonder if there are other phenomena such as effects on electronics (i.e. QM electrons) in GR environments (such as geostationary satellites). Or possibly things like testing the double slit experiment in those conditions.

[1] https://physics.stackexchange.com/questions/646114/why-do-re...

In a way this is what notebooks are for Python and other languages. They mix documentation and code such that you can run that code and inspect the output. See for example the pytorch tutorials.

Blameless post mortems should be similar to air accident investigations. I.e. don't blame the people involved (unless they are acting maliciously), but identify and fix the issues to ensure this particular incident is unlikely to recur.

The intent of the postmortems is to learn what the issues are and prevent or mitigate similar issues happening in the future. If you don't make changes as a result of a postmortem then there's no point in conducting them.

If someone publishes a novel when they are twenty and dies when they are 90 the novel won't be in the public domain for 140 years. That's rediculous.

It allows you the freedom to publish works in those worlds, reference characters, etc. See for example the horror game Alice: Madness Returns based on the Alice in Wonderland series.

Lord of the Rings (1954-1955) has only recently entered the public domain for life+50 countries due to JRR Tolkien dying in 1973, despite the work being over 70 years old. It won't enter the public domain in life+70 countries until 2044.

Only recently are works written in the early to mid 1900s being released in the public domain. This limits the works to around the first world war. For example:

- HG Wells (Died 1946, Life+70 in 2017), works like War of the Worlds and The Time Machine.

- LM Montgomery (Died 1942, Life+70 in 2013), works like Anne of Green Gables -- In the US where publication + 90 years is in effect, her later works (after ~1925) are not yet in the public domain there.

With comic IPs, most are not yet in the public domain:

- Superman (1938, P+95 of 2034) and will only cover that incarnation of the character.

- Batman (1939, P+95 of 2035) and will only cover that incarnation of the character.

So the current copyright terms are very limiting for IPs that are nearly a decade old.

For just the model itself: 4 x params at F32, 2 x params at F16/BF16, or 1 x params at F8, e.g. 685GB at F8. It will be smaller for quantizations, but I'm not sure how to estimate those.

For a Mixture of Experts (MoE) model you only need to have the memory size of a given expert. There will be some swapping out as it figures out which expert to use, or to change expert, but once that expert is loaded it won't be swapping memory to perform the calculations.

You'll also need space for the context window; I'm not sure how to calculate that either.

Like this?: https://huggingface.co/TheDrummer/Rivermind-12B-v1

It could be that they weren't able to produce stable video -- i.e. getting a consistent look across frames. Video is more complex than image because of this. If their architecture couldn't handle that properly then no amount of training would fix it.

If they found that their architecture worked better on static images then it is better to pivot to that than wasting the effort. Especially if you have a trained model that is good at producing static images and bad at generating video.

Reading the post the architectural change is combining a vision model (Mistral 3 in the flux.2 case) with a rectified flow transformer.

I wonder if this architectural change makes it easier to use other vision models such as the ones in Llama 3 and 4, or possibly a future Llama 5.

Veritasium did a video on this [1] with a surface of oil to replicate the effect on a petri dish.

[1] https://www.youtube.com/watch?v=WIyTZDHuarQ

Quantum Electro-Dynamics (QED) is the application of Special Relativity (non-accelerating frames of reference, i.e. moving at a constant speed) to Electromagnetism. Thus, the issue is with applying accelerating frames of reference (the General in GR) to QM.

It depends on what you are doing.

If you are working on an application that has several services (database, local stack, etc.) as docker containers, those can take up more memory. Especially if you have large databases or many JVM services, and are running other things like an IDE with debugging, profiling, and other things.

Likewise, if you are using many local AI models at the same time, or some larger models, then that can eat into the memory.

I've not done any 3D work or video editing, but those are likely to use a lot of memory.

The entire publishing and standards industries are built around XML (JATS and other XML formats). They use XSLT to generate HTML, PDF, EPUB, and other format files.

I don't see the XML-based SVG image format going anywhere.

The ODF, EPUB, and other formats also use XML. Those are not dying.

I used Gitea for a while. I eventually switched to gitolite and CGit primarily because Gitea (and Forgejo) force you into a flat organization/project structure. This makes organizing personal projects harder because:

1. you need to create an organization for each group (lang, tools, template, etc.)

2. you can't create more complex organization structure (e.g. template/python/python-flask-template)

3. you can't group projects with different top-level names (e.g. apps, tools, lang; such as lang/java and tools/gradle) or across a top-level name (e.g. by programming language such as lang/typescript and lang/python)

Yeah. I think I got to around 10-15 before I got stuck. It's been several years since I attempted it though.

I've personally found the opposite. In order to advance you need to know the specific techniques or mathematics and there are no hints or information on how to approach the problem. So it boils down to how much of that mathematics you know. If you don't then the brute force approaches take a long time to find the solution.

Here's Sabastian Lague's (Coding Adventure) video on font rendering -- https://www.youtube.com/watch?v=SO83KQuuZvg.

There are many accessibility issues with using a screenshot of text instead of text directly:

- displaying a white background image of text when I'm using dark mode;

- using a small font to a user with a visual imparement or on a high DPI display;

- using a colour scheme with low contrast, or colours that are indistinguishable for people with a form of colour blindness;

- using a font that is difficult to read for someone with dislexia;

- etc.

And others have mentioned not being able to search for the text within the image, or select/highlight the text (useful for copying a function name, link, or term in the text, or for keeping track of where you are when reading).

libxslt != XSLT.

It's like removing JPEG support because libjpg is insecure!

Widelands is based on/inspired by Settlers II.