与「G_PAPER」相关的搜索结果

Seednace 2.0 on @flovaai Prompt: Photoshoot Break Vlog A photo studio during a break in shooting, midday. Between shots, a female idol is left alone for a moment and films a behind-the-scenes vlog on her own phone. Bright, bubbly idol energy — genuine smiles, playful expressions, eye contact with the lens, small laughs. Handheld from start to finish, quick and lively, alternating between selfie and mirrorless shots, capturing small moments during the shoot break. Eight short cuts flow together, bouncy, within one continuous space and time. Each cut follows the rhythm of a vlog: greeting → introducing the set → backdrop paper spin → water sip → pose recreation for the camera → softbox light play → laughing at a blooper → stylist calls her back to set. A light ending: excitement as she dashes back toward the camera. **Characters** CHASE — a Korean idol in her 20s. Long straight black hair (past her chest), elegant yet lovely Korean features, dewy glass skin, coral pink lips, big eyes. Slim yet curvy proportions at 33C-26-34. Wearing [outfit — let me know if you want the same pink slip dress or something different, e.g. a photoshoot wardrobe like a satin slip or tailored set]. Pearl-silver drop earrings. The bright, bubbly star of the vlog, filming herself facing the lens. **Storyboard** 1. Photoshoot Break Vlog (midday, indoors, handheld) A photo studio between shots. On camera left, a large roll of seamless backdrop paper, a ring light and softbox stands nearby; behind her, a monitor cart showing the last shot; on the right, a small table with her phone and a water bottle. She's alone for a moment during a break in the shoot, still in full hair and makeup, filming a vlog on her phone. Quick, cheerful handheld. (Cut 1 · ~2 sec · front-facing selfie, arm's length) She leans into the lens with a bright smile and a quick hand-heart, hair swaying into frame, catching the ring light in her eyes. CHASE: "Hi hearts, quick break!" (Cut 2 · ~2 sec · whip pan, handheld POV) Phone swings from the backdrop paper → to the softbox lights → to the monitor cart, then snaps back to her face. CHASE (off-screen, playful): "This is the set!" (Cut 3 · ~2 sec · playful spin against backdrop) She steps onto the seamless paper and does a quick twirl, arms out, laughing at herself. CHASE: "Testing my angles!" (Cut 4 · ~1.5 sec · macro insert, shallow depth of field) Detail shot: fingers brushing a strand of hair back, earrings catching the softbox glow. No dialogue — soft fabric rustle only. (Cut 5 · ~2 sec · medium handheld, phone tracking her) She recreates a pose from the shoot — chin tilt, soft hand near her face — holding it for a beat before breaking into a grin. CHASE: "That's the pose from earlier!" (Cut 6 · ~2 sec · snappy cut, close handheld) She grabs her water bottle from the side table and takes a quick sip, exhaling happily afterward. CHASE: "Okay, hydration break!" (Cut 7 · ~1.5 sec · quick punch-in, tight selfie) She glances at the monitor off-camera, laughs at something on it, covering her mouth. CHASE: "Wait, that shot was so funny—" (Cut 8 · ~2 sec · arm's-length selfie finish) An off-screen stylist calls her back to set — her eyes light up with excitement. Quick wave, wink, hand-heart, then she jumps out of frame — camera lingers half a beat on the backdrop paper. CHASE (jumping up): "Back to it! Bye~!" Want me to adjust the outfit, add a second person (stylist/photographer voice), or lock this in as the final version? #flovaai# #flovacpp#

Since the AoE 2 paper seems to have picked up steam (ayyy), and IT IS 13 dense af PAGES, I would like to clarify a few things: 1. I do not deal with consciousness bc it isn't well-defined nor measurable, 2. The AoE II bit is for substrate dependence, and 3. The core argument/proof of the paper is that claiming existence (or lack thereof) human-like attributes needs better experimental setups. Using AoE II (and later Boston) is to emphasise the distinction between our interpretation of what AI does when we observe it, vs what it does. E.g., an LLM outputting an explanation is a sequence of tokens. Calling it an 'explanation' is our observation of it. Assuming it means something (like self-awareness) is an assumption impacting your experimental setup and thus your conclusions. The paper is dense because one needs to be careful when providing these types of arguments (otherwise, trust me, it'd been a lot shorter). So I wrote a less-formal, more-digestible thing here:

I started using the concept in 2016 (e.g. in my NIPS 216 keynote, in which I called it a "world simulator"). I published papers on video prediction in 2016. This was meant to be a key step to train world models. Ha&Schmi appeared in 2018. The slide below is from a talk I gave at Brown in Nov 2017. Full deck here: We were hoping to train world models through video prediction. At the time, we were using generative architectures. We tried latent-variable models and GAN-style training. But never quite worked on natural video. Around 2021, I realized that predicting at the pixel level was not a good idea. That's when the JEPA concept emerged: find an abstract representation within which predictions are performed.

LLM Knowledge Bases Something I'm finding very useful recently: using LLMs to build personal knowledge bases for various topics of research interest. In this way, a large fraction of my recent token throughput is going less into manipulating code, and more into manipulating knowledge (stored as markdown and images). The latest LLMs are quite good at it. So: Data ingest: I index source documents (articles, papers, repos, datasets, images, etc.) into a raw/ directory, then I use an LLM to incrementally "compile" a wiki, which is just a collection of .md files in a directory structure. The wiki includes summaries of all the data in raw/, backlinks, and then it categorizes data into concepts, writes articles for them, and links them all. To convert web articles into .md files I like to use the Obsidian Web Clipper extension, and then I also use a hotkey to download all the related images to local so that my LLM can easily reference them. IDE: I use Obsidian as the IDE "frontend" where I can view the raw data, the the compiled wiki, and the derived visualizations. Important to note that the LLM writes and maintains all of the data of the wiki, I rarely touch it directly. I've played with a few Obsidian plugins to render and view data in other ways (e.g. Marp for slides). Q&A: Where things get interesting is that once your wiki is big enough (e.g. mine on some recent research is ~100 articles and ~400K words), you can ask your LLM agent all kinds of complex questions against the wiki, and it will go off, research the answers, etc. I thought I had to reach for fancy RAG, but the LLM has been pretty good about auto-maintaining index files and brief summaries of all the documents and it reads all the important related data fairly easily at this ~small scale. Output: Instead of getting answers in text/terminal, I like to have it render markdown files for me, or slide shows (Marp format), or matplotlib images, all of which I then view again in Obsidian. You can imagine many other visual output formats depending on the query. Often, I end up "filing" the outputs back into the wiki to enhance it for further queries. So my own explorations and queries always "add up" in the knowledge base. Linting: I've run some LLM "health checks" over the wiki to e.g. find inconsistent data, impute missing data (with web searchers), find interesting connections for new article candidates, etc., to incrementally clean up the wiki and enhance its overall data integrity. The LLMs are quite good at suggesting further questions to ask and look into. Extra tools: I find myself developing additional tools to process the data, e.g. I vibe coded a small and naive search engine over the wiki, which I both use directly (in a web ui), but more often I want to hand it off to an LLM via CLI as a tool for larger queries. Further explorations: As the repo grows, the natural desire is to also think about synthetic data generation + finetuning to have your LLM "know" the data in its weights instead of just context windows. TLDR: raw data from a given number of sources is collected, then compiled by an LLM into a .md wiki, then operated on by various CLIs by the LLM to do Q&A and to incrementally enhance the wiki, and all of it viewable in Obsidian. You rarely ever write or edit the wiki manually, it's the domain of the LLM. I think there is room here for an incredible new product instead of a hacky collection of scripts.

Three days ago I left autoresearch tuning nanochat for ~2 days on depth=12 model. It found ~20 changes that improved the validation loss. I tested these changes yesterday and all of them were additive and transferred to larger (depth=24) models. Stacking up all of these changes, today I measured that the leaderboard's "Time to GPT-2" drops from 2.02 hours to 1.80 hours (~11% improvement), this will be the new leaderboard entry. So yes, these are real improvements and they make an actual difference. I am mildly surprised that my very first naive attempt already worked this well on top of what I thought was already a fairly manually well-tuned project. This is a first for me because I am very used to doing the iterative optimization of neural network training manually. You come up with ideas, you implement them, you check if they work (better validation loss), you come up with new ideas based on that, you read some papers for inspiration, etc etc. This is the bread and butter of what I do daily for 2 decades. Seeing the agent do this entire workflow end-to-end and all by itself as it worked through approx. 700 changes autonomously is wild. It really looked at the sequence of results of experiments and used that to plan the next ones. It's not novel, ground-breaking "research" (yet), but all the adjustments are "real", I didn't find them manually previously, and they stack up and actually improved nanochat. Among the bigger things e.g.: - It noticed an oversight that my parameterless QKnorm didn't have a scaler multiplier attached, so my attention was too diffuse. The agent found multipliers to sharpen it, pointing to future work. - It found that the Value Embeddings really like regularization and I wasn't applying any (oops). - It found that my banded attention was too conservative (i forgot to tune it). - It found that AdamW betas were all messed up. - It tuned the weight decay schedule. - It tuned the network initialization. This is on top of all the tuning I've already done over a good amount of time. The exact commit is here, from this "round 1" of autoresearch. I am going to kick off "round 2", and in parallel I am looking at how multiple agents can collaborate to unlock parallelism. All LLM frontier labs will do this. It's the final boss battle. It's a lot more complex at scale of course - you don't just have a single train. py file to tune. But doing it is "just engineering" and it's going to work. You spin up a swarm of agents, you have them collaborate to tune smaller models, you promote the most promising ideas to increasingly larger scales, and humans (optionally) contribute on the edges. And more generally, *any* metric you care about that is reasonably efficient to evaluate (or that has more efficient proxy metrics such as training a smaller network) can be autoresearched by an agent swarm. It's worth thinking about whether your problem falls into this bucket too.

The next step for autoresearch is that it has to be asynchronously massively collaborative for agents (think: SETI@home style). The goal is not to emulate a single PhD student, it's to emulate a research community of them. Current code synchronously grows a single thread of commits in a particular research direction. But the original repo is more of a seed, from which could sprout commits contributed by agents on all kinds of different research directions or for different compute platforms. Git(Hub) is *almost* but not really suited for this. It has a softly built in assumption of one "master" branch, which temporarily forks off into PRs just to merge back a bit later. I tried to prototype something super lightweight that could have a flavor of this, e.g. just a Discussion, written by my agent as a summary of its overnight run: Alternatively, a PR has the benefit of exact commits: but you'd never want to actually merge it... You'd just want to "adopt" and accumulate branches of commits. But even in this lightweight way, you could ask your agent to first read the Discussions/PRs using GitHub CLI for inspiration, and after its research is done, contribute a little "paper" of findings back. I'm not actually exactly sure what this should look like, but it's a big idea that is more general than just the autoresearch repo specifically. Agents can in principle easily juggle and collaborate on thousands of commits across arbitrary branch structures. Existing abstractions will accumulate stress as intelligence, attention and tenacity cease to be bottlenecks.