Notes on The Edge Cases

Building Docker Images on M1 Mac for Other Platforms

Sat, 19 Sep 2026 02:10:03 +0000

In order to build Docker images for Lambda functions with CDK on ARM or other non-Intel platforms, but want the Lambda to be on an x86_64 platform, use the platform parameter with the from_image_asset() function.

_lambda.DockerImage_function(
    ...
    code=_lambda.DockerImageCode.from_image_asset(  
        directory="./lambda",  
        file="./myservice/Dockerfile",  
        platform=ecr_assets.Platform.LINUX_AMD64,  
    ),
    ...
)

ecr_assets is a CDK package that also needs to be imported from the main aws_cdk package.

Strategies for Mocking AWS Services for Testing

Sat, 19 Sep 2026 02:10:03 +0000

Stubber

Boto3 comes with the Stubber class, but it doesn’t work well for all calls. In those cases

Moto

Moto is a Python package that allows for easy mocking of AWS services. The canonical way to do this is to use the @mock_<service> decorator outside of your test function and call boto3 functions there. Moto will detect and intercept the boto3 calls. Code example from the Moto documentation:

import boto3
from moto import mock_s3
from mymodule import MyModel

@mock_s3
def test_my_model_save:
 conn = boto3.resource('s3', region_name='us-east-1')
 # We need to create the bucket since this is all in Moto's 'virtual' AWS account
 conn.create_bucket(Bucket='mybucket')

 model_instance = MyModel('steve', 'is awesome')
 model_instance.save

 body = conn.Object('mybucket', 'steve').get[
 'Body'].read.decode("utf-8")

 assert body == 'is awesome'

Patching Clients and Resources

This is kind of useless for most testing, where there is an external module or package under test. The Moto documentation advises users to set up their boto3 clients and/or resources within the functions that use them, but this isn’t always workable. Instead, since you’re already importing the module or package under test, you can use Moto’s patch_client or patch_resource to patch the instantiated client or resource:

Organizing Python Packages and User-Facing API with init

Sat, 30 May 2026 02:50:10 +0000

Python gives you a number of options for exporting the public portions of your package’s API depending on the needs of your users. These are exposed via __init__.py. This allows the developer to have a module structure that is optimized for developers while exposing an API that is optimal for the end user.

Given the following example package with 3 modules:

/src  
    /example_pkg  
        __init__.py  
        foo.py  
        bar.py  
        baz.py  
    setup.py  
    README.md  
    LICENSE

And the functions from each module:

Notes for Backpropagation Through Space Time and the Brain

Mon, 15 Dec 2025 18:11:24 +0000

Summary

What are the key ideas? How can I apply this knowledge that I learned? How do these ideas relate to what I already know?

💡Ideas

Note: These should become Project Idea fleeting notes with a link back to this source.

Fleeting Notes

Note: Conceptual notes that aren’t as tied to the source material. These are fodder for processing into evergreen notes.

Literature Notes

Note: Commentary on the book or things you don’t want to forget. Maybe for use in a public mind garden. Should have a visible source reference. These are “weakly evergreen” because they’re tied heavily to a single piece. Must be in your own words. These should be processed into Evergreen notes, or used as fodder for them. ““Literature notes”, titled after a single work and meant primarily as linkages to other more durable notes, and as targets for backlinks. I write these roughly as “outline notes,” except for someone else’s ideas.” These should be regularly refactored into individual notes in Sources/! Literature Notes/

Intro to Database Systems Notes

Tue, 18 Nov 2025 17:04:50 +0000

Intro to Database Systems CMU 15-445/645

Overview

Things that go here can include:

Question trying to answer
Success criteria
Current state (high level view of what’s next)

Lessons Learned

Resources

Course Slides

01 - Course Intro and Relational Model

Project Plan

{
"name": "Intro to Database Systems CMU 15-445/645",
"filter": "@15-445"
}

Designs

Questions

Lecture Notes

Note: From these, create project learnings -> evergreens

01 - Course Introduction and Relational Model

Slides Database - an organized collection of inter-related data that models some aspect of the real world

The Polyglot Method

Mon, 14 Apr 2025 21:19:29 +0000

Overview

Polyglot - How I Learn_Languages is a book by Kato Lomb that discusses how she learned the extensive number of languages she did for her work as a translator. The book is anchored by her experience and thoughts on learning languages, coalescing into a kind of method for language learning.

Core Concepts

Study language 10-12 hours a week
Include reading in your learning from the beginning and read actively. Make notes in the books, keep “loose glossaries,” and reread often. Books will teach you important vocabulary by repetition, you will encounter common constructions, and learn more naturally.
- A loose glossary should be messy, as straight lines are a hindrance to memory
- Should have word, context(s) it was found in, deduced meaning(s), and dictionary meaning(s)
The method should include and accelerate traditional teacher-guided learning, which should include a similarly leveled classmate
View language learning as a leisure activity akin to solving a crossword puzzle.
Develop the habit of discussing your experiences with yourself in a foreign language via monologues
Don’t go to a dictionary right away. You will remember words better if you work a bit to recall them.

The Method

This method assumes one is starting from 0 in a language and there are no tutors available

Model Context Protocol Clients Make Use of MCP Servers to Get External Tools, Prompts, Resources, and More

Thu, 30 Jan 2025 21:12:48 +0000

Purpose

Clients serve as the intermediary between MCP servers and hosts (LLMs).

Development Pattern

Client Class

Model Context Protocol Servers Define and Serve Functions That Can Extend Client Functionality Using an LLM For Coordination

Thu, 30 Jan 2025 20:42:30 +0000

Development Pattern

Use uv to initialize a new project
Create venv with uv venv
Add mcp and other dependencies
In Pyproject, add build system and script entry point
__init__.py should have a main() function that runs the server

Tools

Implement a list_tools() handler that lists available tools
Implement any helper functions that do business logic
Implement call_tool() handler. Takes name str and arguments dict, name will correspond to name of tool in list_tools() handler
Implement a main function to run the server using packages from mcp.server

Prompts

Prompt architecture

Anthropic Streaming Event Types

Tue, 28 Jan 2025 03:57:36 +0000

Anthropic model streaming responses are delivered in event chunks. Below is a list of the event types with some notes on what they mean.

Event Types

event: message_start
data: {"type": "message_start", "message": {"id": "msg_1nZdL29xx5MUA1yADyHTEsnR8uuvGzszyY", "type": "message", "role": "assistant", "content": [], "model": "claude-3-5-sonnet-20241022", "stop_reason": null, "stop_sequence": null, "usage": {"input_tokens": 25, "output_tokens": 1}}}

This indicates the beginning of a message. It is notable for giving the model-provided count of the input tokens, as well as the initial output token count.

event: content_block_start
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "text", "text": ""}}

The beginning of a block of response content, whether it’s text or something else.

Working with Anthropic's Model Context Protocol

Fri, 20 Dec 2024 16:41:49 +0000

Overview

Architecture

Sketch of entities

Servers

Model Context Protocol Servers Define and Serve Functions That Can Extend Client Functionality Using an LLM For Coordination

Clients

Model Context Protocol Clients Make Use of MCP Servers to Get External Tools, Prompts, Resources, and More

Hosts

What They Do

Consulting - Getting Started Resources

Wed, 20 Nov 2024 16:50:32 +0000

Communities

Tribe AI - Staffing, contact me to discuss applying and referral The Technical Freelancer Academy Out of Office - remote working community

Books

The Consulting Bible - Alan Weiss

Courses

Beyond the Code by Mihai Curelea - I took this, good for seeing how to get financial independence via consulting or BigTech. Not too expensive, and Mihai is great to talk to afterwards.

Bloggers/Influencers

Accounting

Bluevine - free business banking
Xero - low-cost but powerful accounting software
Glazer Financial - recommended by a colleague with lots of consulting experience, they’re based in Texas. I’ve engaged with them but it’s too early to have availed myself of their services. Happy to make an introduction.

General Business

Technical Freelancer consulting templates - the 30 day checklist is great

Insurance

Aside from the marketplace, HSA Insurance and SBSB have good options for small businesses
I use Hiscox for business liability insurance

LLC

Northwest Registered Agent

Website

I use Netlify for hosting and Hugo for static site generation.

PNG Image Modes

Wed, 17 Jul 2024 15:34:27 +0000

There are several modes that a PNG opened in Pillow can take on. These can have significant consequences for processing channels, transparencies, etc. They are:

P mode - palletized images with one channel. They have an image_info dictionary with a transparency key that defines which pixels are transparent
PA mode - same as P but with an alpha channel. Not fully supported by Pillow
RGB - 3 channel 8bit, opens as a l * w * 3 matrix representing each pixel
RGBA - same as above but 4 channels, last being alpha for transparency

Using Step Functions for Fan-Out or Scatter-Gather

Mon, 01 Jul 2024 20:57:17 +0000

You can use a Map State for this. You define it like so in CDK:

from aws_cdk import aws_stepfunctions as sfn, aws_stepfunctions_tasks as sfn_tasks

map_lambda_task = sfn_tasks.LambdaInvoke(
    self,
    "task-name",
    lambda_function=function_lambda,
    payload=sfn.TaskInput.from_object(
        {
            "item_key": sfn.JsonPath.string_at("$.item_key")
        }
    ),
    output_path="$.Payload"
)
map_state = sfn.Map(
    self,
    "state-name",
    items_path="$.item_key",
    input_path="$,
    parameters={
        "item_key.$": "$$.Map.Item.Value"
    }
)
map_state.item_processor(processor=map_lambda_task)

This sets up a lambda task (using an existing Lambda function, not shown) to be invoked as a Step Function task, and the map state that calls it in the iterator. The iterator iterates through each item in the Map’s input, then calls the task for each item in the list passed to the state as input, using a single item (whether it’s a primitive or another container like a list or dict).

Switching AWS CLI Profiles

Thu, 27 Jun 2024 19:52:28 +0000

To see all profiles: aws configure list-profiles To see currently set profile: aws configure list To change the profile, set the AWS_PROFILE environment variable: export AWS_PROFILE=<profile name>

Opening Text-Based pgdump Database Backups (postgres)

Wed, 19 Jun 2024 21:15:11 +0000

]

The file itself (unless it’s a binary file) can be opened in a text editor to inspect. To create a database to work with from the backup file, you have to create a database to restore into and then restore the database.

To create:

$ psql -U postgres
postgres=# createdb dbname

To restore from the backup:

psql -U postgres -d dbname -f path/to/your/file.sql

"Double free or corruption" Error Opening Images with Pillow

Thu, 22 Feb 2024 16:23:22 +0000

If an image isn’t properly closed after opening with Pillow, it’s likely because you’re trying to pass the opened image itself without operating on it. Images are lazily loaded until they’re operated on, which can cause multiple being opened to overlap each other in physical memory. To solve this, load images and operate on them one at a time.

Source

Pillow docs

Docker Run Issues - Unable to Start Container

Thu, 22 Feb 2024 15:40:37 +0000

Sometimes you won’t be able to run a Docker container because some .so file can’t be found. This is how to fix it:

sudo apt-get purge docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras
sudo rm -rf /var/lib/docker
sudo rm -rf /var/lib/containerd
for pkg in docker.io docker-doc docker-compose docker-compose-v2 podman-docker containerd runc; do sudo apt-get remove $pkg; done
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo systemctl restart docker
Rebuild and re-run image

Error message

Troubleshooting SSH Issues on EC2

Thu, 22 Feb 2024 15:27:26 +0000

Sometimes on EC2 or another remote server, even with SSH agent forwarding set up, you won’t be able to use SSH on the remote machine (like pulling from a private git repo).

What tends to work is this:

Restart the agent on the local machine by first running ssh-agent to get the PID, then killing the PID with kill -9 PID
Log out of the instance
Log back in

I’ve found that using VS Code remote can cause this issue, and sometimes the above doesn’t untangle it. A workaround is just to use VS Code remote for development and then do any SSH-touching stuff with the integrated terminal.

OpenAI's GPT API's max_token parameter is a limit for prompt and returned completion

Wed, 14 Feb 2024 02:34:10 +0000

In the GPT API, there is an optional max_tokens parameter. This represents the maximum tokens you want to spend between the prompt and the resulting completion. Setting this too low could result in incomplete responses.

Source

OpenAI Forums

DynamoDB Can Take a Static Table Name

Fri, 19 Jan 2024 19:09:51 +0000

CDK autogenerates resource names for every resource in your stack. However some, like DynamoDB, can take a table_name argument, making it a statically named resource. There are a lot of use cases this can benefit, one I’ve used it for was for a table that needed to be accessed by both dev and prod environments, and so needed to be recreated (using from_table_attributes instead of from_table_name so that we have access to any streams) for non-prod environments for access.

Pickled Object Versioning and Compatibility

Thu, 18 Jan 2024 16:31:37 +0000

When you have a class that is used to hold data and is regularly pickled and later retrieved and unpickled, updates to the class in the environment that unpickle the object can cause issues (such as different attributes). For this reason, it is helpful to store the instance’s version and make automated changes to make old pickled instances compatible with the latest version of the object.

Storing the Object Version

Python’s importlib.metadata module allows you to get the distribution version of a package, so this is useful when you are using a packaging system (such as setuptools or poetry) and your class is part of that package. What you will do is upon instantiation, set a version attribute to the version of the package using importlib like so:

Overriding Class Methods in Python

Thu, 04 Jan 2024 05:42:19 +0000

In order to override a class method, the overriding method should also be decorated as a class method and take a required parameter cls, from which you can get class attributes. This is important to keep in mind when overriding things like PynamoDB models.

Example

class OverridingClass(Model):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

    @classmethod
    def classmethod(cls, *args, **kwargs):
        class_attribute_example = cls.class_attribute
        return super().classmethod(*args, **kwargs)

Heads in Machine Learning Are Prediction Components of a Deep Neural Network

Mon, 18 Dec 2023 02:34:00 +0000

In deep learning networks, the head or heads of such a network is the “top” of the network (as opposed to the “bottom” that ingests data) that does some predictive task (such as a classification head or regression head). This is a separate component from the backbone network that does everything to produce the component on which the head or heads completes its tasks (in CNNs, this is the final convolutional feature map of the input image).

Running a Jupyter Notebook From a Docker Container Running on EC2

Wed, 22 Nov 2023 21:54:06 +0000

Given a Dockerfile on an EC2 instance that has, at the very least, these commands at the end:

EXPOSE 8888
ENTRYPOINT ["/bin/bash"]

Build the image

docker build -t <image name> .

Run the container

docker run -it -p 8888:8888 --ip=0.0.0.0 <image name>

If you want to persist data from the host to the container, include bind mounts:

docker run -it -p 8888:8888 -v /abs/path/to/data:/app/data --ip=0.0.0.0 <image name>

Within the container, run Jupyter Lab (note, specifying the port isn’t necessary if you’re using the default port 8888):

jupyter lab --port=8888 --ip=0.0.0.0 --allow-root

Troubleshooting

If you try to open Jupyter Lab in your browser, and you get a “refused to connect” error, ensure that the SSH config you have for your connection to your EC2 instance (or for SSH in general if you don’t have a specific entry for EC2) looks like this:

Working Within a Running Docker Container

Wed, 22 Nov 2023 02:34:18 +0000

First, build your image (assuming your Dockerfile is in the current directory):

docker build -t myimg .

Then call run:

docker run -it myimg

Forwarding SSH Keys Through a Docker Image with Docker Build

Sat, 18 Nov 2023 19:00:54 +0000

Purpose

One use of this technique is to allow Docker to use your keys to access private Github (or any VCS using SSH authentication) repos to install project dependencies during image build time.

The Technique

To do this you will forward your SSH agent or key to the builder with a combination of the docker build command, which signals to the build system that this forwarding ability is available, and bind mounts in the dockerfile that reaches back to the host to get either an existing SSH agent session or keys.

Installing Dependencies from Github Repos with Pip and Poetry

Thu, 16 Nov 2023 20:24:35 +0000

There is a standardized way to install Python packages from VCS repos. The examples will show a complex case that include a branch and subdirectory

pyproject.toml

package-name = {git = "git@github.com:<User>/repo-name.git}
package-name = {git = "git@github.com:<User>/repo-name.git", branch = "test-branch", subdirectory = "repo_dir"}

requirements.txt

package-name @ git+ssh://git@github.com/<User>/repo-name.git
package-name @ git+ssh://git@github.com/<User>/repo-name.git@ptest-branch#subdirectory=repo_dir

pip

This is basically the same format as requirements.txt.

pip install "package-name @ git+ssh://git@github.com/<User>/repo-name.git"
pip install "package-name @ git+ssh://git@github.com/<User>/repo-name.git@ptest-branch#subdirectory=repo_dir"

Private repos

To install from private repos, simply ensure your Github keys are set up on your machine and that they are linked to your Github account (and that you have access to the private accounts).

Linguistically Diverse Prompting Evergreen

Sat, 21 Oct 2023 15:15:58 +0000

Linguistically Diverse Prompting is a technique for doing unsupervised zero-shot generative translation and summarization tasks with low-resource languages. It makes three assumptions:

LLMs have already learned most of the knowledge and task concepts implicitly during pre-training¹
LLMs intuitively learn to perform language encoding and understanding before learning to generate language. This would mean that it is just generative abilities that are improved later when more data is seen.
LLMs can already exhibit near-human generative abilities in the dominant language $E$ where pre-training data is orders of magnitude larger than others. This means that translation tasks between $E$ and minority language $X$ are not symmetric, but are understood as the following tasks:
1. $X \rightarrow E$ translation is a natural language understanding task (NLU) in $X$
2. $E \rightarrow X$ translation is a natural language generation task (NLG) in $X$, which is harder than NLU. While input in $E$ is easy to encode, generating intended results in $X$ will be challenging if the model has not seen enough texts in $X$.

With this in mind, LDP works by presenting in-context exemplars to the model so that the model locates the task of “translate from any language $X$ into $E$.” The exemplars are [input]\n[output] pairs, where inputs are a linguistically and geographically diverse set of high-resource languages with various scripts, while the target [output] are their $E$ equivalents which can be translated using existing multilingual unsupervised machine translation models. Then a test input from a low-resource language is used to translate the target low-resource language $X$ into English.

Designing Machine Learning Systems

Wed, 04 Oct 2023 00:41:17 +0000

[author: Chip Huyen]

Summary

What are the key ideas? How can I apply this knowledge that I learned? How do these ideas relate to what I already know?

💡Ideas

Note: These should become Project Idea fleeting notes with a link back to this source.

Fleeting Notes

Note: Conceptual notes that aren’t as tied to the source material. These are fodder for processing into evergreen notes.

Literature Notes

Pipx and Pre-Commit Bad Interpreter No Such File

Tue, 03 Oct 2023 21:03:01 +0000

While this is generally an issue with pipx, it is likely to come up with pre-commit hooks (since the underlying binaries should be installed with pipx). The issue is the error Bad Interpreter No Such File or Directory when running a pipx-installed application, like poetry or black. This happens on MacOS because of a broken symlink between the application-specific binary path and the Python binary actually being used (I’ve found this to be a brew issue, specifically). This can be fixed with pipx reinstall-all, which will uninstall and reinstall all pipx applications with working symlinks to the appropriate Python binaries.

Setting Up a Virtual Environment Kernel In Jupyter

Mon, 02 Oct 2023 23:26:49 +0000

Activate your project’s virtual environment
Run pip install ipykernel
Run python -m ipykernel install --user --name=myenv
Open notebook and select the myenv kernel

Source

https://janakiev.com/blog/jupyter-virtual-envs/#add-virtual-environment-to-jupyter-notebook

Democratizing LLMs for Low-Resource Languages by Leveraging Their English Dominant Abilities With Linguistically Diverse Prompts

Tue, 04 Jul 2023 20:05:00 +0000

[author: Xuan-Phi Nguyen, Sharifah Magani Aljunied, Shafiq Joty, Lidong Bing] [full title: Democratizing LLMs for Low-Resource Languages by Leveraging Their English Dominant Abilities With Linguistically Diverse Prompts]

Literature Notes

TABLE rows.file.link AS "Literature Note", rows.file.cday AS "Date"
FROM #note/literature AND [Democratizing LLMs for Low-Resource Languages by Leveraging Their English Dominant Abilities With Linguistically Diverse Prompts](/notes/democratizing-llms-for-low-resource-languages-by-leveraging-their-english-domina/)
GROUP BY file.link
sort date ASCENDING

Highlights

in low-resource languages, obtaining such hand-picked exemplars can still be challenging, where unsupervised techniques may be necessary (Page 1)
competent generative capabilities of LLMs are observed only in high-resource languages, while their performances among under-represented languages fall behind due to pre-training data imbalance (Page 1)
we propose to assemble synthetic exemplars from a diverse set of high-resource languages to prompt the LLMs to translate from any language into English. These prompts are then used to create intra-lingual exemplars to perform tasks in the target languages (Page 1)
ﬁne-tuning a 7B model on data generated from our method helps it perform competitively with a 175B model (Page 1)
In non-English translation tasks, our method even outperforms supervised prompting by up to 3 chrF++ in many low-resource languages (Page 1) ^558469488
- Note: Can possibly draw performance benchmarking ideas from here
While most LLMs were pre-trained with multilingual corpora in addition to the gigantic English corpus, and were shown to demonstrate impressive abilities in other languages (Brown et al., 2020; Chowdhery et al., 2022; Scao et al., 2022; Shi et al., 2022; Huang et al., 2023), they only excel in high-resource languages, such as French (Page 1)
In this work, we focus on unsupervised, and zero-shot, generative translation and summarization tasks in low-resource languages, where no supervised few-shot prompts are used (Page 1)
we propose LinguisticallyDiverse Prompting (LDP), a technique that prompts the models to locate the task of “translate any language X into English” by showing the model exemplar pairs between every language and English (En). Practically, we gather a small set of synthetic X -> En exemplars from a diverse set of high-resource languages using off-the-shelf unsupervised MT models (Page 2)
The most multilingual LLM is BLOOM (Scao et al., 2022), which was trained on 46 languages in the ROOTS corpus (Laurençon et al., 2022). This corpus includes 34 Indic and African languages regarded as low-resource, with each language having a pre-training 5% in Tumbuka for the African group coverage of less than 1% in Hindi for the Indic group, to 2e^-5 % in Tumbuka for the African group (Page 3)
Therefore, we use BLOOM as the main model to evaluate our methods and baselines in such 34 low-resource languages (Page 3)
the noteworthy gap between existing UMT and LLMs is that their language coverages do not overlap much, preventing us from using UMT models to enhance LLMs. (Page 3)
Hendy et al. (2023) show that GPT models can perform competitively alongside state-of-the-art MT models (Page 3)
- Note: Get this paper
there is still limited research involving low-resource languages in completely zero-shot setups (Page 3)
linguistically-diverse prompting (LDP) method is inspired from three intuitive assumptions (Page 3)
LLMs have already learned most of the knowledge and task concepts implicitly during pre-training (Page 3) ^558469498
The second assumption is that the models intuitively learn to perform language encoding and understanding at an earlier time, before learning to generate language. (Page 4)
The third assumption is that LLMs can already exhibit near-human generative abilities in the dominant language E (mostly English) where pre-training data is often orders of magnitude larger than other (Page 4)
we argue that with respect to a minority language X, translation tasks between X and E are no longer symmetric and can be interpreted more broadly as follows (Page 4)
X -> E translation is a language understanding task (NLU) in X. This notion extends NLU beyond popular classiﬁcation tasks, such as sentiment analysis or entailment (Page 4)
E -> X translation is a language generation task (NLG) in X, which is often harder to master than NLU (Page 4)
Speciﬁcally, while the input in E can be easy to encode, generating the intended results in X will be challenging if the model has not seen enough texts in X (Page 4)
we design in-context exemplars so that the model locates the task of “translate from any language X into E”, by demonstrating prompt pairs from “every language” to E. (Page 4)
This is because the target-side prompt distribution is now realistic and consistently close to the true target distribution we expect the model to generate, which has been shown to be crucial for in-context learning to work (Xie et al., 2021). (Page 5)
X -> E task. As mentioned above, we ﬁrst gather n Z(sub)i -> X exemplar pairs (s(sub)Z, t^i(sub)E) with Z(sub)i ∈ Z(fancy) where Z(fancy) is a diverse set of languages with various writing systems, lexical and regional characteristics, such as French (Fr) and Chinese (Zh), and Zi ≠ {X, E}. Such exemplars can be collected by randomly selecting a single sentence from unlabeled data of the respective language Z(sub)i (Page 5)
- Note: Convert to latex
E -> X task. We leverage [LDP prompt] to build intra-lingual prompts with unlabeled data from the target X language. Specifically, given m unlabeled texts s^j (sub) X ∈ D(sub)X with D(sub)X as monolinguial corpus in X, we produce synthetic back-translation (BT) target s^j(sub)E - L^(mt)(sub)X->E(s^j(sub)X). Then we use the BT synthetic pairs as in-context exemplars for E-> X translation tasks for input S(sub)E (insert formula -> L^(mtbt)) (Page 5)
- Note: Convert to Latex
we can also use L^(mtbt) simply swapping the direction of the (s^1(sub)E, t^1(sub)X) to (s^1(sub)X, t^1(sub)E). Nonetheless, we found in the experiments that both L^(mt) and L^(mtbt) perform similarly and on par with supervised prompting for the X -> E task, suggesting that we do not need any supervised or unlabeled data to translate any language into English. … we can even omit these back-translation exemplars entirely with non-BT L^(mt) LDP by using native language tags (Page 5)
During training, we only compute loss on the [output] part to train the model to generate the right language (Page 5)
we empirically found that the model fails to learn to generate the low-resource languages unless we increase the learnable parameter counts signiﬁcantly, which seems to defeat the purpose of using PEFT (Page 5)
- Note: PEFT = parameter-efficient fine-tuning approach, e.g. LoRA
As the ROOTS corpus (Laurençon et al., 2022) that BLOOM (Scao et al., 2022) was pre-trained on offers the most diverse language coverage with open-sourced transparency, we tested our methods mainly with the BLOOM model (Page 6)
Figure 5a reveals one reason the models struggle to translate En->X when using LDP prompts L^mt (without intra-lingual BT data) is that the target-side distribution contains multiple languages, and the models struggle to recognize unfamiliar language tags, such as Marathi (Mr), and often generate wrong translations in the wrong languages (Page 9)
supplying synthetic intra-lingual prompts where the target-side is consistently in the intended language, as shown in Figure 5b with L^mtbt, is more important in getting the models to recognize language rather than the language tag. In fact, we found that removing the language tag entirely can help improve the performance slightly. (Page 9)
which high-resource languages should be selected as LDP exemplars. Table 6 examines which LDP language choice is optimal (Page 10)
choosing a single related language (Hindi), which is often called cross-lingual prompting (Zhang et al., 2023; Zhu et al., 2023), can be disastrous as the model tends to translate the prompt language rather than the test language (Page 10)
Choosing a single but distant language (Vi or Zh) yields better results, while choosing a wide variety of languages across different regions (e.g., Ar,Zh,Vi,Fr) may be the optimal choice. (Page 10)
We introduce linguistically-diverse prompting (LDP), which is designed to use synthetic high-quality in-context exemplars from high-resource languages to prompt LLMs to perform generative tasks, such as translation and summarization, in low-resource languages (Page 11)

Using Bind Mounts to Speed Up Docker Development

Tue, 06 Jun 2023 20:41:50 +0000

When using docker run, the --mount parameter allows you to specify a directory to recreate within the Docker container so that you can edit your code locally and then run it within the Docker container without rebuilding the image.

Consider whether coding within a running container fits your use case better.

Example

docker run -it --mount type=bind,source="$(pwd)/tests",target=/tests image_tag

This uses the tests directory within the working directory as the source and puts the contents within a directory /tests in the container whenever you call docker run.

Remote Development with VS Code

Tue, 06 Jun 2023 20:27:18 +0000

Developing with Docker

To use Docker for developing in VS Code, you can use the Docker, Dev Containers and Remote Explorer extensions. Here’s a rough step-by-step guide:

Build an image if it hasn’t been built already from VS Code
Right click the image and select “Run interactive”
Then in the running container, right-click and run “Attach VS Code”
A new VS Code window will open and you can select a directory within the container to open You can also click the green icon in the lower left corner of the window to access the same options.

Developing on a Remote Server with SSH

To connect to a remote server and run VS Code on it, use the same Remote Explorer extension along with Remote - SSH:

Invalid Cross-Device Link when Deploying with CDK

Tue, 06 Jun 2023 20:20:58 +0000

When deploying with CDK, I started out of nowhere getting this error:

OSError: [Errno 18] Invalid cross-device link: '/tmp/pip-target-e_4qns87/lib/python/numpy' -> '/asset-output/numpy'

This seems to be caused by using gRPC FUSE for file sharing in Docker. To fix this, change the setting for file sharing implemnentations from gRPC FUSE to VirtioFS.

If this doesn’t work, it could imply a corrupted virtual environment. Build a new one and try again with that. This was what did the trick for me - but only for one deployment. Updating the few Python 3.8 lambda runtimes to 3.9 fixed it.

Yohimbine HCl

Fri, 02 Jun 2023 15:55:11 +0000

Dosing

5-10 mg 1-2x per day
“Dosages of 0.2mg/kg bodyweight have been successfully used to increase fat burning without significant implications on cardiovascular parameters like heart rate and blood pressure.”
- For a 200lb man, this comes out to 18 mg

Schedule

1 dose (2.5-5 mg) AM
1 dose (2.5-5 mg) PM, after digesting lunch

Uses

Cutting weight
Increasing libido

Side Effects

Anxiety
Increased heart rate
Increased blood pressure

Notes

Must be taken without carbohydrates
Do not stack with Clenbuterol. To use together, use Yohimbine HCl on Clen off-weeks
Doesn’t feel as effective as Clenbuterol but I suspect not much is.

Sources

Fixing Runtime Exited Without a Reason Errors in AWS Lambda

Thu, 25 May 2023 18:47:46 +0000

This happens sometimes with Dockerized Lambdas. I have no idea why, but fixing it usually consists of rebuilding and re-pushing the docker image, redeploying it to the Lambda, and re-running it.

Dispatch Tables in Python

Thu, 18 May 2023 02:09:39 +0000

Dispatch tables are a useful way to use a string to determine which function to call. Why would you do this? When designing an interface to be used in other people’s code, you can make a single routing function or method public to users, and then use a parameter to determine which “worker” function to pass in.

A really basic no-guardrails example could look like this:

DISPATCH_TABLE = {
    "one": _private_fxn_one,
    "two": _private_fxn_two
}

def public_function(which_function: str):
    result = DISPATCH_TABLE[which_function]()
    return result

def _private_fxn_one():
    return "one"

def _private_fxn_two():
    return "two"

Caveats

Don’t put parentheses on the function in the dispatch table because the function will be called then. This applies generally when using a function as an object,
If the private functions have different parameters, you can use kwargs to pass in a standard set of arguments and ignore the unused ones, or generate the parameters based on an argument to the public function.

Sources

LLM Knowledge Management Agent

Sat, 06 May 2023 16:47:59 +0000

Overview

Description: An agent to research a given topic by doing analytical and syntopic reading, summarizing and extracting main points, connecting them together, and forming new knowledge outputs such as zettels or evergreen notes.

Lessons Learned

~~Document embeddings with transformers don’t seem to be too practical. Instead, go with a sentence embedding for the knowledgebase using note titles and search with main idea embeddings.
Dispatch table values need to the the function as an object, so without the parentheses. Otherwise they’ll be run when instantiated.

Project Notes

Future Improvements

Future improvements to the project should go here for easy reference. They should be a type of project note and link back to a Project page and any tickets that come from it.

Data Parallelism

Mon, 17 Apr 2023 20:58:24 +0000

[same: Model Parallelism]

Data parallelism is when you split the data and train the full model in parallel on each segment of data. This is different from Model Parallelism in which the model itself is split across different GPUs.

Machine Learning System Design Interview

Sat, 15 Apr 2023 02:43:54 +0000

Note: See here for valid statuses

[author: Ali Aminian Alex Xu]

Summary

What are the key ideas? How can I apply this knowledge that I learned? How do these ideas relate to what I already know?

💡Ideas

Note: These should become Project Idea fleeting notes with a link back to this source.

Fleeting Notes

Note: Conceptual notes that aren’t as tied to the source material. These are fodder for processing into evergreen notes.

import os Causing Counterintuitive Errors in Sagemaker

Mon, 10 Apr 2023 00:52:17 +0000

Traceback (most recent call last):
  File "/usr/lib/python3.8/runpy.py", line 194, in _run_module_as_main
    return _run_code(code, main_globals, None,
  File "/usr/lib/python3.8/runpy.py", line 87, in _run_code
    exec(code, run_globals)
  File "/function/awslambdaric/__main__.py", line 25, in <module>
    main(sys.argv)
  File "/function/awslambdaric/__main__.py", line 19, in main
    lambda_runtime_api_addr = os.environ["AWS_LAMBDA_RUNTIME_API"]
  File "/usr/lib/python3.8/os.py", line 675, in __getitem__
    raise KeyError(key) from None
KeyError: 'AWS_LAMBDA_RUNTIME_API'

~~My suspicion is that the our internal package requires os as a dependency to open a file, and that causes some kind of clash with AWS.~~

But it gets weirder! The dependency’s Constants module has an import os that works just fine! BUT it uses this to get the assets path:

Passing Arguments from Main Commands to Subcommands in Click

Wed, 05 Apr 2023 18:17:37 +0000

If you have command groups in your CLI application so that you have subcommands, you can pass arguments from the group down to the subcommands with the context object. Here’s the pattern:

@click.group()  
@click.argument("arg1", type=click.File("r"))  
@click.option("--option1", default="test")  
@click.pass_context  
def cli(ctx, arg1, option: str):  
    ctx.ensure_object(dict)  
    ctx.obj["arg1"] = arg1  
    ctx.obj["option1"] = option1  
  
  
@click.command()  
@click.argument("subcommand_arg", type=str)
@click.pass_context  
def trigger_training_job(ctx, subcommand_arg):  
    arg1_from_group = ctx.obj["arg1"]

if __name__ == "__main__":  
    cli(obj={})

Source

Click documentation

Addressing Mismatched CuDNN Versions

Mon, 03 Apr 2023 18:25:19 +0000

Exception

2023-04-03 16:05:09.410087: W tensorflow/core/framework/op_kernel.cc:1830] OP_REQUIRES failed at xla_ops.cc:362 : INTERNAL: RET_CHECK failure (tensorflow/compiler/xla/service/gpu/gpu_compiler.cc:618) dnn != nullptr 
2023-04-03 16:05:09.428729: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:417] Loaded runtime CuDNN library: 8.0.5 but source was compiled with: 8.6.0.  CuDNN library needs to have matching major version and equal or higher minor version. If using a binary install, upgrade your CuDNN library.  If building from sources, make sure the library loaded at runtime is compatible with the version specified during compile configuration.

How to Fix

A number of unclear bits of documentation exist for this, that seem to conflict. Install cudnn with pip and then update paths:

Installing Tensorflow on Apple Silicon Macs

Wed, 22 Mar 2023 16:08:31 +0000

$ brew install hdf5
$ export HDF5_DIR="$(brew --prefix hdf5)"
$ pip install "grpcio>=1.37.0,<2.0" "h5py>=3.6.0,<3.7" "numpy==1.24.2"
## Make new virtual env here
$ pip install tensorflow-macos
$ pip install tensorflow-metal

Versions

The latest (as of 2023-03-22) versions of tensorflow-macos (2.11.0), numpy (1.24.2), and tensorflow-metal (0.7.1) all seem to work well together. Apple’s list of compatible versions is now out of date.

Installing Tensorflow on Silicon Macs

Tue, 28 Feb 2023 19:13:38 +0000

To install Tensorflow on a Silicon Mac, do the following in a virtual environment:

pip install tensorflow-macos
pip install tensorflow-metal

Ensure the version of tensorflow-metal matches with the tensorflow-macos version

Deploying a Flask App to AWS Elastic Beanstalk with CDK and With the AWS Console

Mon, 27 Feb 2023 14:40:39 +0000

Steps in CDK

Initialize construct
Zip flask code
Set up options for application, env vars, and app version
Set environment
Make sure environment is built after CDK application

## Deploy to ElasticBeanstalkanstalk-application-packaging-through-cdk-in-typescript-e91b7ffe4928
app_name = "MyApp"
elb_flask_app = elb.CfnApplication(
    self, f"flask-appserver", application_name=app_name
)

## Move app code into S3 for ELB
elb_archive = s3_assets.Asset(
    self,
    f"elb-flask-app-{stage}",
    path=f"{str(Path(__file__).absolute().parents[2])}/app.zip",
)

## Set OptionSettingProperties
option_setting_properties = [
    elb.CfnEnvironment.OptionSettingProperty(
        namespace="aws:autoscaling:launchconfiguration",
        option_name="InstanceType",
        value="t3.small",
    ),
    elb.CfnEnvironment.OptionSettingProperty(
        namespace="aws:autoscaling:launchconfiguration",
        option_name="IamInstanceProfile",
        value="aws-elasticbeanstalk-ec2-role",
    ),
    elb.CfnEnvironment.OptionSettingProperty(
        namespace="aws:autoscaling:launchconfiguration",
        option_name="IamInstanceProfile",
        value="aws-elasticbeanstalk-servicerole",
    ),
    # This is an example of setting up an environment variable
    elb.CfnEnvironment.OptionSettingProperty(
        namespace="aws:elasticbeanstalk:application:environment",
        option_name="ES_DOMAIN",
        value=es_domain.domain_endpoint,
    ),
]

## Set app version properties
app_version_props = elb.CfnApplicationVersion(
    self,
    f"AppVersion-{stage}",
    application_name=app_name,
    source_bundle=elb.CfnApplicationVersion.SourceBundleProperty(
        s3_bucket=elb_archive.s3_bucket_name,
        s3_key=elb_archive.s3_object_key,
    ),
)

## Set environment
elb_env = elb.CfnEnvironment(
    self,
    f"elb-env",
    environment_name=f"elb-env",
    application_name=app_name,
    solution_stack_name="64bit Amazon Linux 2 v3.2.1 running Python 3.8",
    option_settings=option_setting_properties,
    version_label=app_version_props.ref,
)

## Ensure the env isn't built before the app by placing this at the end of your CDK stack file
app_version_props.add_depends_on(elb_flask_app)
elb_env.add_depends_on(elb_flask_app)

Steps in AWS Console

Launch EC2 instance
SSH into it,
Set up Git keys
1. See here
2. Add deploy key to repo
Pull code from Github into instance

Run Flask server

Activate virutal environment
Install dependencies with pip install -r requirements.txt
Set environment variables:
1. FLASK_ENV=development or FLASK_ENV=prod

Set up uWSGI

Install gcc
Install uWSGI with pip install uwsgi
Install NGinx source 1. Only do steps 1 and 2 from article:

sudo apt update
sudo apt install nginx
# Test firewall
sudo ufw app list
sudo ufw allow 'Nginx HTTP'
sudo ufw status

Set up uWSGI configuration with app.ini:

[uwsgi]
module = wsgi:app
master = true
processes = 5
socket = myproject.sock
chmod-socket = 660
vacuum = true
die-on-term = true

Set up system profile file /etc/systemd/system/myproject.service, taken from linked article

[Unit]
Description=uWSGI instance to serve myproject
After=network.target

[Service]
User=sammy
Group=www-data
WorkingDirectory=/home/sammy/myproject
Environment="PATH=/home/sammy/myproject/myprojectenv/bin"
ExecStart=/home/sammy/myproject/myprojectenv/bin/uwsgi --ini myproject.ini

[Install]
WantedBy=multi-user.target

Start with systemctl:
1. sudo systemctl start myproject
2. sudo systemctl enable myproject
Set up nginx
1. Edit /etc/nginx/sites-available/myapp

server {
    listen 80;
    server_name <EC2 domain>;

    location / {
        include uwsgi_params;
        uwsgi_pass unix:/home/ubuntu/myapp/flask-app/myapp.sock;
    }
}

Then link: sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled
- Restart nginx service:
  - Update firewall rules
```
$ sudo ufw delete allow 5000
$ sudo ufw allow 'Nginx Full'
```

Sources

AWS - Deploying a Flask Application to Elastic Beanstalk Packaging a NodeJS application with CDK on Elastic Beanstalk

Simple Future and Aorist Irregular Verbs

Sun, 19 Feb 2023 17:07:14 +0000

Shortened Irregulars

These verbs become very short in the simple future, in the aorist they are prefixed with ει-

verb	simple future	aorist
βλέπω	θα δω	είδα
λέω	θα πω	είπα
πίνω	θα πιω	είπα

Main -αίνω verbs

These lose the -αίν- root in the simple future and it is replaced with -ηκ in the aorist.

verb	simple future	aorist
βγαίνω	θα βγω	βγήκα
μπαίνω	θα μπω	μπήκα
βρίσκω	θα βρω	βρήκα
ανεβαίνω	θα ανεβώ	ανέβηκα
κατεβαίνω	θα κατεβώ	κατέβηκα

Non-pattern -αίνω verbs

For these, the construction of the aorist follows the pattern of reguar verbs: take the simple future, change the ending, and add ε- if needed.

Creating a Model Instance with from_raw_data() in PynamoDB

Thu, 26 Jan 2023 19:16:08 +0000

When using from_raw_data in PynamoDB, you have to pass in the DynamoDB dict structure ({"attribute_name": {"S": "value"}), not a plain dictionary. When 6.0.0 comes out, there will be to_dict and from_dict methods.

Until to_dict and from_dict are released, use this to convert a Pynamo object to a dictionary: found_record_dict = found_record.__dict__.get("attribute_values", found_record.__dict__)

Proejct Source

Type hint for any subclass in Python

Thu, 26 Jan 2023 19:04:14 +0000

To use a type hint to specify a parameter can be any subclass object of the hinted class, use typing.Type and in the annotation do Type[A]. This is useful if getting warnings for f-strings passed into functions that expect strings.

from typing import Type
s = f"blah"
process(fstring=s)
def process(fstring=Type[str]):
 return fstring

This isn’t needed for instances that are subtypes, though.

Project Source

Logging from Custom Docker Code in Sagemaker

Tue, 10 Jan 2023 18:05:43 +0000

Unlike in AWS Lambda code, in Sagemaker training jobs using custom Python code in Docker containers logging won’t work unless a stream handler is specifically added to the logger.

logger = logging.getLogger("__main__")
stream_handler = logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)

SAGEMAKER_PROGRAM in Custom Dockerfile

Tue, 10 Jan 2023 03:47:47 +0000

At the end of a Dockerfile that defines a container for a Sagemaker training job, you have to define the SAGEMAKER_PROGRAM environment variable. It needs to point directly to the script that acts as the entry point as it exists within /opt/ml/code, rather than the full path.

ENV SAGEMAKER_PROGRAM train.py

Securing a New SSH Server

Tue, 10 Jan 2023 03:35:06 +0000

Steps for securing a fresh SSH server:

Disable root login
- sudo vim /etc/ssh/sshd_config
- Uncomment “PermitRootLogin no”
- Restart ssh: sudo systemctl restart sshd
Disable password login
- Using steps [here](Securing a New SSH Server):
  - Set “PasswordAuthentication no”
Keyfile login (generate key if necessary, use ssh-copy-id to copy public key to authorized hosts)
- If necessary, generate a key
- ssh-copy-id -i user@ssh.host
Change SSH port
- Edit sshd_config
- Update “Port 22” line (uncomment if necessary) to the port you want to use
Install fail2ban

Deploying an Updated Image to Lambda Function

Wed, 04 Jan 2023 18:24:48 +0000

Redeploying a CDK stack with a Lambda function that relies on a Docker image in ECR won’t necessarily update the function with a newly pushed image. Instead, use the Lambda console’s “Deploy new image” button to push the ECR image to the function.

Forming The Feminine of Certain Adjectives

Wed, 21 Dec 2022 03:01:50 +0000

Some adjectives in Greek have different endings when in the feminine gender. Adjectives that end in -χος or -θος in the masculine become -χια or -θια for people and -χη or -θη for things or places. Adjectives that end in -υς in the masculine become -ια in the feminine.

Examples

-χος/-θος -> -χια/-θια (people)	-χος/-θος -> -χη/-θη (things/places)	-υς -> -ια
ξανθός - Η Μαρία είναι ξανθιά	ξανθός - Μου αρέσει η ξανθή σταφίδα	μακρύς - μακριά
φτωχός - Αυτή η οικογένεια είναι φτωχιά	φτωχός - Αυτή η χώρα είναι φτωχή

Task Machine Learning Engineers and Platform MLEs

Sun, 18 Dec 2022 03:31:19 +0000

Note

Task MLEs work with data scientists to “productionize” models, sustaining a specific pipeline or pipelines in production. They need to write, maintain, and monitor pipelines that are responsible for the entire lifecycle of a ML model.

Platform MLEs help task MLEs automate their job. They build pipelines that support multiple tasks (task MLEs solf specific tasks).

Platform MLEs build pipelines to create features, task MLEs create pipelines to use features. PMLEs trigger ML performance drop alerts, TMLEs act on alerts.

Gkatzoyiannis Etymology

Wed, 30 Nov 2022 14:35:19 +0000

A listing of some theories for the name Γκατζογιάννης that I’ve heard and researched myself. Specifically, the decidedly non-Greek γκατζο part.

Yiayia’s Story

One time I asked my Yiayia about what the name meant. According to her, it was the name of a famous chicken in a nearby village. To this day I never found out if she was joking with me or not.

Nick Gage’s Serbian Theory

According to Nick Gage, Γκατζο comes from an old Serbian dialect, meaning “black,” with the name meaning “black John.”

Uses of μπορώ and μπορεί

Fri, 11 Nov 2022 17:41:43 +0000

It Is Possible/Might

Depending on context, μπορεί (and only μπορεί - impersonal form) can mean “might.”

See Wiktionary entry

Examples

Δεν μπορεί! ― It is not possible! Μπορεί να βρέξει αύριο. ― It may rain tomorrow. Tα παιδιά μπορεί να πάνε σινεμά. ― Τhe children/guys might go to the cinema. Mπορεί να είμαι καλύτερα αύριο ― I might be better tomorrow.

Can/May

This meaning does not use the impersonal, and so will take the full personal conjugation of μπορώ.

System Design Interview

Mon, 31 Oct 2022 03:03:50 +0000

Note: See here for valid statuses

[author: ]

What is the Book About?

Note: See How To Read a Book What kind of book is it?

Non-fiction, practical book. Examples of system design interview questions. What is the book about in 1-2 sentences at most?
System design interview questions and how to answer them.

Summaries

Chapter 1: Scale from Zero to Millions of Users

Single Server Setup

Request flow:
1. Users access websites through domain names, which are resolved by DNS
2. Internet protocol (IP) address is returned to the browser.
3. Once IP address is obtained, HTTP requests are sent directly to server
4. The web server returns HTML pages or JSON response.

Database

Separating web/mobile traffic (web tier) from database (data tier) servers allows them to be scaled independently.
Non-relational DBs might be right choice if:
- Application requires super-low latency
- Data are instructured
- You only need to serialize and deserialize data
- You need to store massive amount of data.

Vertical vs. Horizontal Scaling

Vertical scaling - adding more power (CPU, memories, etc.) to servers. “Scale up”
- Limitations:
  - Hard limit - can’t add unlimited CPU and memory
  - No failover or redundancy
Horizontal scaling - adding more serviers to pool of resources

Load Balancer

A load balancer evenly distributes traffic among web servers.
The load balancer communicates with web serves via private IPs.
Load balancers can redirect traffic away from offline servers
They also can handle rapid gains in traffic, allowing you to simply add more servers behind the load balancer to accomodate the growing traffic.

Database Replication

Master/slave terminology: master only handles writes, slave databases only support reads and get copies of databases from the master.
Advantages
- Better performance
- More reliable
If one slave DB is available then goes offline, read operations get directed to master database
If master goes offline, after some time a slave will be promoted to the new master.

Cache

A cache is a temporary storage area that stores the result of expensive responses/frequently acccesed data in memory to serve them more quickly.

Raising Exceptions from Lambda to API Gateway Caller

Wed, 05 Oct 2022 17:09:29 +0000

You can send exception feedback from a Lambda to an API Gateway API either by raising a Python exception and handling it via a mapping template, or return a specific set of values from the main handler function.

Returning from the Handler Function

You can return a dictionary that includes at least:

the desired status code
the message body (JSONified)
and whether or not the body is base64 encoded

return {  
    "statusCode": 404,  
    "body": simplejson.dumps(  
        f"User {username} not found"  
    ),  
    "isBase64Encoded": False,  
}

Raising an Exceptions

Using a mapping template allows you to simply use regex to associate an error message from a plain Python exception with a certain HTTP code. I don’t have any examples because I haven’t done it, preferring the previous method.

Troubleshooting Slow Docker Image Builds

Wed, 05 Oct 2022 14:31:11 +0000

Slow Build During Python Dependency Installation

This could be due to Docker attempting to build the dependency from the code rather than using a prebuilt wheel binary. This happens with older versions of dependencies, and especially hard-to-build dependencies like scikit-learn.

Installing Scipy with Docker

Tue, 04 Oct 2022 19:19:35 +0000

Certain packages can be troublesome to install in a Docker container when they’re defined in a requirements.txt file, such as scipy. If you’re running into issues installing these, which are typically problems with installing or building dependencies, try running pip install from the Dockerfile itself, then installing from requirements.txt.

Example

RUN pip install --no-cache-dir --upgrade pip && \  
    pip install numpy scipy cython && \  
    pip install -r requirements.txt --target ${FUNCTION_DIR}

Including Assets from Parent Directories in Dockerized Lambda Functions with CDK

Tue, 04 Oct 2022 17:31:19 +0000

If you have a Docker based Lambda that is defined in some directory and there are assets that the Lambda needs in the parent directory, from_image_asset() takes directory and file parameters, so you can select the parent directory as well as the specific Dockerfile that describes the environment for the Lambda.

Here is an example folder structure:

CDK_infrastructure/
    lambdas/
        lambda_one.py
        lambda_two.py
        lambda_pkg/
            ...
        docker_lambda/
            Dockerfile

And here is how you would set this up in your stack definition:

Hugo Project Architecture

Tue, 13 Sep 2022 01:34:20 +0000

Page Bundles

Personal Site Redesign Personal Site Redesign

Content Sections

Any directories within content/ define a different content section such as posts, tutorials, etc. These directories are also used to determine a page’s content type, which can affect how the page is displayed, which archetype applies, and more

Sources

Content sections source note

Hugo Archetypes

Mon, 12 Sep 2022 00:22:25 +0000

Archetypes in Hugo are templates for different content types. Among other things, they allow you to configure frontmatter for whatever content type. They are found in either the top-level archetypes directory of your project, or if you’re using a theme, in themes/your-theme/archetypes and their the name is the content type + .md, like posts.md.

Then, when you run hugo new posts/new-post/new.md, the appropriate folder and file will be made with initial content from the matching archetype file.

Flask-Tables Variable Names Must Match Fields

Thu, 01 Sep 2022 20:00:21 +0000

When setting up a table with Flask-Tables, the variable names for the columns must match those in the database the table is pulling from. Alternative column names can be passed in as a parameter.

Source

Flask-Tables Documentation

Setting Up Helix on MacOS

Thu, 01 Sep 2022 14:47:34 +0000

Installation

brew install helix
hx --grammar fetch
hx --grammar build
1. This requires a C++ compiler to be installed

Integrate config with RCM

Python Setup

Install LSP pipx install 'python-lsp-server[all]'
Add black plugin to LSP’s virtual environment pipx inject python-lsp-server black python-lsp-black
1. In progress - not sure how to config and use properly yet.

Elixir Setup

Rust Setup

Sources

DynamoDB Batch Gotchas

Wed, 31 Aug 2022 16:08:03 +0000

The main thing to remember is that a batch_get call on a table with a hash key and a range (or sort) key requires both keys for the request. If you have a list of hash keys and the range key is constant, you can use map with a lambda to combine them into a list of tuples:

list_of_tuples = list(map(lambda x: (x, "constant-range-key"), hash_key_listlike

PynamoDB and batch_get without a Range Key

PynamoDB requires a list of dicts when calling batch_get on a model with a hash and range key. If you try calling it with a set or list (which is allowed because not all models will include a range key), then the string hash keys will be interpreted as a tuple of strings, with the first character being interpreted as the hash key and the second one interpreted as a range key.

Aorist Tense

Wed, 31 Aug 2022 00:28:04 +0000

same: The Past Imperfect (Continuous Past) Tense

The Aorist Tense (ο αόριστος)

Meaning

The aorist is one of the main tenses of Modern Greek. It is also known as the simple past, as it is perfective, referring to a single completed past action. Not only will other tenses in the perfective aspect take the aorist root for their formation, but so will some derivatives of adjectives.

Conjugation Examples

Group A

Group B1

Group B2

Irregulars

Additional Notes

Adjective Derivatives

Wed, 31 Aug 2022 00:24:42 +0000

Verb Derivatives

These are generally formed with a verb’s aorist stem and the requisite ending.

-τός

This means that the noun being modified can be affected by the action of the verb.

Examples

present tense	Aorist Tense	Adjective	Adjective meaning
-ω	χαμογέλασα	-ό	smiling
ταιριάζω	ταιρίασα	-ό	fitting

-τικός

This means that the object is suitable for/associated with

Examples

-άτος

Examples

Noun Derivatives

-ινος

-ινός/-ιανός

-ιακός

More information

Greekpod 101 Level 3 Greek Lesson 11 notes

Asynchronous Lambda Invocation

Tue, 30 Aug 2022 18:57:17 +0000

In order to invoke a Lambda asynchronously, pass InvocationType="Event" to the invoke call. This is useful for, among other things, a hub/message routing Lambda that calls other ones in a fire-and-forget manner. ¹

Source

Lambda API Invoke AWS Documentation

This is likely not an ideal architecture, there are usually better alternatives ↩︎

Managing a Project as a Tech Lead

Fri, 26 Aug 2022 00:11:24 +0000

These are some step-by-step guidelines to approach project management as a tech lead.

Break down the work - use your favorite tools to recursively break down the ask into smaller pieces of work. Once some of the work is broken down, look at the ordering of the work and hand off tasks to people who can turn them into ticket-sized work.
Push through the details and unknowns - “the trick of project management is not to stop when you feel a little bit stuck.” Push past those points by asking an experienced manager to push through with you, ask you questions to prompt you, or work through it together with you.
Run the project and adjust as you go - a good planning process helps you know about how far the project has come and about how far it is from being finished. Things will slip, the key is to communicate that to stakeholders along with underscoring completed milestones and remaining work.
Use what you learn during planning to manage requirement changes - apply what you learned from breaking down the project with its original requirements to what it would look like with the new requirements. Communicate the cost of those changes (new planning? more work? significant risk?) clearly. Having an idea of the effort the changes will take will help make the optimal compromise to achieve a deadline.
Revisit details at you get close to completion - do a pre-mortem: run through all that could fail on the launch of the project, and figure out where good enough is, socialize it, and commit to it. Cut out any remaining work that falls below that line. Attend to the finishing details as well: what is missing? What testing is left? What verification must be done?

Estimating Home Maintenance Costs

Tue, 26 Jul 2022 00:47:23 +0000

There are two different rules of thumb for estimating ongoing maintenance costs of a home: The 1% rule and the square foot rule. These are useful in rough budgeting what you can afford in a home.

The 1% Rule

Budget 1-4% of the home’s cost for maintenance per year. The number should be on the higher end of that range if the house is older.

The Square Footage Rule

Budget $1 per square foot of the home. This is very broad, however, and glosses over differing costs of labor across the country, the type of finishes, etc.

Two Pointer or Iterator Algorithm

Fri, 15 Jul 2022 01:43:58 +0000

In this algorithm, you keep track of two pointers to items in an array, and iterate one or the other as needed. This works with sorted lists.

When To Use

This algorithm is used when you have a sorted list and you need to operate on pairs, triplets, or more. This is a good first choice when you need to find two numbers in an array that satisy some condition.

The Passive Participle -μένος, -μένη, -μένω

Thu, 14 Jul 2022 15:18:30 +0000

The Passive Participle -μένος, -μένη, -μένω

Example

τυπώνω (to print) -> τυπωμένος - printed

Sources

Greekpod101 Level 3 Greek Lesson 2

Uses of Να

Wed, 29 Jun 2022 22:44:54 +0000

[down: Να with noun or pronoun Simple Subjunctive]

The Many Uses of Να

Να is a Grammatical Particle

Subjunctive Particle

The particle να can be used to indicate the subjunctive. Θέλω να μαγειρέψω σήμερα -> I want to cook today

Indicative Particle

Να can also be used to indicate where something is. This is constructed as να + noun or να + pronoun.

When using να with αυτός/αυτή/αυτό, the αυ gets cut off: να αυτός -> να τος (here he is). This can also be translated as “here he comes.”

When To Use Log Levels

Sat, 11 Jun 2022 05:04:55 +0000

When to Use Different Log Levels

This note comprises some heuristics others and myself have found success with when it comes to deciding when and how to use the different log levels in a logging utility.

Debug

Every logged class method should log that it was called as DEBUG along with its parameters.
You should be able to pretty much recreate all that happened with DEBUG logs.

Info

API or external system calls should be logged, at least at this level. Log the start and end times of each call to get an idea of how long that call takes.
At this level, you shuold be able to tell whether it ran reasonably and see what choices might have been made.

Warn

Any time an exception is handled

Sources

Every method of any class I’ve built logs that it’s called as DEBUG; I’ll often include whatever variables were passed to it. This way in debug mode I can see every step of the process 2. API calls or other interactions with external systems definitely should be logged, probably at INFO level at least. Log when it starts and when it ends. This way you can tell about how long it took. 3. Clearly any time you handle an exception that’s a good WARNING, because something happened that needed managing. If I look at the log at DEBUG level, I should be able to pretty much recreate everything that happened. Clearly this is helpful, but it’s also a lot of junk, so it can be annoying. At the INFO level I should be able to tell whether it ran reasonably, and I should be able to see choices that were made (e.g. did it choose to do calculation A or calculation B? which toggle did they select before saying “next”?). And of course the best way to tell what needs logging is that you ran your code and thought to yourself “I wonder if. . . “. You should log that thing you wondered. https://reddit.com/r/learnpython/comments/v9judz/_/ibxnuv1/?context=1

Open Writing

Fri, 10 Jun 2022 02:00:57 +0000

Open writing is a tentative name for a writing style or exercise where you write about something, but use purposefully vague language and underdefined/undefined concepts. This exercise fits somewhere between free association writing and precise writing, where concepts are broken down, defined, and explained.

Some potential benefits of this style:

Triggering diffuse thinking modes
Make space for more poetic writing
Breaking writer’s block
Writing more by feel, allowing more precise writing to be less stiff and breathe a bit more

Catching and Responding To Failures in AWS Step Functions

Tue, 07 Jun 2022 18:40:26 +0000

To handle errors within a Step Function, you can use a Catch block that hands off execution to an Error State. This State can be a Task type, which can (among other things) trigger a Lambda that does the actual error handling.

Example

## Step function failure handler - in the future this will be more complex than writing to DB
failure_handler = lambda_python.PythonFunction(
 self,
 f"failure-handler",
 entry="lambda/",
 index="failure_handler.py",
 runtime=_lambda.Runtime.PYTHON_3_9,
)
failure_task = sfn_tasks.LambdaInvoke(
 self,
 f"failure-lambda-task",
 lambda_function=training_pipeline_failure_handler,
 output_path="$",
)

## State machine definition
task_one.add_catch(failure_task, result_path="$.error")
task_two.add_catch(failure_task, result_path="$.error")
state_machine_def = task_one.next(task_two)
state_machine = sfn.StateMachine(
 self, f"failing-state-machine", definition=state_machine_def
)

Sources

AWS Step Function Documentation - handling error conditions

CDK Deployment Troubleshooting

Tue, 07 Jun 2022 18:23:48 +0000

There are a number of avenues to explore for troubleshooting a CDK deployment.

More Than One Index Error

If you know you haven’t actually created or deleted multiple DynamoDB indexes, npx aws-cdk diff (or cdk diff if CDK was installed globally) will tell you what the differences between the synthesized template and deployed template actually are.

Source

API Gateway URL Construction

Tue, 07 Jun 2022 16:39:00 +0000

This is the construction of the base URL of an API Gateway API: https://{restapi_id}.execute-api.{region}.amazonaws.com/{stage_name}/

Sources

AWS Docs - How to call API

REST API Best Practices

Tue, 07 Jun 2022 15:50:53 +0000

Path vs. Request Parameters

Path parameters (/item) identify a specific resource(s), while request parameters (/item?color=blue) should act to filter items of that resource.

Sources

Path vs. Request Parameters

Click Quickstart and Reference

Wed, 27 Apr 2022 01:33:12 +0000

Quickstart

@click.command
@click.option('-c', '--count', default=1, help='number of greetings')
@click.argument('name')
def hello(count, name):
 for x in range(count):
 click.echo(f"Hello {name}!")

^jaloxu

What it looks like:

$ python hello.py --help
Usage: hello.py [OPTIONS] NAME

Options:
 --count INTEGER number of greetings
 --help Show this message and exit.

Arguments vs. Options

Arguments and options are the two parameter types supported by Click.¹

Arguments

Arguments do less than options, but can do some things that options can not, such as take in an arbitrary number of arguments. They are also always required.

Using Entry Points in Poetry

Wed, 27 Apr 2022 00:59:17 +0000

same: Using Poetry to Change Python Versions and Create New Virtual Environment

Using Entry Points in Poetry

If you need to use entry points in a Poetry project, you can use a feature in pyproject.toml for the same behavior as in setuptools. This feature is the heading [tool.poetry.scripts]. Under this, you create the linkage between a command and a function in your script in the form of cmd = "package.module.path:function", giving the fully qualified location of the function using the same dot notation as you would with an import statement.

Use multiple context managers in Python

Wed, 27 Apr 2022 00:36:53 +0000

In Python, you can use multiple context managers on the same block. To do that, simply separate the context manager declarations with a comma.

 with context_manager1 as ctx1, context_manager2 as ctx2:
     do_stuff()

Source

Original note

IAM Bucket Policies for User-Level Access

Tue, 26 Apr 2022 21:57:03 +0000

If you want to have user-level access for an indvidual bucket (or other resource), create an IAM policy scoped to that individual resource (or the whole class of resources if you want), and attach it directly only to the users that need that access. Other users won’t be able to access it by default.

Source Original note

What Is An Evergreen Note Anyways

Wed, 20 Apr 2022 02:35:33 +0000

An attempt to classify different note types, their definitions/defining characteristics, and what they’re for. This is largely a synthesis/summary of Andy Matuschak’s notes on notes, as his system has resonated the most with me.

Literature Note

These are lightweight insights that are processed like fleeting notes. They’re usually very small, and that’s okay. A literature note should be a reminder for some passage with just “a few words of context to jog your memory about what the passage was about” or what you were thinking about.

Object Pronouns

Wed, 13 Apr 2022 21:51:01 +0000

Order of Indirect and Direct Object Pronouns

When using indirect and direct object pronouns together, the indirect comes first, followed by the direct object pronoun. Any non-pronoun objects can be referred to in any order.

Example

Αγοράσατε το κινητό στο παιδί σας/Αγοράσατε στο παιδί σας το κινητό. (both valid constructions)
- Του το αγοράσατε

Pronouns with Indefinite Articles

If you would normally use an indefinite article with an object, you can’t use an object pronoun for it. This is because object pronouns refer to a specific instance of an object, rather than any instance.

Short Stories in Greek Vocabulary and Exercises

Sat, 09 Apr 2022 02:54:54 +0000

Chapter 1 Vocabulary

επόμενος/η/ο - next η παιδική χαρά - playground η κούνια - swing η τραμπάλα - see-saw η τσουλήθρα - slide πέρα δώθε - back and forth ξεκουράζομαι - to rest, relax opposite of κουράζομαι με τίποτα - in no way η άμμος - sand πλατσουρίζω - splash in/wade (only in water) κάνοντας - making/doing (present participle) Κάνοντας πως δεν μας είδε, συνέχισε να περπατάει. Pretending (lit: making as if) he didn’t see us, he kept on walking μαζεύω - gather, pick up, collect το περίπτερο - kiosk, newsstand συνήθως - usually απολαυστικός/ή/ό - enjoyable/pleasurable

Indirect Object Pronouns

Sun, 03 Apr 2022 20:07:59 +0000

same: Direct Object Prounouns

Indirect object pronouns are pronouns that are affected by verb’s action in place of the object itself. In English, an example would be “I gave the book to her” where her is the indirect object pronoun that (indirectly) receives the action of gave. In Greek, this example would be Της έδωσα το βιβλίο. Indirect object pronouns can be used for any object of a sentence that in English would be accompanied by a preposition.

Direct Object Prounouns

Wed, 30 Mar 2022 22:25:14 +0000

same: Indirect Object Pronouns

Direct object prounouns are pronouns that receive a verb’s action in place of the object itself. In English, an example would be “I borrowed it” where it is the direct object pronoun of borrowed. In Greek, an example would be Το διαβάζω or “I am reading it”.

Strong and Weak Forms

Direct object pronouns have two forms: the “strong” and the “weak” forms. The strong form can stand on its own and comes after the verb - it is also considered an “emphatic” form. The weak form can not, is placed before the verb (except with imperative and gerund verbs, e.g. πάρε την), and can’t be used after prepositions.

How to Pass Arguments to Training Code in Sagemaker via a Step Function

Tue, 29 Mar 2022 03:43:22 +0000

To pass arguments to training code in Sagemaker by itself or via a Step Function, set up an argument parser in the Python script with keyword arguments.

Example

Implement an argument parser in the Sagemaker entry point script. For example, in a Python script:

 import argparse

 if __name__ == "__main__":
 parser = argparse.ArgumentParser

 parser.add_argument("--learning-rate", type=int, default=1)
 parser.add_argument("--batch-size", type=int, default=64)
 parser.add_argument("--communicator", type=str)
 parser.add_argument("--frequency", type=int, default=20)

 args = parser.parse_args
...

Start a training job with hyperparameters.

Baseline Competency for Engineering Teams

Tue, 29 Mar 2022 03:39:07 +0000

A baseline level of competency should be defined and understood by an organization as the minimum skillset needed across the team/org. It is difficult to define, but the definition should be based on the shape and structure of the team network, and understood to change over time.

This is in context of contagions as ideas that spread through a team (or network), if there are wide bridges between nodes, the contagion can spread more easily. An example of a contagion would be a new technology.

Using Poetry to Change Python Versions and Create New Virtual Environment

Fri, 25 Mar 2022 00:05:44 +0000

With Poetry, to change an underlying Python version (for testing, etc.) and create a new virtualenv on top of that, use poetry env use /PATH/TO/VERSION/BINARY. For pyenv, this will be poetry env use ~/.pyenv/versions/x.y.z/bin/python3. This will create and activate a new virtual environment, but it won’t show up automatically in the shell. To make it show up, get the full path of the activated virtual environment with poetry env list --full-path, then use that with source /VIRTUALENV/PATH/bin/activate.

Real World Problem Spaces Exhibit Non-Stationarity ie They Drift

Thu, 24 Mar 2022 22:32:56 +0000

Data Drift

Machine learning models are stationary. The trained model is an artifact that doesn’t move, however the problem space in the real world does (see this diagram), which is referred to as data drift. Recall that machine learning models can be thought of as existing in a multidimensional Euclidian space.

There are two kinds of drift:

concept drift - also known as real drift, this is a shift in the relationship between model inputs and outputs. Because p(y | x) changes, this always causes model decay.
data drift - also known as input drift, feature drift, or covariate shift, this is a change to the statistical distributions within the input data. It can cause model decay by driving a change in p(y | x) but doesn’t necessarily. When it doesn’t, it is referred to as virtual drift.

Both kinds of drift can manifest in at least 4 modes: 1. Abrupt 2. Incremental 3. Gradual 4. Reoccurring (e.g. seasonality)

Supervised Machine Learning Data Exists in a Euclidean Space

Thu, 24 Mar 2022 15:32:29 +0000

All training data exists as points in a multidimensional Euclidean space. You can visualize an enclosure of this data (the training domain). Within that space, supervised ML acts as interpolation geometry.

Visualization

In reality, the training domain will look jagged and weird because data is messy, incomplete, and often doesn’t line up with the regional problem space. Because ML models can not extrapolate, the model won’t work well at the edges or outside of the training domain.

FourthBrain - ML Model Drift and Decay

Tue, 22 Mar 2022 21:43:08 +0000

FourthBrain - ML Model Drift and Decay

Metadata

URL: https://www.youtube.com/watch?v=C1yiOonTYqM Author: FourthBrain

Literature Notes

TABLE rows.file.link AS "Literature Note", rows.file.cday AS "Date"
FROM #note/literature AND Example Title
GROUP BY file.link
sort date ASCENDING

Note: there may not be many literature notes for this, because it’s a how-to type of talk, where there won’t be notes on the piece itself, but on what it teaches.

Fleeting Notes

Supervised ML is interpolation geometry. “All training data exists as points in a Euclidean space…we can create an enclosure. Then, inside that enclosure, we can interpolate.” Global problem space -> regional problem space -> training domain -> model. When we get data, there are quantity and quality gaps which are smaller than the ideal training domain. This means that a model won’t work well at trying to predict on observations that fall outside the training domain because machine learning models for non-linear problems are interpolation machines. They can not extrapolate. Active learning can fix gaps between the training domain and regional problem space. This flags and prioritizes confusing inputs for human ground-truthing and augments the training set with newly labeled observations to fill gaps in the training domain. Most machine learning methods are based on the assumption that the problem space does not change over time. In the real world, though, the problem space does indeed change - this is called non-stationarity. In other words, the problem space drifts out of alignment with the existing training domain and model (data drift). Addressing data drift can take the form of filling gaps with active learning or pruning old or obsolete observations by using a weighting scheme (among other strategies). MLOps and Pipelines are beneficial for monitoring models for appreciable drift and refitting the model on augmented training data when drift is detected. Two kinds of drift: - concept drift - or real drift; a shift in the relationship between model inputs and outputs (changes p(y | x)). This always causes model decay. - data drift - change to the statistical distributions within the input data (also known as input drift, feature drift, covariate shift). This can cause model decay by driving a change in p(y | x). If it doesn’t cause that change, then it’s called virtual drift. Both kinds of drift can manifest in 4 modes: 1. Abrupt 2. Incremental 3. Gradual 4. Reoccurring (like seasonality)

Rebuilding Missing Resources in CDK

Mon, 14 Mar 2022 19:37:06 +0000

In AWS CDK, if a resource like a DynamoDB table is missing (maybe it was accidentally manually deleted) with a ResourceNotFound or Unable to retrieve arn error, you can recover it without tearing down the whole stack by recreating the resource with the same full name that the CDK stack/CloudFormation template is looking for.

Source

AWS docs

Testing Python Code with Pytest

Mon, 14 Mar 2022 19:20:53 +0000

Mocking External Code

To mock outside function calls with Pytest, install the pytest-mock package and use mocker as a parameter to your test function. Then you set the patch with the following syntax: mocker.patch.object(Class, "function_name", replacement_function). Note how there aren’t any parantheses for the functions - either in the string representation or the actual function. This is because if they were used, the function would be evaluated at the call, rather than passed in to the patch.object function. These are best done in setup functions rather than the test function itself.

PynamoDB Filters

Mon, 07 Mar 2022 23:50:59 +0000

Filter Conditions in PynamoDB

Filter conditions in PynamoDB are objects of the class pynamodb.expressions.condition.Comparison. For testing, you can get the string representation by casting it to a string, and I can use that for matching.

Example

Creating a condition

condition = None
if source:
    condition &= Model.source == source
if time_limit:
    time_limit_min = datetime.timestamp(datetime.now() - timedelta(days=time_limit))
    condition &= time_limit_min <= Model.last_updated

In PynamoDB, filter objects overload common Python logic operators for translation into DynamoDB’s conditional filter operators. You can find the translation table here.

Force a Python Function to Only Accept Keyword Arguments

Fri, 04 Mar 2022 22:03:04 +0000

In Python 3, you can force a function to only accept keyword arguments (even without default values) by making the first parameter an asterisk *.

Example

def myfunc(*, a, b, c):
    ...

Source

Unpacking Object Parameters in Python

Fri, 04 Mar 2022 21:20:19 +0000

In Python, if two objects have the same parameters, you can unpack the output of the __dict__ method of an instance of one into the constructor of another to transmute an object.

Example

## Create an instance of Class B using the properties of an instance of Class A
b = ClassB(**instance_a.__dict__)

Imports and Class Instances

Fri, 04 Mar 2022 21:17:11 +0000

In Python, if you return a class instance, that instance has everything a consumer needs to use it. So for instance, if I pass a PynamoDB model object (indicating a document in DynamoDB) back to a consumer, they’ll be able to use it without importing Pynamo directly.

Source

https://stackoverflow.com/questions/27991552/when-does-a-passed-class-instance-require-an-import-in-python

Database Engineering and Machine Learning Systems for Data Science Curriculum

Fri, 18 Feb 2022 00:47:25 +0000

This is a list of resources to gain an advanced understanding of databases and machine learning systems that data engineers, MLOps professionals, ML engineers, and other titles build for R&D groups. Because this is a major part of my own job description, I wanted to compile this list of courses to be consumed as projects to improve what I build for my own teams.

The first iteration of this comes completely from Arun Kumar’s response thread to me asking about how to learn these things without shelling out for an MS in CS (still a goal of mine, though!).

AWS Lambda Return Values for API Triggering

Mon, 07 Feb 2022 21:41:05 +0000

A Lambda triggered by an API has to return a dictionary with certain keys and values in order to not cause an error in execution (e.g. “malformed lambda proxy response”). These are the status code, body (JSONified), and if it’s base64 encoded. Headers can also be added to this structure, but they don’t seem required.

Code Example

    return {  
      "statusCode": 200,  
   "body": json.dumps(f"User {username} not found"),  
   "isBase64Encoded": False  
  }

Sources

Passing Secrets into Lambdas in CDK

Mon, 07 Feb 2022 18:43:52 +0000

same: AWS Lambda Return Values for API Triggering, To Build a Lambda from a Dockerfile in CDK

Passing Secrets into Lambdas in CDK

Do not pass Secret Manager values via environment variables in your CDK Stack! This is a problem for two reasons:

This exposes the Secret in the generated CF templates.
This only pulls the Secret value at deploy time only if the Secrets construct or Lambda in question will be rebuilt upon deploy or synthesis. If the keys are rotated, and the constructs in the CDK stack aren’t changed, this won’t be picked up by the app.

To address this, handle Secret Manager secrets in the following way:

Install Specific CDK Version And-Or By Project

Mon, 07 Feb 2022 18:32:33 +0000

Install Specific CDK Versions And/Or By Project

You can install the CDK toolkit for a specific project by omitting -g from the npm install command then invoking it with npx aws-cdk. You can also install the toolkit for a specific version with npm install -g aws-cdk@x.yyy.z.

Install specific version for a project

Navigate to project directory
- npm install aws-cdk@x.yy.zzz
- npx aws-cdk ...

Install specific version globally

npm install -g aws-cdk@x.yyy.z
aws-cdk ...

Use the installed version

npx aws-cdk ...

AWS API Gateway Changes Break Deployment

Mon, 07 Feb 2022 15:43:47 +0000

If you try to rename a parameter in a deployed API Gateway object via CDK, deployment will break (you won’t be able to deploy the change). This seems to do with how CloudFormation diffs are applied, and it will cause a conflict during the deployment process (see here). The workaround is to comment out all the API code in the CDK stack, deploy, then uncomment and redeploy. This removes and remakes the API.

DynamoDB Index Read and Write Capacity in PynamoDB

Fri, 04 Feb 2022 19:42:30 +0000

When setting up a Global Secondary Index model in PynamoDB, the read and write capacity units have to be specified. These are not needed if not provisioning a table or index, yet are not optional. Arbitrary values can be used and nothing will be done with them.

Example

class ModelIndex(GlobalSecondaryIndex):
  class Meta:
      index_name = "model-index"
      read_capacity_index = 0  # Not used, since the table isn't being provisioned
      write_capacity_index = 0
      projection = AllProjection
  model_key = UnicodeAttribute(hash_key=True)

PynamoDB Field Aliases

Fri, 04 Feb 2022 17:59:50 +0000

To give an alias to DynamoDB field with PynamoDB, use the attr_name parameter for the appropriate attribute constructor:

class Thread(Model):
class Meta:
    table_name = 'Thread'
forum_name = UnicodeAttribute(hash_key=True)
# This attribute will be called 'tn' in DynamoDB
thread_name = UnicodeAttribute(null=True, attr_name='tn')

The Past Imperfect (Continuous Past) Tense

Thu, 27 Jan 2022 17:49:12 +0000

The Past Imperfect or Continuous Past Tense (ο Παρατατικός)

Meaning

A habitual or continuous action that happened in the past with no fixed temporal boundary.

Example

I was reading the book -> Διάβαζα το βιβλίο

Conjugation

Past imperfect (continuous past) is the same as the present tense but has the ending of the aorist (simple past) as well as the accent shift:

Present	Continuous past (παρατατικός)	Aorist (αόριστος)
νοικιάζω	νοίκιαζα	νοίκιασα (aorist)
διαβάζω	διάβαζα	διάβασα
νιώθω	ένιωθα	ένιωσα
πθγαίνω	πήγαινα	πήγα (*)
θέλω	ήθελα	ήθελα (*)
μένω	έμενα	έμεινα (*)

Group A (-ω) Endings

-α -εσ -ε -αμε -ατε -αν

Personal Site Redesign

Wed, 26 Jan 2022 04:46:05 +0000

Overview

I want to move away from webflow and build a simpler, static site for my articles and stuff.

Lessons Learned

Hugo archetypes are templates for different content types. They allow you to configure different frontmatter. - Hugo Archetypes

Each directory within the content/ directory defines a different content section (like tutorials, articles, etc.), and this is used to determine a content’s content type. - Hugo Project Architecture

Page Bundles are a way to organize pages. Branch bundles are used for a home page, section page, taxonomy terms, etc. (these are list pages) and must contain at least an _index.md file. Leaf bundles contain at least an index.md file and define a regular page. These aren’t required organization methods, however. This all occurs within the content/ directory.

PynamoDB Arguments

Wed, 26 Jan 2022 04:37:46 +0000

In PynamoDB, when running a DynamoDB query, the first two positional arguments are the hash key (primary key) and filters for the range key (sort key). To do a filter expression without querying on the range key, explicitly provide the filter_condition_expression parameter.

Example

    return [
        post
        for post in PostModel.query(
            user_id,
            filter_condition=(PostModel.media_type == "IMAGE") & PostModel.image_key.exists(),
            limit=100,
        )
    ]
    ```

TypedDicts in Python

Thu, 13 Jan 2022 17:11:28 +0000

In Python 3.8+, you can create a dictionary with type annotations with the TypedDict class in the typing module. This is a regular dictionary that allows you to define it with type hints, allowing for better documentation of simple objects like dictionaries. To use them, create a class that inherits from typing.TypedDict and define your expected keys and their types like so:

from typing import TypedDict

class ModelMetadata(TypedDict):
    audience_id: str
    training_correlation: List[float]
    validation_correlation: List[float]
    final_sample_count: int
    final_accounts: List[AccountMetadata]

Software Engineering MOC

Sun, 09 Jan 2022 19:38:23 +0000

Cloud Engineering

AWS MOC | Cloud Engineering MOC

Languages

python | Elixir MOC | Rust MOC

Tools

Addressing Docker No Space Left on Device Errors | Docker Copy and Add | Configure a Docker Interpreter in PyCharm

Miscellaneous

Learning How to Program | Database Engineering MOC | Algorithms MOC | Data Structures MOC

Setting Pynamo Model's Table After Instantiation

Mon, 22 Nov 2021 03:35:57 +0000

In some cases you may not know the table for a Pynamo model until you instantiate it. You can’t do this when you construct the object, but you can create a static method that takes the model class and table name and sets model.Meta.table_name to the table_name parameter, changing the table that model is connected to. This is useful if you set up models in one module and then import it elsewhere, and the table names come from user input.

Addressing Docker No Space Left on Device Errors

Mon, 15 Nov 2021 23:03:06 +0000

When you build Docker assets with CDK, they are still built locally and aren’t removed when the process is complete. You may eventually hit this error: #8 29.62 ERROR: Could not install packages due to an OSError: [Errno 28] No space left on device. This is because the images and containers are sitting in the Docker disk image that is of a fixed size. To fix this, you can prune all stopped containers, images, and volumes with docker system prune --all, volumes only docker system prune --volumes. To prune all images: docker prune images -af

To Build a Lambda from a Dockerfile in CDK

Wed, 27 Oct 2021 19:24:41 +0000

Creating the Dockerfile

To set up a Dockerfile for a Lambda function that relies on non-AWS base images, you have to include the Python package awslambdaric in your requirements and install it. Then, do the following in the Dockerfile:

ENTRYPOINT [ "/usr/local/bin/python", "-m", "awslambdaric" ]  
CMD ["lambda_code.function_name"]

Example

ARG FUNCTION_DIR="/function"
  
FROM tensorflow/tensorflow:2.4.3 as DEV  
ARG FUNCTION_DIR  
RUN mkdir -p ${FUNCTION_DIR}
## copies python code into container's FUNCTION_DIR
COPY lambda_code.py ${FUNCTION_DIR} 
## copies lambda_requirements.txt into container's requirements.txt
COPY lambda_requirements.txt ./requirements.txt  
## copies dataset into container's FUNCTION_DIR/dataset/
COPY dataset ${FUNCTION_DIR}/dataset/  
RUN pip install --no-cache-dir --upgrade pip && \  
    pip install -r requirements.txt --target ${FUNCTION_DIR}  
WORKDIR ${FUNCTION_DIR}  
ENTRYPOINT [ "python", "-m", "awslambdaric" ]  
CMD ["lambda_code.function_name"]

Setting Up the Lambda in CDK

To create a Lambda from a Dockerfile in CDK, use cdk.aws-lambda.DockerImageFunction when defining your Lambda:

Input and Output Channels for Sagemaker Training Jobs

Wed, 27 Oct 2021 19:08:01 +0000

Inputs

With SageMaker training jobs, you specify an “input channel” and configure it in the job definition. Each channel is a dictionary that specifies the data split. Each of these items will be made available on the instance in /opt/ml/input/data/<stage>.

JSON Example

{
 "train": {
 "ContentType": "trainingContentType",
 "TrainingInputMode": "File",
 "S3DistributionType": "FullyReplicated",
 "RecordWrapperType": "None"
 },
 "evaluation": {
 "ContentType": "evalContentType",
 "TrainingInputMode": "File",
 "S3DistributionType": "FullyReplicated",
 "RecordWrapperType": "None"
 },
 "validation": {
 "TrainingInputMode": "File",
 "S3DistributionType": "FullyReplicated",
 "RecordWrapperType": "None"
 }
}

CDK Example

Source

Outputs

With SageMaker training jobs, model artifacts should be saved to /opt/ml/model/ so that, with the training job output configuration, they will be zipped and added to S3. Failures can be written to the file /opt/ml/output/failure and the first 1024 characters will be returned as FailureReason.

The Advantage of gRPC is Language-Agnosticism

Tue, 19 Oct 2021 21:05:15 +0000

The major advantage of gRPC on AWS seems to be the ability to call services in a language agnostic manner from code, without having to use HTTP and the limitations that come with it. The other advantage is that the calling code just has to call the defined method for the service.

Sources

Introduction to gRPC

The Diminutive in Greek

Mon, 18 Oct 2021 23:06:53 +0000

Nouns

Diminutive Uses

Actual diminutive
- παιδάκι - little kid
Affection
- παιδάκι for adult kids
Insult
- ανθρωπάκι - a little man

Diminutives

Neutral
- -ακι
Feminine
- -ιτσα
- -ουλα
Masculine
- -ακης
  - Mostly found on names
- -ούλης
  - Mostly found on adjectives

Adjectives

-ούτσικος turns a masculine adjective into a diminutive form

Example

καλός (good) -> καλούτσικος (not bad, so-so)

Να with noun or pronoun

Mon, 18 Oct 2021 23:01:17 +0000

Θέλω να αγοράσω - να means “to” να πάμε για φαγητό - να means “shall” (shall we go for food) να ο Γιάννης, τον βλέπω, έρχεται - να means “here is” να is an indicative particle

να + noun or να + pronoun -> “here is” Πού είναι ο Γιάννης; Αυτός είναι εδώ -> Να τος
Basically for αυτός/αυτή/αυτό αυτοί/αυτές/αυτό you take out the αυ to prepend the να
- να τος - here he is
- να τη
- να το
- να τοι
- να τες
- να το

εμείς είμαστε εδώ (we are here) -> να μαστε See also Ελληνικά για σας Α2 p. 124 γραμματική 2

AWS MOC

Mon, 27 Sep 2021 14:47:02 +0000

How Tos

How to Set Up an API with AWS API Gateway to Trigger a Step Function with Input

Service Notes

ECS Notes | sagemaker | AWS Lambda MOC

Events in Solidity

Wed, 15 Sep 2021 02:34:35 +0000

Events are smart contract members in Solidity, which allow a smart contract to emit events to any listeners on the blockchain. These allow outside applications to consume data from a smart contract in real time.

Sources

https://hackernoon.com/how-to-use-events-in-solidity-pe1735t5

Making Notes from Outside Sources

Wed, 01 Sep 2021 22:58:12 +0000

Highlights and Fleeting Notes

These can be done the same way as fleeting notes from original work are, or on a page of notes for a source within the Sources folder. They can be the raw material for creating Literature Notes as highlights, as well as original ideas, questions, etc. to “serve as reminders of what is in your head.” (https://fortelabs.co/blog/how-to-take-smart-notes/)

Process highlights as you would fleeting notes - preferably right after taking them - and turn them into literature notes.

Ham Radio MOC

Sun, 29 Aug 2021 18:15:07 +0000

Radios

RTLSDR MOC | Icom IC-

Antennas

Random Wire Antenna

Projects

Get on the Air with FT-8

Modes

APRS MOC | FT-8 | ADS-B

Activities

SDR Listening | Parks on the Air | DX

Learn Functional Programming With Elixir

Thu, 19 Aug 2021 21:35:26 +0000

Metadata

Author: Ulisses Almeida
Full Title: Learn Functional Programming With Elixir
Category: #books

Literature Notes

TABLE rows.file.link AS "Literature Note", rows.file.cday AS "Date"

FROM #note/literature AND [Learn Functional Programming With Elixir](/notes/learn-functional-programming-with-elixir/)

GROUP BY file.link

sort date ASCENDING

Summaries

Chapter 1: Thinking Functionally

In functional programming, functions are the basic building blocks of a program, values are immutable, and the code is declarative, rather than imperative. Functions, immutability, and declarative code are the core principles of functional programming.

Interests MOC

Wed, 18 Aug 2021 03:33:09 +0000

Navigate your “library” with a classification system modified for PKM. This is for knowledge. Navigate research topics at Things To Explore.

Knowledge Management

The Note-Taking MOC defines some standards for taking notes.

Personal Management

Writing MOC | Projects MOC | Finances MOC | Fitness MOC

Philosophy & Psychology Spirituality & Religion

Politics | Society | Law | Relationships

Communications & Rhetoric; Language & Linguistics

greek

Natural Sciences

Biology MOC | Physics MOC

I want to...

Tue, 17 Aug 2021 03:21:13 +0000

I want to get my bearings. Click +Home.
I want to journal in a new daily note.
- Click on “Open today’s note”. Tag it with #my/journal
I want to process new #source material, adding my own commentary.
- Go to Sources MOC
- From that processing, I want to make new notes.
I want to find undeveloped notes and build them.
- Click #state/develop
I want to further develop half-formed seedlings into fuller notes.
- Click #state/boat (also search TK).
I want to forge, collide, and craft ideas in an #MOC note.
I want to further tidy up valuable, but messy notes.
- Click #state/tidy
I want to build something
- Go to Projects MOC
I want to write something
- Go to Writing MOC
I want to spend some time researching a topic
- Click #research-topic
I want to navigate my existing spatial constellation of ideas.
- Either go to: Interests MOC or “Open graph view”
I just want to browse around and have fun. Same as above.
I want to review my timestamped notes
- (If you have hotkeys set up, you can go from day to day with a click. It’s pretty awesome.)
I want to do a deeper reflection and planning session.
- Go to: #my/review, #my/goals, and #my/planning
I want to dig into my projects and ideas
- Go to Projects MOC
I want to be surprised (click on “Open random note”)

Simple Subjunctive

Mon, 16 Aug 2021 11:56:52 +0000

να + aorist verb stem indicates the simple subjunctive (one time)

Example

Αυτό το Σάββατο όμως αποφασίσαμε να μη βγούμε.
Εγώ και η Τάνια αποφασίσαμε να βγαίνουμε έξω κάθε Σάββατο.

ADS-B

Mon, 16 Aug 2021 11:56:51 +0000

Flight tracking @ 1090 MHz

Powers FlightAware

Radio

RTLSDRs work well out of the box for ADS-B listening
- I use the Nooelec NESDR Smart V4 (affiliate link)

Software

MacOS

Cocoa1090
- Need to run rtl_tcp first
- Map view isn’t great
Dump1090 by antirez
- Much better map view, but doesn’t work in Brave
- ./dump1090 --interactive --net

Raspberry Pi

Dump1090 and OpenSky tutorial

Antennas

Wine cork antenna
The shorter antennas with the RTLSDR work great
ADS-B Antenna

APRS MOC

Mon, 16 Aug 2021 11:56:51 +0000

APRS Over Satellites
Successful listening with gqrx and the built-in AFSK1200 decoder
Installing Xastir to set up an APRS iGate
- http://xastir.org/index.php/Homebrew
- Use via command line after running XQuartz with xastir &
- Still need to do some configuration. Installation was done 2021-06-06
  - Xastir with RTLSDR
    - Need to use multimon-ng with rtl_fm and socat
      - rtl_fm -f 144390000 -s 22050 -o 4 -g 100 - | multimon-ng -a AFSK1200 -A -t raw - | sed -u -r 's/^.{6}//' | socat -u STDIN TCP-LISTEN:14580,reuseaddr,fork
        
        Then Xastir needs to have connect to an internet server with localhost:14580
        
        I set this to an alias start_aprs
    - Configuration
      - Run callpass to generate
      - Station
        
        GPS, comments
      - Defaults
        
        Enable RF->Inet OR 2-way
      - Interface
        
        Internet for APRS Tier 2 server interface (along with radio interface if want to function as igate)
        
        This should be allowed to transmit
        
        Password from callpass goes here
To use Xastir with SDR
- Run start_aprs alias
- Launch XQuartz
- From the terminal that pops up, run xastir &
How to pass messages to internet?
- Set up password by running callpass <callsign> to send and receive, add that to Tier 2 server interface config
- I added another internet interface and pointed it to one of the Tier 2 APRS servers. I haven’t seen anything on APRS.fi yet though.
  - Enable RF->Inet OR 2-way also needed. Verified on aprs.fi
Thinking about getting a Baofeng UV-5R for cheap APRS operation
- Got it
Get Started with APRS with RTLSDR and Xastir on Mac Hub Page

Other Modes

FT-8

Notes on The Edge Cases

Building Docker Images on M1 Mac for Other Platforms

Strategies for Mocking AWS Services for Testing

Stubber

Moto

Patching Clients and Resources

Organizing Python Packages and User-Facing API with __init__

Notes for Backpropagation Through Space Time and the Brain

Summary

💡Ideas

Fleeting Notes

Literature Notes

Intro to Database Systems Notes

Intro to Database Systems CMU 15-445/645

Overview

Lessons Learned

Resources

Course Slides

Project Plan

Designs

Questions

Lecture Notes

01 - Course Introduction and Relational Model

The Polyglot Method

Overview

Core Concepts

The Method

Model Context Protocol Clients Make Use of MCP Servers to Get External Tools, Prompts, Resources, and More

Purpose

Development Pattern

Client Class

See also

Model Context Protocol Servers Define and Serve Functions That Can Extend Client Functionality Using an LLM For Coordination

Development Pattern

Tools

Prompts

Anthropic Streaming Event Types

Event Types

Working with Anthropic's Model Context Protocol

Overview

Architecture

Servers

Clients

Hosts

What They Do

Consulting - Getting Started Resources

Communities

Books

Courses

Bloggers/Influencers

Meta

Accounting

General Business

Insurance

LLC

Website

PNG Image Modes

Using Step Functions for Fan-Out or Scatter-Gather

Switching AWS CLI Profiles

Opening Text-Based pgdump Database Backups (postgres)

"Double free or corruption" Error Opening Images with Pillow

Source

Docker Run Issues - Unable to Start Container

Troubleshooting SSH Issues on EC2

OpenAI's GPT API's max_token parameter is a limit for prompt and returned completion

Source

DynamoDB Can Take a Static Table Name

Pickled Object Versioning and Compatibility

Storing the Object Version

Overriding Class Methods in Python

Example

Heads in Machine Learning Are Prediction Components of a Deep Neural Network

Running a Jupyter Notebook From a Docker Container Running on EC2

Troubleshooting

Working Within a Running Docker Container

Forwarding SSH Keys Through a Docker Image with Docker Build

Purpose

The Technique

Installing Dependencies from Github Repos with Pip and Poetry

pyproject.toml

Organizing Python Packages and User-Facing API with init