Good question! I am collecting human data on how quantization affects outputs. See here for more information: ggml-org/llama.cpp#5962
In the meantime, use the largest that fully fits in your GPU. If you can comfortably fit Q4_K_S, try using a model with more parameters.
See the wiki upstream: https://github.com/ggerganov/llama.cpp/wiki/Feature-matrix
| services: | |
| ts-ollama-ui: | |
| image: tailscale/tailscale:latest | |
| container_name: ts-ollama-ui | |
| hostname: ollama-ui # http://ollama-ui.<tailnet>.ts.net | |
| extra_hosts: | |
| - "host.docker.internal:host-gateway" # important for ollama web ui to communicate with ollama running locally | |
| environment: | |
| - TS_AUTHKEY=<YOUR_OAUTH_KEY / YOUR_AUTH_KEY > | |
| - "TS_EXTRA_ARGS=--advertise-tags=tag:container --reset" ## only needed if you use YOUR_OAUTH_KEY with owner tags |
WebAssembly is a low-level language for a portable virtual machine. Wasm is designed to be a compilation target for a variety of programming languages and its design is hardware independent and relatively simple, making its support ubiquitous in modern browsers. Its simple design made it a perfect first candidate for a first emulator of an conventional computational system on a novel functional computer: Urbit. In this paper I discuss the current state of urwasm project and some technical details, as well as describe the strategy to jet the interpreter of a state machine in a functional environment.
I've recently been amazed, if not mind-blown, by how a very simple, "one-line" SAT solver on Interaction Nets can outperform brute-force by orders of magnitude by exploiting "superposed booleans" and optimal evaluation of λ-expressions. In this brief note, I'll provide some background for you to understand how this works, and then I'll present a simple code you can run in your own computer to observe and replicate this effect. Note this is a new observation, so I know little about how this algorithm behaves asymptotically, but I find it quite
| // A nano dependent type-checker featuring inductive types via self encodings. | |
| // All computation rules are justified by interaction combinator semantics, | |
| // resulting in major simplifications and improvements over old Kind-Core. | |
| // Specifically, computable annotations (ANNs) and their counterpart (ANN | |
| // binders) and a new self encoding based on equality (rather than dependent | |
| // motives) greatly reduce code size. A more complete file, including | |
| // superpositions (for optimal unification) is available on the | |
| // Interaction-Type-Theory repository. | |
| // Credits also to Franchu and T6 for insights. |
(map page-number=@ page-array=@)block/loop/if and call/call_indirect execution: it appears that the current model causes unnecessary copies of the entire membuffer, slowing down the computation. So instead of cloning the core, interpreting an expression and back-propagating changes in the global state, I need to call an evaluating arm that will edit the global state in-placefetch-operation within apply-instruction that takes term of an instruction as an argument and returns a number of operands to be consumed and a gate to be applied to the immediate arguments and consumed operandshwasm coreterm is a direct atom)
This was first posted on ~2022.3.16 in a group that no longer exists, based on the first few weeks of my experience in the first Hoon School Live cohort. Reuploaded here for posterity, which means some points are out of date.
Not less because in purple I descended
The western day through what you called
The loneliest air, not less was I myself.What was the ointment sprinkled on my beard?
What were the hymns that buzzed beside my ears?
What was the sea whose tide swept through me there?
>
The target audience is people who are familiar with Urbit's architecture, though not necessarily much of its code.
As some of you already know, i recently left my job as a core dev for the Urbit Foundation to work on a similar system called Plunder. Plunder was created in 2020 by two former Tlon employees, after their proposal for a new version of Nock was rejected. They have since reworked that significantly and built a reference implementation of their own system. You can follow its continued development on its mailing list.
I've known about Plunder for quite some time now, but their recently released demo -- in which the system is used to serve a 70 GB dataset, complete with metadata and searchable -- made me feel the need to explore it again and in greater detail. Doing this with my personal server doesn't feel like a big ask, but there is currentl
| => | |
| |% | |
| +$ ulam | |
| $~ [%coin *coin] | |
| :: leaves | |
| :: | |
| $% [%coin =coin] :: atom, noun, or compound coin | |
| [%path =pith] :: hoon path syntax | |
| [%page =mark noun=*] :: %foo|bar, bar is coin blob | |
| :: |
| import time | |
| from contextlib import suppress | |
| import torch | |
| import torch.nn as nn | |
| import torch.optim as optim | |
| import torch.nn.functional as F | |
| import torch.backends.cuda as cuda | |
| from torch.utils.data import DataLoader, IterableDataset |