Interests: programming, video games, anime, music composition

I used to be on kbin as e0qdk@kbin.social before it broke down.

  • 0 Posts
  • 43 Comments
Joined 3 years ago
cake
Cake day: November 27th, 2023

help-circle
  • If you just pulled the default version of qwen3.5 from ollama’s repo you downloaded a mediocre one that only uses ~6GB.

    Check ollama show qwen3.5 and see if you get something like this in the result:

      Model
        architecture        qwen35    
        parameters          9.7B      
        context length      262144    
        embedding length    4096      
        quantization        Q4_K_M 
    

    This is the default version I got when I first tried using ollama without any experience. It worked, but it’s a heavily quantized, lower parameter version of the model – i.e. it’s pretty dumb – compared to what you can actually run on your hardware.


  • e0qdk@reddthat.comtoSelfhosted@lemmy.worldDo you host your own AI?
    link
    fedilink
    English
    arrow-up
    3
    arrow-down
    1
    ·
    15 hours ago

    I started running LLMs a couple months ago on my own hardware. I have a Framework Desktop that I ordered last year and also recently picked up a refurbished 24GB AMD RX 7900 XTX which I’m doing some performance testing against. The dGPU is much better for dense models, and slightly faster for MoE if I’m willing to run them at a lower quant – but uses more power and has annoying coil whine. The Framework Desktop uses ~100W under load, is quieter, and for the MoE models already runs them fast enough for most of my needs – so most of my LLM use happens on that system still.

    For software: I’m using ollama on the Framework currently, but I want to replace it with just using llama.cpp directly eventually. I’ve been using llama-cli for testing the dGPU. I wrote my own chat client to interact with ollama as well as a few other programs for specific tasks.

    I’ve been using the LLMs for a mix of research (both personal and professional), entertainment, practical coding tasks (mostly debugging and brainstorming, plus a bit of UI prototyping, automatic generation of sequence diagrams for documentation, and light scripting), as well as automation of tedious tasks.

    As an example of the latter, people often send me requests to prepare data sets by email but don’t specify the sources they want precisely so I have to go match the name against the real name in our archives; LLMs are great for mapping the imperfect name – with typos, missing prefixes, incorrect addition of spaces, addition/removal of hyphens, etc. – to the exact name I actually need to pull the data off disk when given a lookup table to compare against.

    As far as models go, I’m mostly using various Qwen 3.6 and Gemma4 variants. I have multiple versions of each for different purposes. llmfan46’s uncensored Qwen 3.6 35B-A3B @ Q6_K (from Hugging Face) is my default model currently.


  • I tried throwing this image at qwen3.6 locally with the prompt “What is in this image?” and it spat out:

    Based on the visual evidence, this is a micrograph (a photograph taken through a microscope) of bacteria.

    Here is a breakdown of what you are seeing:

    • Organism Type: These are bacteria. You can tell by their small size relative to the scale bar in the bottom right corner (which represents 10 micrometers).
    • Stain: They are stained purple/blue, which indicates they are Gram-positive bacteria. In a Gram stain, Gram-positive bacteria retain the crystal violet dye and appear purple.
    • Shape: The individual bacterial cells are spherical or round, which classifies them as cocci (singular: coccus).
    • Arrangement: The most distinct feature is that the cocci are arranged in chains.

    Conclusion: This image shows Gram-positive cocci in chains, which is the characteristic appearance of bacteria from the genus Streptococcus (or possibly Enterococcus). Common examples include Streptococcus pyogenes (which causes strep throat).

    So you might be able to get further than you expect. You might try collecting some of your own sample data for things you understand (like particular bacteria you’re interested in) and providing those images along with a prompt that includes labels for your sample imagery. (Like “Image 1 is an example of (…whatever…). Image 2 is an example of (…something else…). Which (if any) of these are in Image 3?”)

    I don’t know how well it would work, but worth a try.

    The dream, for me, is to get it to understand the protein structure files and DNA sequence files

    Even then, much of what I’d want help with looking at proteins is how to write analyses of points in 3D space

    I tried throwing this image at qwen3.6 as well, and it spits this out (but takes a REALLY long time to do it on my local hardware):

    Based on the visual evidence, this image is a 3D molecular visualization of a protein structure, likely created using software such as PyMOL, UCSF Chimera, or VESTA.

    Here is a breakdown of the specific components visible in the image:

    1. The Protein (Blue Ribbon):

      • The large, coiling blue structure is the protein backbone.
      • It is rendered as a “ribbon” or “cartoon” diagram, which is a standard way to visualize the secondary structure of proteins.
      • The coiled sections represent alpha-helices, which make up the majority of this protein’s structure. This “helix bundle” fold is characteristic of proteins in the globin family, such as myoglobin or hemoglobin, which are responsible for oxygen transport and storage.
    2. The Central Ligand/Co-factor (Middle Right):

      • Nestled within the protein fold is a complex molecule shown in a “stick” and “sphere” representation.
      • The Flat Ring: You can see a flat, ring-like structure with blue sticks (representing nitrogen atoms). This is characteristic of a porphyrin ring.
      • The Red Sphere: There is a large red sphere in the center of the ring. In this context, this almost certainly represents an Iron (Fe) atom.
      • Conclusion: This complex is a heme group (or heme prosthetic group). Heme is the molecule responsible for binding oxygen in hemoglobin and myoglobin, or for electron transfer in cytochromes. The long chains extending from the ring are likely the side chains of the heme molecule (propionate groups) or a bound drug/inhibitor interacting with the iron.
    3. The Ion (Bottom Right):

      • There is a small molecule floating near the bottom right of the protein.
      • It has a yellow center with four red arms arranged in a cross/tetrahedral shape.
      • In chemical coloring (CPK coloring), yellow represents Sulfur and red represents Oxygen. This indicates a Sulfate ion ($SO_4^{2-}$). Sulfate ions are common in crystal structures of proteins and are often used to stabilize the structure or mimic phosphate groups.

    Summary: You are looking at a structural biology model of a protein (likely a globin like myoglobin) containing a heme cofactor (the molecule with the iron) and a sulfate ion. This type of image is used by scientists to understand how the protein works at the atomic level.

    You might be able to it to do something useful with analysis of protein renderings, but I think you’ll need some creativity with the prompts to stop it from overthinking things… It was able to recognize this as myoglobin in the “thinking” stage quickly enough, but then kept second guessing itself about various aspects for a long time. I also tried throwing it at gemma4 but it didn’t really give me much besides recognizing it as some sort of protein structure.

    hook it up to some lab robotics and automate experiments

    You might find this project and associated HN post interesting – it’s basically someone doing that with electronics analysis instead of biology, IIUC. No idea how well it works, but interesting to look at and think about.

    Maybe there’s a coding community on lemmy that’s a decent place to talk shop on how to build these scripts up and what local models are good at what?

    There’s !localllama@sh.itjust.works and probably some communities on lemmy.dbzer0.com as well – they’re not super-active though (at least from what’s made it to my attention browsing by all).


  • non-text based problems

    I don’t know enough about the specifics of what you’re doing to really give detailed suggestions, but I have been surprised by models like qwen3.5/3.6 giving reasonable results to questions about images – like answering questions based on comparing a few images. For example:

    • Which of these images were taken from the same place?
    • Which of these images were taken in the AM and which in the PM?
    • Is the third image more like the first or the second? Answer “1” or “2” only indicating which of the first two images it is most similar to.
    • What sort of tags would you attach to these images? Provide a list of tags as JSON as the only response.

    Those prompts actually worked for imagery from camera systems I have to deal with for my job – which, frankly, shocked me. The AM/PM one in particular read timestamps in the image (i.e. did OCR automatically) and converted from a 24 hour clock to answer the question. I’ve implemented that in scripts with older computer vision tools (like tesseract) that needed a lot of hand holding; the fact that current models can just do it is sort of mind blowing to me…



  • My limited understanding of “agentic AI” is that it’s LLMs prompted by a script repeatedly in a loop. e.g. You give it an initial prompt, the LLM spits out a response indicating what it thinks it should do next (like run a program) and the script looks at the output of the LLM, does what is asked if it can, then feeds the results back in as the next prompt (or tells the LLM that it can’t/won’t do that if so programmed, I assume), until the LLM indicates to the script in one of its responses that the complex task is done – or indefinitely if the prompt is the sort that will never terminate.

    You can limit what the overall system is capable of by careful design of the control script – just using LLMs to bridge the gaps for tasks that are hard/impossible to program traditionally. For controlling a robot, I’d guess that you’d want to have actions for things like taking a picture with a camera (or reading other sensors) that the LLM can analyze, repositioning arms, controlling motors, etc?

    If I knew how to set up a robotic arm that could safely turn the pages of a traditional book, then combining it with a camera or flatbed scanner, a couple different vision models + traditional OCR (to sanity check each other), and wiring the whole thing up with a custom script to make really high-quality ebooks out of the books I own that no one has bothered to digitize would be neat… Maybe some day.

    You might get more informed responses on db0 or another site; most of Lemmy is straight up AI-hostile. I have mixed feelings on it personally – I really don’t like the AI companies DDOSing the internet for profit while driving up the cost of electronics (etc), but writing off local AI tech entirely also seems like throwing out the baby with the bathwater to me…


  • Adding to this, the money to repay bonds has to come from somewhere – usually taxes. So, if a government issues a bond it is committing to collecting the amount of money for the bond-plus-interest from the populace. It’s the government taking out a loan, essentially, on the basis that it can use long term tax revenue for repayment.

    Why not just use taxes directly then? Sometimes you need a lot of money for a specific project and it would take too long to collect that money through taxes at a rate that is reasonably payable by the populace over a short enough time frame.

    Suppose you need a million dollars to cover the cost of replacing some infrastructure – like a critical pipeline for your town’s drinking water – but you only have 100 people in your small town. That’s $10,000 per person if the cost is split evenly. The people in town may not have that much money to pay all at once, but getting the pipe fixed so they have water to drink is really important. So, the government gets a loan (i.e. issues a bond) and pays out the amount plus interest over a long period of time. Adding 5% interest and breaking the payments up over a 30 year term would require everyone in that hypothetical town to need to pay about $30/mo more in taxes to cover the cost. That’s probably a lot more politically feasible to actually collect than trying to get everyone to pitch in $10k right now.





  • No, we are communicating. People can coordinate their actions to achieve things that are impossible for an individual. We obviously don’t have perfect shared understanding, and miscommunications are not uncommon (as others have already pointed out) but we can exchange enough information to do useful things.

    Also, we can make jokes. The fact that it’s possible to craft a joke and make someone laugh by setting up and intentionally subverting expectations through language is pretty good evidence that we have shared understanding and similar processing.


  • e0qdk@reddthat.comtoFediverse@lemmy.worldGhost of Lemm.ee?
    link
    fedilink
    English
    arrow-up
    56
    ·
    5 months ago

    Looking back through your history, that’s a post by a user local to your instance. You can see it because you’re on the same instance.

    If I understand how federation works correctly, posts don’t go directly to the instance a community is on when they are made. They are created locally on your own instance, and then federate out if/when they can. Since you’re both on the same instance, you can see the post and interact with it, but the post and your comments are (presumably) stuck in a queue trying to federate to the now defunct instance. Since lemm.ee is gone, it can’t federate out, so other people don’t see the post/comment on their instance.

    I think that’s what’s going on.



  • Should be trivial to set up something like that if you’ve got parts you want to work with. Any desktop with an automatic background switcher should be able to cycle through images in a directory you specify on a timer. Set up your favorite remote access software (SSH, Samba, NFS …) and you’re done. If you want more control over the behavior, you could script up something custom with a little more effort – but it’s still not particularly hard to implement something like that.

    Watch out for burn in on the screen if you’re leaving it on all the time.