zora_goron

I also had a similar thought process regarding understanding vs memorizing facts while transitioning from studying CS (where I emphasized understanding the underlying concepts rather than trying to memorize atomic facts that I could derive) to medicine (where having facts memorized is also a key component). Interestingly, I found that committing to memorizing facts actually helped me gain a deeper understanding of the topics themselves, which was not what I originally expected! (I wrote a little bit about the above a few months ago -- https://samrawal.substack.com/p/on-the-relationship-between-...)

I wrote a quick integration to the GPT-3 API to Emacs [0]. Although it's a very simple implementation, it's made many small things I would've previously done manually much quicker (ie - one-off calls to convert a hyperlink in X format to markdown; abbreviate first names of author lists of papers; convert some "text message speak" messages into a paragraph).

[0] https://github.com/samrawal/gpt-emacs-macro

I've been working on MedQA, a GPT-powered clinical reference tool that can answer clinical questions and follow-up questions in natural language, along with references to sources. It's been an interesting way to experiment with the use of LLMs in the clinical context, and how to build around the strengths of these models while mitigating the downsides. I've been using it on rounds at the hospital and using those experiences as a feedback loop to continue improving it!

[0] MedQA: https://labs.cactiml.com/medqa

[1] Twitter thread: https://twitter.com/samarthrawal/status/1620545601296564228

I was having similar battery life on my 2020 Intel MBP, and I found turning off the "Manage battery longevity (As your battery ages, maximum capacity is reduced to extend battery lifespan.)" setting improved battery life by an additional few hours.

I've been using the GPT-3 API in various ways; I occasionally use it through my emacs config as a sort of natural-language abstraction for keyboard macros [0].

I've also been developing a GPT-3 based clinical reference tool [1] -- currently it serves as an exploratory vehicle to see how this technology can be applied reliably to the clinical domain, but as I've started to gain an intuition of the sorts of things it is useful (and accurate) for, I've been using it fairly regularly for quick lookups about particular clinical topics!

[0] https://twitter.com/samarthrawal/status/1591527892386734081

[1] https://labs.cactiml.com/medqa

Microsoft Edge Dev with the new Bing + OpenAI integration seems capable of this as well: https://twitter.com/AlphaSignalAI/status/1624077152302862339

I've been working on integrating GPT-3 into a clinical reference tool by "grounding" its responses using data from the NCBI StatPearls clinical handbook -- doing that seems to lead to accurate and relevant responses much of the time, but still occasionally returning partially-correct or irrelevant information.

[0] demo - https://labs.cactiml.com/medqa

[1] some screenshots and details - https://twitter.com/samarthrawal/status/1620545601296564228

This was the Python code outputted by ChatGPT when I pasted in the original problem:

  import random
  import sympy
  
  def generate_large_int(num_digits):
      return int("".join(str(random.randint(0,9)) for _ in range(num_digits)))
  
  # Generate the first large integer
  first_int = generate_large_int(500)
  
  # Generate two prime factors of the first integer
  while True:
      factor1 = sympy.randprime(10\*250, 10\*251)
      factor2 = sympy.randprime(10\*250, 10\*251)
      if first_int % factor1 == 0 and first_int % factor2 == 0:
          break
  
  print(f"{first_int},{factor1},{factor2}","STOP")

I made something similar for emacs and it unlocks what I think of as “semantic macros” — being able to interface with GPT-3 makes actions that are a tiny complexity level above what I usually use kbd macros for (like smart capitalization) easily possible to automate!

Screenshot - https://twitter.com/samarthrawal/status/1591527892386734081

Code - https://github.com/samrawal/gpt-emacs-macro

> I think the most important job for a browser is to stay in the background and let the user focus on the website.

Incidentally, this is why I love the macOS Safari "Compact Tabs" feature [0] -- this is the most compact browser UI I've come across.

[0] https://www.theverge.com/2021/9/21/22686070/apple-macos-safa...

> Technically you can run an Emacs server remotely, and connect to it with the UI client. But the setup is going to be much more involved.

Any pointers on how to get started with this?

This is a newsletter as opposed to a mailing list, but I came across it recently and found it interesting -- https://tldr.tech -- it's a daily email with small blurbs and links to sources covering latest science, AI/ML, programming, tech industry, etc. news!

A little more heavy and less generalizable than this, but I’ve used this Drop-in Minimal CSS bookmarklet [0] several times to quickly try out drop-in CSS frameworks on my projects!

[0] https://dohliam.github.io/dropin-minimal-css/

Same here! I remember implementing little algorithms to solve these puzzles in Python to get familiarized with the basics of the language.

HN discussion on his full podcast with Lex Fridman - https://news.ycombinator.com/item?id=32347172 (which is where these comments are from)

I implemented a "mini" version of Copilot using EleutherAl GPT-Neo-2.7B and HuggingFace model hub and wrote a wrapper to use in emacs -- https://github.com/samrawal/emacs-secondmate

It's much more rudimentary compared to Copilot, but it's fun to play around with, and it can be run completely locally (after the model is downloaded). Plus it runs using a simple Flask local server, so it can be easily extended to other text editors.

I had a good time using Project Euler puzzles as a way to gain familiarity with new programming languages or getting the hang of using Vim for the first time!

This small alias can clear the formatting from whatever you have copied to your clipboard on macOS (not sure what the equivalents of `pbcopy`/`pbpaste` are on other OS's):

  alias noformat="pbpaste | pbcopy"

Thanks for sharing, I didn't know about TRex! I've been using TextSniper (https://textsniper.app) for this functionality -- not sure how these two compare, feature-wise.

A quick question for anyone familiar with the architecture of these Transformer-based models -- I've heard that one reason why they don't work well with numbers is how the inputs are tokenized (i.e. as "chunks" rather than individual words/numbers). Is there anything architecturally preventing an exception in this form of tokenizing in the data preprocessing step, and passing numbers into the model in the format of 1 digit == 1 token? It seems like such a change could possibly result in a better semantic "understanding" of digits by the model.

It might be fun to train a classifier that outputs the "HN Peakness" value of a comment, using the parent comments from this search as positive training samples.

You can import local files to Spotify [0] and if you download the playlist for offline use on your mobile device, they'll be synced over from your desktop [1].

[0] https://support.spotify.com/us/article/local-files/

[1] https://community.spotify.com/t5/iOS-iPhone-iPad/Syncing-Loc...

I've enjoyed The Robot Brains Podcast with Pieter Abeel [0] -- interesting insights and anecdotes and great guests! Some of the episodes I enjoyed:

- Ilya Sutskever (https://shows.acast.com/the-robot-brains/episodes/ilya-sutsk...)

- Andrej Karpathy (https://shows.acast.com/the-robot-brains/episodes/andrej-kar...)

[0] https://shows.acast.com/the-robot-brains

Related thread from last week: https://news.ycombinator.com/item?id=29292818

For all my personal GitHub projects, I've been using a `README.org` file instead of the default `README.md`!

I wonder if part of this includes a possible correlation between deep expertise and enthusiasm/passion for the subject matter, which is passed on throughout the team.

I don't have any experience in this domain, but perhaps one thing to try is formulating this challenge as taking in Tweet sentiment and predicting the delta in stock price. For example, using the stock data, generate the % change in stock price every day compared to the prior day. Then, using Tweets from a date _n_ (or range of dates), try to predict the % change of the stock price on date _n+1_.

Colab is free to use -- you can click Runtime → Run All to run the cells in the notebook free-of-charge. (You may need to be logged in to a Google Account to run it.)

Spotify (https://developer.spotify.com/) exposes a lot of interesting data via their API!

I believe those demos involve "priming" GPT-3 by providing a few examples of (text → generated code), then during inference time passing in just the text. The model would follow the examples provided and subsequently generate a string of code/mockup syntax, which is then evaluated.

Edit: here is a tweet (from the author of the GPT3 layout generator) that seems to show this in practice: https://twitter.com/sharifshameem/status/1282692481608331265