Zettelkasten (this page)

A co-worker of mine used to keep all his notes in one large notepad file. He literally used Windows notepad.Then when he needed to check his notes, he would simply do keyword searches on the file. It went back years and proved to be a better reference than a fancy knowledge base. This file is a similar dump for myself. It includes everything I read, notes and cheatsheets. Organized with markdown but may move for emacs org mode format in the future. Creative commons license.

Ideas and Qoutes

https://slife.org/japanese-proverbs/

成功する事よりも、失敗しない事の方が重要だ。- Seikou suru koto yori mo, shippai shinai koto no hou ga juuyou da.

Meaning: It’s more important to not fail than to succeed.

“I constantly see people rise in life who are not the smartest, sometimes not even the most diligent, but they are learning machines. They go to bed every night a little wiser than they were when they got up and boy does that help, particularly when you have a long run ahead of you.” ― Charles T. Munger

Simple tools for complex interactions.

Tools over process.

Reading Notes

Neural Networks From Scratch

Layers

import numpy as np

class Layer_Dense:
  def __init__(self, n_inputs, n_neurons):
    self.weights = 0.01 * np.random.randr(n_inputs, n_neurons)
    self.biases = np.zeros((1, n_neurons))

  def forward(self, inputs):
    self.output = np.dot(inputs,self.weights) + self.biases

one_hot = [0, 1, 0, 0, 0, 0]

Activation Functions

softmax activation outputs a probability distribution

example output: soft_max = [0.9, 1.2, 0.6]

Loss functions

Categorial cross entropy is used to compare ground truth probability (y targets) against predictions (y-hat)

import math

""" one hot encoding """
target_values = [1,0,0]

softmax_output = [0.7, 0.1, 0.2]

""" note: natural log e**x = b """
loss = -(math.log(softmax_output[0]))

Generic loss class

import numpy as np
class Loss:
  def calculate(self, output, y):
    sample_losses = self.forward(output,y)
    data_loss = np.mean(sample_losses) 
    return data_loss

Cross Entropy Loss class

for classification problems

  # Common loss class
class Loss:
# Calculates the data and regularization losses # given model output and ground truth values  
    def calculate(self, output, y):
          # Calculate sample losses
          sample_losses = self.forward(output, y)
          # Calculate mean loss
          data_loss = np.mean(sample_losses)
          # Return loss
          return data_loss

# Cross-entropy loss
class Loss_CategoricalCrossentropy(Loss): # Forward pass
    def forward(self, y_pred, y_true): # Number of samples in a batch
          samples = len(y_pred)
          # Clip data to prevent division by 0
          # Clip both sides to not drag mean towards any value
          y_pred_clipped = np.clip(y_pred, 1e-7, 1 - 1e-7)
          # Probabilities for target values -
          # only if categorical labels
          if len(y_true.shape) == 1:
              correct_confidences = y_pred_clipped[
                  range(samples),
y_true ]
          # Mask values - only for one-hot encoded labels
          elif len(y_true.shape) == 2:
              correct_confidences = np.sum(
                  y_pred_clipped*y_true,
axis=1 )
# Losses
          negative_log_likelihoods = -np.log(correct_confidences)
          return negative_log_likelihoods

accuracy - how often the largest confidence is the correct class

gradient in gradient descent is the result of the partial derivative of the loss function with respect to the weights

another way of looking at it is the impact that x has on y

ECDSA

https://www.instructables.com/Understanding-how-ECDSA-protects-your-data/

Allows verification of authenticity without compromising security. It is impossible to forge a signature. It does no encrypt the data but ensures it is not tampered with.

Algo (high level)

choose random point on curve, point of origin

generate a random number, private keys

apply equation to private key and point of origin, public key

Sign the file

equation(use the private key, with a hash of the file), signature

signature is divided into R and S

Verification

equation(S, public key) == R

ECDSA uses SHA1 hashes

Mastering Bitcoin

transaction input and output - there will be a difference between them which is the miner fee

transactions form a chain

users keys can unlock previous output in the chain proving ownership

change address - address of new and old user

UTXO - unspent transactions database

Ethereum Book

Fallback functions

It is called when a non-existent function is called on the contract.

It is required to be marked external.

It has no name.

It has no arguments

It can not return any thing.

It can be defined one per contract.

If not marked payable, it will throw exception if contract receives plain ether without data.

Solidity fallback function:

It has no name, no arguments, no return values. It external and payable. Defined once. Called when non-existent function called.

EOA vs. Contract Accounts

Externally owned accounts are those that have a private key; having the private key means control over access to funds or contracts.

A contract account has smart contract code, which a simple EOA can’t have. Furthermore, a contract account does not have a private key. Instead, it is owned (and controlled) by the logic of its smart contract code: the software program recorded on the Ethereum blockchain at the contract account’s creation and executed by the EVM.

account addresses are derived directly from private keys: a private key uniquely determines a single Ethereum address, also known as an account.

Cryptography

There is no encryption as part of the Ethereum protocol—all messages that are sent as part of the operation of the Ethereum network can (necessarily) be read by everyone. As such, private keys are only used to create digital signatures for transaction authentication.

Starting with a private key in the form of a randomly generated number k, we multiply it by a predetermined point on the curve called the generator point G to produce another point somewhere else on the curve, which is the corresponding public key K: K = k * G

the generator point is always the same for all Ethereum users

Ethereum only uses uncompressed public keys; therefore the only prefix that is relevant is (hex) 04.

The test most commonly used for a hash function is the empty input. If you run the hash function with an empty string as input you should see the following results:

Keccak256(““) = c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470

SHA3(““) = a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a

Ethereum uses Keccak-256, even though it is often called SHA-3 in the code.

Ethereum addresses are unique identifiers that are derived from public keys or contracts using the Keccak-256 one-way hash function.

We use Keccak-256 to calculate the hash of this public key:

Keccak256(K) = 2a5bc342ed616b5ba5732269001d3f1ef827552ae1114027bd3ecf1f086ba0f9

Then we keep only the last 20 bytes (least significant bytes), which is our Ethereum address:

001d3f1ef827552ae1114027bd3ecf1f086ba0f9

Wallet

Transactions

A transaction is a serialized binary message that contains the following data:

Nonce

A sequence number, issued by the originating EOA, used to prevent message replay

Gas price

The amount of ether (in wei) that the originator is willing to pay for each unit of gas

Gas limit

The maximum amount of gas the originator is willing to buy for this transaction

Recipient

The destination Ethereum address

Value

The amount of ether (in wei) to send to the destination

Data

The variable-length binary data payload

v,r,s

The three components of an ECDSA digital signature of the originating EOA

Smart Contracts and Solidity

Computer programs

Smart contracts are simply computer programs. The word “contract” has no legal meaning in this context.

Immutable

Once deployed, the code of a smart contract cannot change. Unlike with traditional software, the only way to modify a smart contract is to deploy a new instance.

Deterministic

The outcome of the execution of a smart contract is the same for everyone who runs it, given the context of the transaction that initiated its execution and the state of the Ethereum blockchain at the moment of execution.

EVM context

Smart contracts operate with a very limited execution context. They can access their own state, the context of the transaction that called them, and some information about the most recent blocks.

Decentralized world computer

The EVM runs as a local instance on every Ethereum node, but because all instances of the EVM operate on the same initial state and produce the same final state, the system as a whole operates as a single “world compute

Lifecycle

0x0 special contract creation address

contracts only run if they are called by a transaction

contracts are atomic

To delete a contract, you execute an EVM opcode called SELFDESTRUCT. That operation costs “negative gas,” a gas refund, thereby incentivizing the release of network client resources from the deletion of stored state.

Solidity

function syntax:

function FunctionName([parameters]) {public|private|internal|external} [pure|view|payable] [modifiers] [returns (return types)]

Gas

estimating gas cost:

var contract = web3.eth.contract(abi).at(address); var gasEstimate = contract.myAweSomeMethod.estimateGas(arg1, arg2, {from: account});

To obtain the gas price from the network you can use:

var gasPrice = web3.eth.getGasPrice();

And from there you can estimate the gas cost:

var gasCostInEther = web3.utils.fromWei((gasEstimate * gasPrice), ‘ether’);

Security

Re-entrency

This type of attack can occur when a contract sends ether to an unknown address. An attacker can carefully construct a contract at an external address that contains malicious code in the fallback function.

prevention

The first is to (whenever possible) use the built-in transfer function when sending ether to external contracts.

The second technique is to ensure that all logic that changes state variables happens before ether is sent out of the contract (or any external call).

A third technique is to introduce a mutex.

over flow under flow

prevention

The current conventional technique to guard against under/overflow vulnerabilities is to use or build mathematical libraries that replace the standard math operators addition, subtraction, and multiplication (division is excluded as it does not cause over/underflows and the EVM reverts on division by 0).

Tokens

Interface

ERC20

The ERC20 Interface in Solidity:

contract ERC20 {
function totalSupply() constant returns (uint theTotalSupply);
function balanceOf(address _owner) constant returns (uint balance);
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint _value) returns
(bool success);
function approve(address _spender, uint _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns
(uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}

data structures

mapping(address => uint256) balances;

mapping (address => mapping (address => uint256)) public allowed;

Workflows

1. transfer - wallet to wallet direct transfer of tokens, uses the ‘transfer’ function

2. approve and transfer - two transaction

Editors

nvim

set foling in nvim

https://bitcrowd.dev/folding-sections-of-markdown-in-vim/

https://neovim.io/doc/user/fold.html

config/nvim/lua/config/options.lua

local vim = vim
local opt = vim.opt

opt.foldmethod = "expr"
opt.foldexpr = "nvim_treesitter#foldexpr()"

vim

format a file gg =G

indent visual select < or >

Projectile

M-x projectile-discover-in-directory

Dired

create file spc-. then type filename

open neotree: SPC-o-p

Buffers and windows

buffers - hold data, usually file

Templates

python Makefile

snapshot:
pip3 freeze > requirements.txt

install:
pip3 install --upgrade pip && pip3 install -r requirements.txt

lint:
pylint --disable=R,C app/main.py

format:
black app/*

test:
python -m pytest -vv --cov=main test_main.py

.zshrc zsh utils

mkcd(){
  mkdir -p "$1"
  cd "$1"
}

mkpyvenv(){
  venv=$(basename $(pwd))
  python3 -m venv ".${venv}"
  source ".${venv}/bin/activate"
}

src(){
  venv=$(basename $(pwd))
  source ".${venv}/bin/activate"
}

Programming

Docker

docker init - create a Dockerfile

docker build -t . - build a docker image

docker run -d –name mycontainer -p 80:80 myimage

docker rm

Ollama

ollama list - list all models

ollama run codellama:7b - download and run the 7 billion parameter codellama model

ollama run codellama:7b-python - fine tuned model for python

import ollama
from langchain import Tool, initialize_agent


# Define the function to interact with Ollama's local service
def ollama_local_query(prompt: str) -> str:
    # Initialize Ollama client
    client = ollama.Client(
        base_url="http://localhost:11434"
    )  # Adjust the base_url to your local server's URL

    # Create a request
    request = ollama.GenerateRequest(prompt=prompt)

    # Send the request and get the response
    response = client.generate(request)

    # Extract the text from the response
    return response.text


# Create a Tool instance for Ollama
ollama_tool = Tool(
    name="OllamaTool",
    func=ollama_local_query,
    description="Tool to interact with Ollama language model",
)

# Initialize the LangChain agent with the Ollama tool
agent = initialize_agent(
    tools=[ollama_tool], agent_type="zero-shot-react-description", verbose=True
)

Tailwind

tailwindcss -w -i styles/main.css -o static/css/main.css

Python

langchain

embedding - numeriocal representation of content into a vector that encapisulates its semantic content, for processing

semantic similarity - distance between two vectors

word2vec - learns embeddings by prediciting surrounding words https://arxiv.org/abs/1901.09813

embeddings are usually transformer based models

text = "i am a query"
query_result = embeddings.embed_query(text)
words = ["some","list","of","documents"]
doc_vectors = embeddings.embed_documents(words)

vector distance: euclidian distance or cosine similarity

Vector Euclidian distance

from scipy.spatial.distance import pdist, squareform
import numpy as np
import pandas as pd
X = np.array(doc_vectors)
dists = squareform(pdist(X))

vectorstores - langchain to store and querying vectors

similar_vectors = vector_store.query(query_vector, k)

retreiver - langchain component that queries the vector database on a given index

custom retreiver:

from langchain.schema import Document, BaseRetriever
class MyRetriever(BaseRetriever):
    def get_relevant_documents(self, query: str, **kwargs) -> list[Document]: 
        # Implement your retrieval logic here 
        # Retrieve and process documents based on the query 
        # Return a list of relevant documents 
        relevant_documents = [] 
        # Your retrieval logic goes here… 
        return relevant_documents

DocArray - in memory vector store

Steps to setup a chatbot with langchain

1. setup a document loader

2. store docoments in a vector store

3. setup chatbot retrieve from the vector store

alembic

alembic downgrade base

alembic upgrade head - upgrade to latest version

alembic revision –autogenerate -m “some comments”

dis.dis() - disassemble a function

dir(