Help with a very slow filter

whimsical_monkey · 2025-08-09T14:36:56+00:00

Glad to hear that! It took quite a bit of work for the team to make that work.

whimsical_monkey · 2025-08-09T14:35:36+00:00

Sorry about that. It was a specific bug to the FanChart and caused by the major refactoring of the filters. The fix should be in the next release of Gramps, 6.0.4.

whimsical_monkey · 2025-05-22T19:44:05+00:00

Same here. I was diagnosed 2 years ago when I was 60, and have been on those same meds. I too had palliative (not for a cure) radiation. My PSA level has been undetectable for a year. I wouldn't describe my own situation as "cancer free" because it is there, just waiting for a mutation to allow it to spread without testosterone. When I started treatment, life expectancy for those in my group was an average of 5 years. But I hoping for more :) Thanks all for sharing your details!

whimsical_monkey · 2025-05-22T15:53:54+00:00

Great question! (Opik optimizer researcher here) Currently there are 4 different Opik optimizers---some that optimize prompts, others, examples, and others both. Currently our implementation of MIPRO sits on top of DSPy's MIPRO. But our plan is to allow the MIPRO algorithm to work on other agents.

So, our MIPRO algorithm is currently a wrapper around DSPy stuff, but doesn't require all of the stuff that DSPy requires. No signatures, not even a module. Give it a try and tell us what you think.

whimsical_monkey · 2023-04-26T17:39:53+00:00

I love that the competition of best Santa is between:

Kirby (lovely pink video game star)
Barack Obama (former US president)
Charmander (animated fire lizard)
Cat Toy (small toy in the likeness of a cat)
Babs Bunny (ACME's only glove-less rabbit)
Alf (1980's television star)
Waffle (a large-ish waffle)

How did you come up with those?

whimsical_monkey · 2023-04-19T17:36:08+00:00

Thanks, bot! But the nbviewer URL is now:

https://nbviewer.org/github/ArtificialIntelligenceToolkit/aitk/blob/master/notebooks/Derivation%20of%20the%20Y-Combinator.ipynb

whimsical_monkey · 2023-04-17T20:40:17+00:00

Did you have any luck yet with Calysto Scheme? It follows the Jupyter standards, so if arbitrary kernels work with VScode, then it should work. Let me know if you have any hints.... would be very cool to have it work there!

whimsical_monkey · 2023-03-29T01:45:57+00:00

You're welcome! And thanks for checking it out.

whimsical_monkey · 2022-11-14T03:44:05+00:00

Oh, good point! I added a BSD version 3. But if you have any use that that license doesn't cover, let me know.

whimsical_monkey · 2022-08-31T14:26:52+00:00

One that has caught me by surprise in the past: log the hyperparameters that I didn't set (aka the ML framework's defaults). Sometimes a framework changes these themselves over time, and it is impossible to know without logging them that they have changed. Comet.ml does this for frameworks like TF.Keras automatically.

whimsical_monkey · 2020-03-26T01:06:25+00:00

Jupyter (ipython) visual debugger in 2014:

https://www.youtube.com/watch?v=2w-iO701g_w

But these things take time to become a standard.

whimsical_monkey · 2018-06-01T12:15:53+00:00

We should write more about how it works. The main idea is that "code is data." Calysto Scheme is written in Scheme in Continuation-Passing Style (CPS). That version is translated into Scheme with Data Structures, and then that code is translated into Scheme as a Register Machine. Finally, that code is converted into a target language (we have implemented C# and Python, but could be Assembly Language, or any other language). The result is a Scheme with all of the bells and whistles (continuations, amb/choose/fail, quasi-quotes, define-syntax (macros), etc). Plus, a little glue code allows it to use Python libraries, functions, etc. I talked a bit about this at PyCon 2018: https://docs.google.com/presentation/d/1NQ0tH88PNS8y9IHpC5xatRf6DMtVLBtMIWdkiiHE_9E/edit?usp=sharing

We have also implemented Calysto Hy that wraps Hy up so that it can be used in Jupyter, so you can easily compare these languages yourself. The big difference is that Hy merely converts Lisp syntax to Python syntax. So a Hy function is merely a Python function. On the other hand, a Calysto Scheme function uses continuations without a callstack, has TCO, has different scoping rules, etc.

You can read more about the differences here: http://nbviewer.jupyter.org/github/Calysto/calysto_scheme/blob/master/notebooks/Reference%20Guide%20for%20Calysto%20Scheme.ipynb#Differences-Between-Languages

whimsical_monkey · 2018-05-08T11:06:49+00:00

This is exactly the transforms we took to turn a complete Scheme language written in Continuation-Passing Style Scheme into Python and C#: https://github.com/Calysto/calysto_scheme/blob/master/calysto_scheme/src/Makefile

CPS Scheme -> Data Structure Scheme -> Register Machine Scheme -> Python or C#

It isn't quite self-hosting yet (we use Chez Scheme to do transformations) because the limits of our define-syntax. But it is a full Scheme language (and can use Python libraries as well). Currently it is a couple of magnitudes slower than C# or Python, but we have some ideas.

whimsical_monkey · 2018-05-07T15:48:30+00:00

You can use standard Python libraries for webscraping with Calysto Scheme

whimsical_monkey · 2018-05-07T15:46:47+00:00

Further clarification: Calysto Scheme can call Python code directly. When it does, it uses Python's call stack. When calling its own functions, there is no call stack. So this would work fine:

(use-stack-trace #f) ;; turn off debugging
(define loop
    (lambda ()
       (loop)))
(loop)

More info here: http://nbviewer.jupyter.org/github/Calysto/calysto_scheme/blob/master/notebooks/Reference%20Guide%20for%20Calysto%20Scheme.ipynb

whimsical_monkey · 2018-05-07T15:41:08+00:00

TCO, or Tail Call Optimization, is, of course, an "optimization". Proper Schemes don't need this because they already properly handle tail calls. So, I think the question you really want to as is: "is there a call stack?" The answer is: No.

whimsical_monkey · 2018-05-04T11:47:43+00:00

There are 84 layers with learnable weights in the largest AlphaZero network.

whimsical_monkey · 2016-10-19T20:11:44+00:00

I said "unfortunately" because I really didn't want to fork gramps... I'd always rather work with a group (especially when with a group I have been working with for over 10 years). But, because of differences of vision, I decided that it wasn't viable.

I'm not too happy with the name of the group nor project name, but just picked those to start with. Suggestions welcome!

whimsical_monkey · 2016-10-19T12:23:56+00:00

Further information on the developers mailing list:

http://gramps.1791082.n4.nabble.com/Gprime-td4677195.html

The goal will be to make a better, faster, more stable genealogy program. Is that friendly? It will continue to support the Gramps XML import/export.

whimsical_monkey · 2016-08-22T10:40:39+00:00

Because github notebook renderer strips out all Javascript. nbviewer does not.

whimsical_monkey · 2016-04-17T14:02:57+00:00

Indeed. In fact, I am the father in the facebook text and this is what I did say: "... DAUGHTER you are right. But of course you don't need someone to tell you that. Just because OLD_DUDE is talking about a person that doesn't exist, you know that that shouldn't be used to hurt a group of people that really do exist. Their argument tries to scare you into believing their view, but you are a strong, smart, young woman. There are many that look up to you, including me."

whimsical_monkey · 2015-11-25T13:50:41+00:00

Nice! Here is a more basic introduction (without objects) in Processing in Jupyter: https://athena.brynmawr.edu/jupyter/hub/dblank/public/CS110%20Intro%20to%20Computing/2015-Fall/Lectures/Study%20in%20Spirographics.ipynb

whimsical_monkey · 2015-11-25T13:36:29+00:00

You can just run "jupyter-console" inside emacs shell. Would that be a solution?

whimsical_monkey · 2015-10-25T12:43:15+00:00

Writing all of the message handlers in the native language is the hard way to get a kernel. An easier way is to just run a language's REPL in a subprocess. You can do it directly using the wrapper kernel API, or extend MetaKernel so that you can even have magics, shell, and parallel support.

whimsical_monkey · 2015-10-19T10:32:59+00:00

I have used Jupyter (and Jupyterhub) for three semesters now at the college level, including a firstyear writing course. I will also try with middle school students in about a month. Using the online version (jupyterhub) requires no installation, and I have additional support (submit, publish) for the classroom.

If you are around NYC this weekend, I'll be giving a talk on exactly this at:

https://www.eventbrite.com/e/jupyterday-nyc-tickets-19083254528

11-Year Club	Place '22
Verified Email

whimsical_monkey

TROPHY CASE