From b97810a884975a9a370998202876f00fc5f80bfd Mon Sep 17 00:00:00 2001 From: William Guss Date: Fri, 13 Sep 2024 22:02:50 -0700 Subject: [PATCH 01/11] rambling.. --- docs/ramblings/0.1.0/chain_of_thought_ell | 1 + docs/ramblings/0.1.0/chain_of_thought_ell.md | 249 +++++++++++++++++++ docs/ramblings/0.1.0/chain_of_thought_ell.py | 86 +++++++ docs/ramblings/0.1.0/chat.md | 15 ++ docs/ramblings/0.1.0/test.py | 42 ++++ docs/ramblings/dspy.md | 0 6 files changed, 393 insertions(+) create mode 100644 docs/ramblings/0.1.0/chain_of_thought_ell create mode 100644 docs/ramblings/0.1.0/chain_of_thought_ell.md create mode 100644 docs/ramblings/0.1.0/chain_of_thought_ell.py create mode 100644 docs/ramblings/0.1.0/chat.md create mode 100644 docs/ramblings/0.1.0/test.py create mode 100644 docs/ramblings/dspy.md diff --git a/docs/ramblings/0.1.0/chain_of_thought_ell b/docs/ramblings/0.1.0/chain_of_thought_ell new file mode 100644 index 000000000..b767a2f38 --- /dev/null +++ b/docs/ramblings/0.1.0/chain_of_thought_ell @@ -0,0 +1 @@ +chain_of_thought_ell.py \ No newline at end of file diff --git a/docs/ramblings/0.1.0/chain_of_thought_ell.md b/docs/ramblings/0.1.0/chain_of_thought_ell.md new file mode 100644 index 000000000..f3cb1da8b --- /dev/null +++ b/docs/ramblings/0.1.0/chain_of_thought_ell.md @@ -0,0 +1,249 @@ + +```python +import ell + +@ell.simple() +def chain_of_thought(question: str) -> str: + return f"Reasoning: Let's think step by step in order to " +``` + +DSP is basically sayyhing , dont prompt at all we have high level meta technqiues whic hhave a solution shape (neural architecture) + +we the n can train the promopts based on the solution shape + +in practice i migth actually not do shit liek that at all like inside ghost it was like + +```python + +@ell.simple(model="gpt-4o") +def generate_approaches_to_eamil_somone(linkedinprofile, aboutme): + """ You are a helpful assistant that generates approaches to email someone based on their linkedin profile and your about me. """ + + return f"Come up with one for: {linkedinprofile} given that I am {aboutme}" + +@ell.simple(model="gpt-4o") +def come_up_with_hook_subject_line(approaches, linkedinprofile): + """ You are a helpful assistant that generates hook subject lines for emails based on approaches to emailing someone and their linkedin profile. """ + + return f"Come up with a hook subject line for: {approaches} given that I am {linkedinprofile}" + +@ell.simple(model="gpt-4o") +def write_email(hook_subject_line, linkedinprofile, aboutme): + return f"Write an email based on the hook subject line: {hook_subject_line} and the approaches: {approaches}" + + +linkedinprofile = "linkedinprofile" +aboutme = "aboutme" + +# people are used to doing shit like + +approaches = generate_approaches_to_eamil_somone(linkedinprofile, aboutme) +hook_subject_line = come_up_with_hook_subject_line(approaches, linkedinprofile) +email = write_email(hook_subject_line, linkedinprofile, aboutme) +``` + +what if we want to optimize this chain, or one dividiual prompt + +```python +optimizer = ell.FewShotFromLabels() +better_email_generator = optimizer.fit(generate_approaches_to_eamil_somone, X=profiles, y=correct_appraoches) + +fit: some_lmp -> a_new_lmp +``` + +# an lmp is a function that takes an input and returns the output of an lm. +# when u FewShotFromLabels you prepend shit into the system prompt + + +# so this type of optimizaiton would happen after production of the prompt.. +# it could serialize as +```python +def generate_approaches_to_eamil_somone(linkedinprofile, aboutme): + """ You are a helpful assistant that generates approaches to email someone based on their linkedin profile and your about me. """ + + return f"Come up with one for: {linkedinprofile} given that I am {aboutme}" + +@ell.simple(model="gpt-4o") +def better_email_generator(linkedinprofile, aboutme): + message = generate_approaches_to_eamil_somone(linkedinprofile, aboutme) + "prepend stuff to the messages!" + return message +``` +So it could be that we want to preserve hte programmatic structure of the code... so that inputs are processed in as imilar way. But also we want to allow for variation in the prompt program string so its a double edged sword. + +actually if we introduce a new technique for optimizing LMPs then it doesnt matter.. + + +also what if we want to encourage people to use chain of thought. + + + +like take a complicated lmp + +```python +def get_random_adjective(): + adjectives = ["enthusiastic", "cheerful", "warm", "friendly", "heartfelt", "sincere"] + return random.choice(adjectives) + +def get_random_punctuation(): + return random.choice(["!", "!!", "!!!"]) + +@ell.simple(model="o1-preview") +def hello(name: str): + """You are a helpful and expressive assistant.""" + adjective = get_random_adjective() + punctuation = get_random_punctuation() + return f"Say a {adjective} hello to {name}{punctuation}" + +greeting = hello("Sam Altman") +print(greeting) +``` + +What does it mean to optimize this? Do we want it to preserve the random adjective and punctuation code.? + +Optimizing this module is optimizinf the fn +``` +hello : (name: str) -> str +min_µ ∑ L(hello(x),y) + +hello = [lm : (prompt : msgs) -> str] + • [hello_prompt_µ: (name :str ) -> prompt] +``` + +In DSP we "optimize µ by forward composing it. I think we dynamically construct +hello prompt from a "signature" so that the dynamic construct can bem utated. + + +Consider Predict: + +``` + +class BasicGenerateInstruction(Signature): + """You are an instruction optimizer for large language models. I will give you a ``signature`` of fields (inputs and outputs) in English. Your task is to propose an instruction that will lead a good language model to perform the task well. Don't be afraid to be creative.""" + + basic_instruction = dspy.InputField(desc="The initial instructions before optimization") + proposed_instruction = dspy.OutputField(desc="The improved instructions for the language model") + proposed_prefix_for_output_field = dspy.OutputField( + desc="The string at the end of the prompt, which will help the model start solving the task", + ) + +instruct = dspy.Predict( + BasicGenerateInstruction, + n=self.breadth - 1, + temperature=self.init_temperature, + )(basic_instruction=basic_instruction) + +``` + +So basically all of hte prompts and basic building blocks are already in the library, and +we define these prompt builders which are basically just a bunch of strings and then we can +use DSP to optimize these prompts. + +```python + if instructions is None: + sig = Signature(signature, "") # Simple way to parse input/output fields + instructions = _default_instructions(sig) + return f"Given the fields {inputs_}, produce the fields {outputs_}." +``` + +In fact prompt templates dont really exist within ell and this a major flaw in some sense. + +Like if I want to do CoT waht do I do? +But it's clear code like +```python + prefix = "Reasoning: Let's think step by step in order to" + if dspy.settings.experimental: + desc = "${produce the output fields}. We ..." + else: + desc = f"${{produce the {last_key}}}. We ..." + + rationale_type = rationale_type or dspy.OutputField(prefix=prefix, desc=desc) + # Add "rationale" field to the output si +``` +is very bad.. + + +so recap DSP constructs promps via +``` +( + signature = ( + inputs fields ( + desc,name), + output fields ( + desc, name) + ), + instructions +) -> "prompt" +``` +in ell we could theoretically infer those things +```python +def prompt(params : str): + """Your a good guy""" # system + + return f"Be a good guy " #User prompt +``` + +What is the params in this case (params : str) +well actually its their manifestation in the return cause we can have arbitrary args. So it's like we need the DSP abstractions to construct shit. We could do like + +But DSP is fundamentally higher level. + +Dynamic prompt construciton in ell is also limited. + +```python +@ell.simple() +def hello_with_kshot(name : str, examples : List[str]): + return [ + ell.system("You are a helpful assistant"), + *examples, + ell.user(f"Say hello to {name}") + ] + +``` + +but if i wanted to mutate the prompt after creation i would have to do it manually. + +so leads us to a prompt api + +```python +@ell.simple() : + (lmp : Callable) -> + +class LMP(ell.Module): + def __init__(self, lmp : Callable): + pass + def __call__(self, **kwargs): + prompt: str = lmp(**args, **kwargs) + pre_lm = post_process_prompt(prompt) + lm(pre_lm) + post_lm = post_process_lm(lm) + return post_lm + +``` + +and for dsp we could technically invert params using another llm as a part of optimization + but that's also janky + but so is dpsy + +what would it look like also how should we do cot in ell + +```python +def res(question : str) -> str: + thoughts = think(question) + answer = thoughts.split("Answer:")[1] + return answer + +@ell.simple() +def chain_of_thought(question : str) -> str: + return f"Reasoning: Let's think step by step in order to {question}. " + +``` + +but if we rewrote dspy and forgot about @ell.simple because LMPs are just fucking like weights lol okay so + + +chain_of_thought ===== W^T (process_into_vector(x)) + +but like W^T is like a bunch of format strings and arbitrary instructions so then what the fuck is optimizing CoT cause in Ell we've basically merged data parsing and instruction formattging into one big ass thring + +nah this is bad. \ No newline at end of file diff --git a/docs/ramblings/0.1.0/chain_of_thought_ell.py b/docs/ramblings/0.1.0/chain_of_thought_ell.py new file mode 100644 index 000000000..14052bb76 --- /dev/null +++ b/docs/ramblings/0.1.0/chain_of_thought_ell.py @@ -0,0 +1,86 @@ +import ell + +@ell.simple() +def chain_of_thought(question: str) -> str: + return f"Reasoning: Let's think step by step in order to " + + + +# DSP is basically sayyhing , dont prompt at all we have high level meta technqiues whic hhave a solution shape (neural architecture) + +# we the n can train the promopts based on the solution shape + +# in practice i migth actually not do shit liek that at all like inside ghost it was like + + + +@ell.simple(model="gpt-4o") +def generate_approaches_to_eamil_somone(linkedinprofile, aboutme): + """ You are a helpful assistant that generates approaches to email someone based on their linkedin profile and your about me. """ + + return f"Come up with one for: {linkedinprofile} given that I am {aboutme}" + +@ell.simple(model="gpt-4o") +def come_up_with_hook_subject_line(approaches, linkedinprofile): + """ You are a helpful assistant that generates hook subject lines for emails based on approaches to emailing someone and their linkedin profile. """ + + return f"Come up with a hook subject line for: {approaches} given that I am {linkedinprofile}" + +@ell.simple(model="gpt-4o") +def write_email(hook_subject_line, linkedinprofile, aboutme): + return f"Write an email based on the hook subject line: {hook_subject_line} and the approaches: {approaches}" + + +linkedinprofile = "linkedinprofile" +aboutme = "aboutme" + +# people are used to doing shit like + +approaches = generate_approaches_to_eamil_somone(linkedinprofile, aboutme) +hook_subject_line = come_up_with_hook_subject_line(approaches, linkedinprofile) +email = write_email(hook_subject_line, linkedinprofile, aboutme) + + +# what if we want to optimize this chain, or one dividiual prompt + +optimizer = ell.FewShotFromLabels() +better_email_generator = optimizer.fit(generate_approaches_to_eamil_somone, X=profiles, y=correct_appraoches) + +fit: some_lmp -> a_new_lmp + +# an lmp is a function that takes an input and returns the output of an lm. +# when u FewShotFromLabels you prepend shit into the system prompt + + +# so this type of optimizaiton would happen after production of the prompt.. +# it could serialize as +```python +def generate_approaches_to_eamil_somone(linkedinprofile, aboutme): + """ You are a helpful assistant that generates approaches to email someone based on their linkedin profile and your about me. """ + + return f"Come up with one for: {linkedinprofile} given that I am {aboutme}" + +@ell.simple(model="gpt-4o") +def better_email_generator(linkedinprofile, aboutme): + message = generate_approaches_to_eamil_somone(linkedinprofile, aboutme) + "prepend stuff to the messages!" + return message +``` +# So it could be that we want to preserve hte programmatic structure of the code... so that inputs are processed in as imilar way. But also we want to allow for variation in the prompt program string so its a double edged sword. + + + +# like take a complicated lmp + + +# Actually if we introduce a new technique for optimizing LMPs then it doesnt matter.. + + +#also what if we want to encourage people to use chain of thought. + + + + + + + \ No newline at end of file diff --git a/docs/ramblings/0.1.0/chat.md b/docs/ramblings/0.1.0/chat.md new file mode 100644 index 000000000..41e05a43b --- /dev/null +++ b/docs/ramblings/0.1.0/chat.md @@ -0,0 +1,15 @@ +# Chat + +There needs to be a better way to do chat and message history than + +```python + + +@ell.complex(model="claude-3-5-sonnet-20240620", tools=[create_claim_draft, approve_claim], temperature=0.1, max_tokens=400) +def insurance_claim_chatbot(message_history: List[Message]) -> List[Message]: + return [ + ell.system( """You are a an insurance adjuster AI. You are given a dialogue with a user and have access to various tools to effectuate the insurance claim adjustment process. Ask question until you have enough information to create a claim draft. Then ask for approval."""), + ] + message_history + + +``` \ No newline at end of file diff --git a/docs/ramblings/0.1.0/test.py b/docs/ramblings/0.1.0/test.py new file mode 100644 index 000000000..0d10a1b37 --- /dev/null +++ b/docs/ramblings/0.1.0/test.py @@ -0,0 +1,42 @@ + +from typing import Callable + +# The follwoing works... + + + +def decorator(fn : Callable): + def wrapper(*args, **kwargs): + print("before") + result = fn(*args, **kwargs) + print("after") + return result + return wrapper + + +class TestCallable: + def __init__(self, fn : Callable): + self.fn = fn + + def __call__(self, *args, **kwargs): + return self.fn(*args, **kwargs) + +def convert_to_test_callable(fn : Callable): + return TestCallable(fn) + +x = TestCallable(lambda : 1) + +@decorator +@convert_to_test_callable +def test(): + print("test") + +@decorator +class MyCallable: + def __init__(self, fn : Callable): + self.fn = fn + + def __call__(self, *args, **kwargs): + return self.fn(*args, **kwargs) + +# Oh so now ell.simples can actually be used as decorators on classes diff --git a/docs/ramblings/dspy.md b/docs/ramblings/dspy.md new file mode 100644 index 000000000..e69de29bb From f63e6724d377c32b46972fdc9acfa70210d0ce05 Mon Sep 17 00:00:00 2001 From: William Guss Date: Sun, 15 Sep 2024 11:57:02 -0700 Subject: [PATCH 02/11] better lexical closure tests --- docs/ramblings/0.1.0/cem.py | 279 +++++++++++++++++++++++++++++++++++ docs/ramblings/0.1.0/cpbo.py | 219 +++++++++++++++++++++++++++ docs/ramblings/dspy.md | 3 + tests/test_closure.py | 212 ++++++++++++++++++++++++-- 4 files changed, 701 insertions(+), 12 deletions(-) create mode 100644 docs/ramblings/0.1.0/cem.py create mode 100644 docs/ramblings/0.1.0/cpbo.py diff --git a/docs/ramblings/0.1.0/cem.py b/docs/ramblings/0.1.0/cem.py new file mode 100644 index 000000000..ddeedaa88 --- /dev/null +++ b/docs/ramblings/0.1.0/cem.py @@ -0,0 +1,279 @@ +import gym +import torch +import torch.nn as nn +import torch.optim as optim +import numpy as np +from gym.vector import AsyncVectorEnv +import random + +# Set random seeds for reproducibility +SEED = 42 +random.seed(SEED) +np.random.seed(SEED) +torch.manual_seed(SEED) + +# Hyperparameters +NUM_ENVIRONMENTS = 4 # Reduced for simplicity +NUM_ITERATIONS = 50 # Number of training iterations +TRAJECTORIES_PER_ITER = 100 # Total number of trajectories per iteration +ELITE_PERCENT = 10 # Top k% trajectories to select +LEARNING_RATE = 1e-3 +BATCH_SIZE = 64 +MAX_STEPS = 500 # Max steps per trajectory +ENV_NAME = 'CartPole-v1' # Gym environment + +# Define the Policy Network +class PolicyNetwork(nn.Module): + def __init__(self, state_dim, action_dim, hidden_dim=128): + super(PolicyNetwork, self).__init__() + self.fc = nn.Sequential( + nn.Linear(state_dim, hidden_dim), + nn.ReLU(), + nn.Linear(hidden_dim, hidden_dim), + nn.ReLU(), + nn.Linear(hidden_dim, action_dim) + ) + + def forward(self, state): + logits = self.fc(state) + return logits + + def get_action(self, state): + logits = self.forward(state) + action_probs = torch.softmax(logits, dim=-1) + action = torch.multinomial(action_probs, num_samples=1) + return action.squeeze(-1) + +# Function to create multiple environments +def make_env(env_name, seed): + def _init(): + env = gym.make(env_name) + return env + return _init + +def collect_trajectories(envs, policy, num_trajectories, max_steps): + trajectories = [] + num_envs = envs.num_envs + + # Handle the return type of reset() + reset_output = envs.reset() + if isinstance(reset_output, tuple) or isinstance(reset_output, list): + obs = reset_output[0] # Extract observations + else: + obs = reset_output + + done_envs = [False] * num_envs + steps = 0 + + # Initialize storage for states, actions, and rewards per environment + env_states = [[] for _ in range(num_envs)] + env_actions = [[] for _ in range(num_envs)] + env_rewards = [0.0 for _ in range(num_envs)] + total_collected = 0 + + while total_collected < num_trajectories and steps < max_steps: + # Convert observations to tensor efficiently + try: + # Ensure 'obs' is a NumPy array + if not isinstance(obs, np.ndarray): + print(f"Unexpected type for observations: {type(obs)}") + raise ValueError("Observations are not a NumPy array.") + + # Convert observations to tensor using from_numpy for efficiency + obs_tensor = torch.from_numpy(obs).float() + # Ensure the observation dimension matches expected + assert obs_tensor.shape[1] == 4, f"Expected observation dimension 4, got {obs_tensor.shape[1]}" + except Exception as e: + print(f"Error converting observations to tensor at step {steps}: {e}") + print(f"Observations: {obs}") + raise e + + with torch.no_grad(): + actions = policy.get_action(obs_tensor).cpu().numpy() + + # Unpack step based on Gym version + try: + # For Gym versions >=0.26, step returns five values + next_obs, rewards, dones, truncs, infos = envs.step(actions) + except ValueError: + # For older Gym versions, step returns four values + next_obs, rewards, dones, infos = envs.step(actions) + truncs = [False] * len(dones) # Assume no truncations if not provided + + # Handle the reset output of step() + if isinstance(next_obs, tuple) or isinstance(next_obs, list): + next_obs = next_obs[0] # Extract observations + + # Ensure infos is a list + if not isinstance(infos, list): + infos = [{} for _ in range(num_envs)] # Default to empty dicts + + for i in range(num_envs): + if not done_envs[i]: + # Check if obs[i] has the correct shape + if len(obs[i]) != 4: + print(f"Unexpected observation shape for env {i}: {obs[i]}") + continue # Skip this step for the problematic environment + + env_states[i].append(obs[i]) + env_actions[i].append(actions[i]) + env_rewards[i] += rewards[i] + if dones[i] or truncs[i]: + # Extract reward from infos + if isinstance(infos[i], dict): + episode_info = infos[i].get('episode', {}) + traj_reward = episode_info.get('r') if 'r' in episode_info else env_rewards[i] + else: + # Handle cases where infos[i] is not a dict + traj_reward = env_rewards[i] + print(f"Warning: infos[{i}] is not a dict. Received type: {type(infos[i])}") + + trajectories.append({ + 'states': env_states[i], + 'actions': env_actions[i], + 'reward': traj_reward + }) + total_collected += 1 + env_states[i] = [] + env_actions[i] = [] + env_rewards[i] = 0.0 + done_envs[i] = True + + obs = next_obs + steps += 1 + + # Reset environments that are done + if any(done_envs): + indices = [i for i, done in enumerate(done_envs) if done] + if total_collected < num_trajectories: + for i in indices: + try: + # Directly reset the environment + reset_output = envs.envs[i].reset() + if isinstance(reset_output, tuple) or isinstance(reset_output, list): + # For Gym versions where reset returns (obs, info) + obs[i] = reset_output[0] + else: + # For Gym versions where reset returns only obs + obs[i] = reset_output + done_envs[i] = False + except Exception as e: + print(f"Error resetting environment {i}: {e}") + # Optionally, handle the failure (e.g., retry, terminate the environment) + done_envs[i] = False # Prevent infinite loop + + return trajectories + + +def select_elite(trajectories, percentile=ELITE_PERCENT): + rewards = [traj['reward'] for traj in trajectories] + if not rewards: + return [] + reward_threshold = np.percentile(rewards, 100 - percentile) + elite_trajectories = [traj for traj in trajectories if traj['reward'] >= reward_threshold] + return elite_trajectories + +# Function to create training dataset from elite trajectories +def create_training_data(elite_trajectories): + states = [] + actions = [] + for traj in elite_trajectories: + states.extend(traj['states']) + actions.extend(traj['actions']) + if not states or not actions: + return None, None + # Convert lists to NumPy arrays first for efficiency + states = np.array(states, dtype=np.float32) + actions = np.array(actions, dtype=np.int64) + # Convert to PyTorch tensors + states = torch.from_numpy(states) + actions = torch.from_numpy(actions) + return states, actions + +# Main execution code +if __name__ == '__main__': + # Initialize environments + env_fns = [make_env(ENV_NAME, SEED + i) for i in range(NUM_ENVIRONMENTS)] + envs = AsyncVectorEnv(env_fns) + + # Get environment details + dummy_env = gym.make(ENV_NAME) + state_dim = dummy_env.observation_space.shape[0] + action_dim = dummy_env.action_space.n + dummy_env.close() + + # Initialize policy network and optimizer + policy = PolicyNetwork(state_dim, action_dim) + optimizer = optim.Adam(policy.parameters(), lr=LEARNING_RATE) + criterion = nn.CrossEntropyLoss() + + # Training Loop + for iteration in range(1, NUM_ITERATIONS + 1): + try: + # Step 1: Collect Trajectories + trajectories = collect_trajectories(envs, policy, TRAJECTORIES_PER_ITER, MAX_STEPS) + except Exception as e: + print(f"Error during trajectory collection at iteration {iteration}: {e}") + break + + # Step 2: Select Elite Trajectories + elite_trajectories = select_elite(trajectories, ELITE_PERCENT) + + if len(elite_trajectories) == 0: + print(f"Iteration {iteration}: No elite trajectories found. Skipping update.") + continue + + # Step 3: Create Training Data + states, actions = create_training_data(elite_trajectories) + + if states is None or actions is None: + print(f"Iteration {iteration}: No training data available. Skipping update.") + continue + + # Step 4: Behavioral Cloning (Policy Update) + dataset_size = states.size(0) + indices = np.arange(dataset_size) + np.random.shuffle(indices) + + for start in range(0, dataset_size, BATCH_SIZE): + end = start + BATCH_SIZE + batch_indices = indices[start:end] + batch_states = states[batch_indices] + batch_actions = actions[batch_indices] + + optimizer.zero_grad() + logits = policy(batch_states) + loss = criterion(logits, batch_actions) + loss.backward() + optimizer.step() + + # Step 5: Evaluate Current Policy + avg_reward = np.mean([traj['reward'] for traj in elite_trajectories]) + print(f"Iteration {iteration}: Elite Trajectories: {len(elite_trajectories)}, Average Reward: {avg_reward:.2f}") + + # Close environments + envs.close() + + # Testing the Trained Policy + def test_policy(policy, env_name=ENV_NAME, episodes=5, max_steps=500): + env = gym.make(env_name) + total_rewards = [] + for episode in range(episodes): + obs, _ = env.reset() + done = False + episode_reward = 0 + for _ in range(max_steps): + obs_tensor = torch.from_numpy(obs).float().unsqueeze(0) + with torch.no_grad(): + action = policy.get_action(obs_tensor).item() + obs, reward, done, info, _ = env.step(action) + episode_reward += reward + if done: + break + total_rewards.append(episode_reward) + print(f"Test Episode {episode + 1}: Reward: {episode_reward}") + env.close() + print(f"Average Test Reward over {episodes} episodes: {np.mean(total_rewards):.2f}") + + # Run the test + test_policy(policy) \ No newline at end of file diff --git a/docs/ramblings/0.1.0/cpbo.py b/docs/ramblings/0.1.0/cpbo.py new file mode 100644 index 000000000..d36ff1ad0 --- /dev/null +++ b/docs/ramblings/0.1.0/cpbo.py @@ -0,0 +1,219 @@ +import gym +import torch +import torch.nn as nn +import torch.optim as optim +import numpy as np +from collections import namedtuple +from torch.utils.data import DataLoader, TensorDataset + +# Define a simple policy network +class PolicyNetwork(nn.Module): + def __init__(self, state_dim, action_dim, hidden_dim=128): + super(PolicyNetwork, self).__init__() + self.network = nn.Sequential( + nn.Linear(state_dim, hidden_dim), + nn.ReLU(), + nn.Linear(hidden_dim, hidden_dim), + nn.ReLU(), + nn.Linear(hidden_dim, action_dim), + nn.Softmax(dim=-1) # Output action probabilities + ) + + def forward(self, x): + return self.network(x) + +# Function to collect trajectories +def collect_trajectories(env, policy, num_episodes, device): + trajectories = [] + Episode = namedtuple('Episode', ['states', 'actions', 'rewards']) + + for episode_num in range(num_episodes): + states = [] + actions = [] + rewards = [] + # Handle Gym's updated reset() API + state, info = env.reset(seed=42 + episode_num) # Optional: set seed for reproducibility + done = False + + while not done: + state_tensor = torch.FloatTensor(state).unsqueeze(0).to(device) + with torch.no_grad(): + action_probs = policy(state_tensor) + action_dist = torch.distributions.Categorical(action_probs) + action = action_dist.sample().item() + + # Handle Gym's updated step() API + next_state, reward, terminated, truncated, info = env.step(action) + done = terminated or truncated + + states.append(state) + actions.append(action) + rewards.append(reward) + + state = next_state + + trajectories.append(Episode(states, actions, rewards)) + + return trajectories + +# Function to compute returns +def compute_returns(trajectories, gamma=0.99): + all_returns = [] + for episode in trajectories: + returns = [] + G = 0 + for reward in reversed(episode.rewards): + G = reward + gamma * G + returns.insert(0, G) + all_returns.extend(returns) + return all_returns + +# Function to create labeled dataset +def create_labeled_dataset(trajectories, gamma=0.99, device='cpu'): + states = [] + actions = [] + labels = [] + + all_returns = compute_returns(trajectories, gamma) + all_returns = np.array(all_returns) + median_return = np.median(all_returns) + + for episode in trajectories: + for t in range(len(episode.rewards)): + # Compute return from timestep t + G = sum([gamma**k * episode.rewards[t + k] for k in range(len(episode.rewards) - t)]) + label = 1 if G >= median_return else 0 + states.append(episode.states[t]) + actions.append(episode.actions[t]) + labels.append(label) + + # Convert lists to NumPy arrays first for efficiency + states = np.array(states) + actions = np.array(actions) + labels = np.array(labels) + + # Convert to PyTorch tensors + states = torch.FloatTensor(states).to(device) + actions = torch.LongTensor(actions).to(device) + labels = torch.FloatTensor(labels).to(device) + + return states, actions, labels + +# Function to perform behavioral cloning update +def behavioral_cloning_update(policy, optimizer, dataloader, device): + criterion = nn.BCELoss() + policy.train() + + for states, actions, labels in dataloader: + optimizer.zero_grad() + action_probs = policy(states) + # Gather the probability of the taken action + selected_probs = action_probs.gather(1, actions.unsqueeze(1)).squeeze(1) + # Labels are 1 for good actions, 0 for bad actions + loss = criterion(selected_probs, labels) + loss.backward() + optimizer.step() + +# Evaluation function +def evaluate_policy(env, policy, device, episodes=5): + policy.eval() + total_rewards = [] + for _ in range(episodes): + state, info = env.reset() + done = False + ep_reward = 0 + while not done: + state_tensor = torch.FloatTensor(state).unsqueeze(0).to(device) + with torch.no_grad(): + action_probs = policy(state_tensor) + action = torch.argmax(action_probs, dim=1).item() + # Handle Gym's updated step() API + next_state, reward, terminated, truncated, info = env.step(action) + done = terminated or truncated + ep_reward += reward + state = next_state + total_rewards.append(ep_reward) + average_reward = np.mean(total_rewards) + return average_reward + +# Main CBPO algorithm +def CBPO(env_name='CartPole-v1', num_epochs=10, num_episodes_per_epoch=100, gamma=0.99, + batch_size=64, learning_rate=1e-3, device='cpu'): + + env = gym.make(env_name) + state_dim = env.observation_space.shape[0] + action_dim = env.action_space.n + + policy = PolicyNetwork(state_dim, action_dim).to(device) + optimizer = optim.Adam(policy.parameters(), lr=learning_rate) + + for epoch in range(num_epochs): + print(f"Epoch {epoch+1}/{num_epochs}") + + # 1. Collect trajectories + trajectories = collect_trajectories(env, policy, num_episodes_per_epoch, device) + + # 2. Create labeled dataset + states, actions, labels = create_labeled_dataset(trajectories, gamma, device) + + # 3. Create DataLoader + dataset = TensorDataset(states, actions, labels) + dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True) + + # 4. Behavioral Cloning Update + behavioral_cloning_update(policy, optimizer, dataloader, device) + + # 5. Evaluate current policy + avg_reward = evaluate_policy(env, policy, device) + print(f"Average Reward: {avg_reward}") + + # Early stopping if solved + if avg_reward >= env.spec.reward_threshold: + print(f"Environment solved in {epoch+1} epochs!") + break + + env.close() + return policy + +if __name__ == "__main__": + # Check if GPU is available + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + print(f"Using device: {device}") + + # Run CBPO + trained_policy = CBPO( + env_name='CartPole-v1', + num_epochs=50, + num_episodes_per_epoch=500, + gamma=0.99, + batch_size=64, + learning_rate=1e-3, + device=device + ) + + # Final Evaluation + env = gym.make('CartPole-v1') + final_avg_reward = evaluate_policy(env, trained_policy, device, episodes=20) + print(f"Final Average Reward over 20 episodes: {final_avg_reward}") + env.close() + + # Save the trained policy + torch.save(trained_policy.state_dict(), "trained_cartpole_policy.pth") + print("Trained policy saved to trained_cartpole_policy.pth") + + # Demo the trained policy with rendering + env = gym.make('CartPole-v1', render_mode='human') + state, _ = env.reset() + done = False + total_reward = 0 + + while not done: + state_tensor = torch.FloatTensor(state).unsqueeze(0).to(device) + action = trained_policy(state_tensor).argmax().item() + state, reward, terminated, truncated, _ = env.step(action) + total_reward += reward + done = terminated or truncated + env.render() + + print(f"Demo episode finished with total reward: {total_reward}") + env.close() \ No newline at end of file diff --git a/docs/ramblings/dspy.md b/docs/ramblings/dspy.md index e69de29bb..776068946 100644 --- a/docs/ramblings/dspy.md +++ b/docs/ramblings/dspy.md @@ -0,0 +1,3 @@ +# How do we make a simpler dspy? + + diff --git a/tests/test_closure.py b/tests/test_closure.py index 5b940d9ef..4a040d060 100644 --- a/tests/test_closure.py +++ b/tests/test_closure.py @@ -7,7 +7,6 @@ lexical_closure, should_import, get_referenced_names, - is_function_called, ) import ell from ell.util.serialization import is_immutable_variable @@ -80,19 +79,19 @@ def test_get_referenced_names(): assert "sin" in referenced assert "cos" in referenced -def test_is_function_called(): - code = """ -def foo(): - pass +# def test_is_function_called(): +# code = """ +# def foo(): +# pass -def bar(): - foo() +# def bar(): +# foo() -x = 1 + 2 - """ - assert is_function_called("foo", code) - assert not is_function_called("bar", code) - assert not is_function_called("nonexistent", code) +# x = 1 + 2 +# """ +# assert is_function_called("foo", code) +# assert not is_function_called("bar", code) +# assert not is_function_called("nonexistent", code) # Addressing linter errors def test_lexical_closure_signature(): @@ -134,5 +133,194 @@ def main_func(): assert len(dependency_func.__ell_uses__) == 0 +def test_lexical_closure_with_multiple_nested_functions(): + def outer(): + a = 1 + def middle(): + b = 2 + def inner(): + return a + b + return inner() + return middle() + + closure, (_, _), uses = lexical_closure(outer) + assert "def outer():" in closure + assert "def middle():" in closure + assert "def inner():" in closure + assert "a = 1" in closure + assert "b = 2" in closure + assert "return a + b" in closure + assert isinstance(uses, Set) + +def test_lexical_closure_with_class_methods(): + class MyClass: + class_var = 10 + + def method(self, x): + return self.class_var + x + + @classmethod + def class_method(cls, y): + return cls.class_var + y + + @staticmethod + def static_method(z): + return z * 2 + + closure_method, (_, _), uses_method = lexical_closure(MyClass.method) + # assert "class MyClass" in closure_method # We don't want ot serialize the class. + assert "def method(self, x):" in closure_method + assert "self.class_var + x" in closure_method + + closure_class_method, (_, _), uses_class_method = lexical_closure(MyClass.class_method) + assert "def class_method(cls, y):" in closure_class_method + assert "cls.class_var + y" in closure_class_method + + closure_static_method, (_, _), uses_static_method = lexical_closure(MyClass.static_method) + assert "def static_method(z):" in closure_static_method + assert "z * 2" in closure_static_method + +# def test_lexical_closure_with_recursive_function(): +# def factorial(n): +# if n == 0: +# return 1 +# else: +# return n * factorial(n - 1) + +# closure, (_, _), uses = lexical_closure(factorial) +# assert "def factorial(n):" in closure +# assert "return n * factorial(n - 1)" in closure +# assert isinstance(uses, Set) + +# def test_lexical_closure_with_mutable_free_variable(): +# data = {"count": 0} + +# def increment(): +# data["count"] += 1 +# return data["count"] + +# closure, (_, _), uses = lexical_closure(increment) +# # assert "'count': 0" in closure +# assert "" in closure +# assert "def increment():" in closure +# assert "data[\"count\"] += 1" in closure +# assert isinstance(uses, Set) + + +def test_lexical_closure_with_error_in_function(): + def faulty_func(): + return undefined_variable + 1 # This will raise NameError + + # with pytest.raises(Exception) as exc_info: + lexical_closure(faulty_func) + + # assert "Failed to capture the lexical closure" in str(exc_info.value) + # assert "NameError" in str(exc_info.value) + +def test_lexical_closure_with_multiple_decorators(): + def decorator_one(func): + def wrapper(*args, **kwargs): + return func(*args, **kwargs) + return wrapper + + def decorator_two(func): + def wrapper(*args, **kwargs): + return func(*args, **kwargs) + return wrapper + + @decorator_one + @decorator_two + def decorated_func(x): + return x * 2 + + closure, (_, _), uses = lexical_closure(decorated_func) + assert "def decorated_func(x):" in closure + assert "return x * 2" in closure + assert isinstance(uses, Set) + +def test_lexical_closure_with_class_and_imported_function(): + from math import sqrt + + class Helper: + def help(self, y): + return sqrt(y) + + # Todo: Currently we don't supprot type closuring. This needs to be fixed. + helper = Helper() + + def compute(x): + return helper.help(x) + sqrt(x) + + closure, (_, _), uses = lexical_closure(compute) + assert "from math import sqrt" in closure + # assert "class Helper:" in closure + # assert "def help(self, y):" in closure + # assert "return sqrt(y)" in closure + assert "def compute(x):" in closure + assert "helper.help(x) + sqrt(x)" in closure + assert isinstance(uses, Set) + +# def test_lexical_closure_with_circular_dependencies(): +# # Simulate circular dependencies by defining two functions that reference each other +# def func_a(): +# return func_b() + 1 + +# def func_b(): +# return func_a() + 1 + +# closure_a, (_, _), uses_a = lexical_closure(func_a) +# closure_b, (_, _), uses_b = lexical_closure(func_b) + +# assert "def func_a():" in closure_a +# assert "return func_b() + 1" in closure_a +# assert "def func_b():" in closure_b +# assert "return func_a() + 1" in closure_b +# assert isinstance(uses_a, Set) +# assert isinstance(uses_b, Set) + +def test_lexical_closure_with_import_aliases(): + import math as m + + def compute_circle_area(radius): + return m.pi * radius ** 2 + + closure, (_, _), uses = lexical_closure(compute_circle_area) + assert "import math as m" in closure + assert "def compute_circle_area(radius):" in closure + assert "return m.pi * radius ** 2" in closure + assert isinstance(uses, Set) + +import asyncio + +def test_lexical_closure_with_async_function(): + async def async_func(x): + await asyncio.sleep(1) + return x * 2 + + closure, (_, _), uses = lexical_closure(async_func) + assert "async def async_func(x):" in closure + assert "await asyncio.sleep(1)" in closure + assert "return x * 2" in closure + assert isinstance(uses, Set) + +# def test_lexical_closure_with_reexported_modules(): +# # Simulate re-exported modules +# # module_a.py +# import math +# def func_a(): +# return math.sqrt(16) + +# # module_b.py +# from module_a import func_a + +# def func_b(): +# return func_a() + +# closure, (_, _), uses = lexical_closure(func_b) +# assert "from module_a import func_a" in closure +# assert "def func_b():" in closure +# assert "return func_a()" in closure +# assert isinstance(uses, Set) + if __name__ == "__main__": test_lexical_closure_uses() \ No newline at end of file From c841d11ee648e1562384c7d16927dc48a0505679 Mon Sep 17 00:00:00 2001 From: William Guss Date: Sun, 15 Sep 2024 19:03:23 -0700 Subject: [PATCH 03/11] broken --- examples/future/o1_graph.py | 497 ++++++++++++++++++--- examples/hello_world.py | 5 +- examples/iteration_0 | 83 ++++ examples/iteration_0.png | Bin 0 -> 376204 bytes src/ell/util/closure.py | 824 ++++++++++++++++------------------- src/ell/util/closure_util.py | 160 +++++++ tests/test_closure.py | 137 +++++- 7 files changed, 1194 insertions(+), 512 deletions(-) create mode 100644 examples/iteration_0 create mode 100644 examples/iteration_0.png create mode 100644 src/ell/util/closure_util.py diff --git a/examples/future/o1_graph.py b/examples/future/o1_graph.py index c804444f7..01f68092a 100644 --- a/examples/future/o1_graph.py +++ b/examples/future/o1_graph.py @@ -60,8 +60,7 @@ def draw(self, prefix: str = None): @ell.simple(model="o1-mini") def update_knowledge_graph(cur_state: KnowledgeGraph, inp: str, i: int, num_iterations: int): return [ - ell.user(f"""You are an iterative code base knowledge graph builder. You are trying to build the most useful represnetaiton about how thigns in the codebase interact with eachother. - It is important that your graph is semantically meaningful The edges should not just be has method etc. A knowledge graph woild best convey that to someone learning the system for the first time & doesn't know programming. + ell.user(f"""You are a going to build a graph of how the following process works in as extreme detail as possible. Don't build a call graph. Build a graph of the actual process of lexical closure. You are given the current state of the graph, and you must append the nodes and edges to it Do not procide any duplcates and try to reuse nodes as much as possible. Extract any new nodes and edges from the following: Here is the current state of the graph: @@ -96,56 +95,448 @@ def generate_graph(input: List[str]) -> KnowledgeGraph: if __name__ == "__main__": ell.init(verbose=True, store='./logdir', autocommit=True) - generate_graph([ - """ - class User: - def __init__(self, name, email): - self.name = name - self.email = email - - def send_email(self, message): - # Send email logic here - pass - - class Order: - def __init__(self, user, items): - self.user = user - self.items = items - - def process(self): - # Order processing logic - self.user.send_email("Your order has been processed.") - """, - """ - class Product: - def __init__(self, name, price): - self.name = name - self.price = price - - class ShoppingCart: - def __init__(self): - self.items = [] - - def add_item(self, product, quantity): - self.items.append((product, quantity)) - - def calculate_total(self): - return sum(product.price * quantity for product, quantity in self.items) - """, - """ - class PaymentProcessor: - @staticmethod - def process_payment(order, amount): - # Payment processing logic - pass - - class OrderManager: - @staticmethod - def create_order(user, cart): - order = Order(user, cart.items) - total = cart.calculate_total() - PaymentProcessor.process_payment(order, total) - order.process() - """ + generate_graph([''' + # src/ell/util/closure.py + +import collections +import hashlib +import inspect +import re +import types +from collections import deque +from dataclasses import dataclass, field +from typing import Any, Callable, Dict, Optional, Set, Tuple, List + +import itertools +import dill +from dill.source import getsource + +from ell.util.closure_util import ( + format_source, + get_referenced_names, + globalvars, + should_import, +) +from ell.util.serialization import is_immutable_variable + +# Constants +FORBIDDEN_NAMES = {"ell", "lstr"} + + +@dataclass +class Dependency: + """Represents a dependency with its source code.""" + source: str + + +@dataclass +class ModuleDependency: + """Represents a module and its associated dependencies.""" + name: str + value: Any + dependencies: List[Dependency] = field(default_factory=list) + + +@dataclass +class Closure: + """Aggregates all closure-related information for a function.""" + source: str + dependencies: List[Dependency] = field(default_factory=list) + imports: Set[str] = field(default_factory=set) + modules: deque = field(default_factory=deque) + uses: Set[Any] = field(default_factory=set) + + +def lexical_closure( + func: Any, + already_closed: Optional[Set[int]] = None, + initial_call: bool = False, + recursion_stack: Optional[List[str]] = None, + forced_dependencies: Optional[Dict[str, Any]] = None, +) -> Tuple[str, Tuple[str, str], Set[Any]]: + """ + Generate a lexical closure for a given function or callable. + + Args: + func: The function or callable to process. + already_closed: Set of already processed function hashes. + initial_call: Indicates if this is the initial call. + recursion_stack: Tracks the recursion path. + forced_dependencies: Additional dependencies to include. + + Returns: + A tuple containing: + - Full source code of the closure. + - A tuple of (formatted source, cleaned source). + - A set of function objects used in the closure. + """ + already_closed = already_closed or set() + recursion_stack = recursion_stack or [] + forced_dependencies = forced_dependencies or {} + + original_func, wrapper_func = _unwrap_function(func) + + func_hash = hash(original_func) + if func_hash in already_closed: + return "", ("", ""), set() + + try: + source = getsource(original_func, lstrip=True) + except (IOError, TypeError) as e: + _raise_error( + f"Unable to retrieve source for function '{original_func.__qualname__}'", + e, + recursion_stack, + ) + + closure = Closure(source=source) + already_closed.add(func_hash) + recursion_stack.append(original_func.__qualname__) + + globals_and_frees = _get_globals_and_frees(original_func) + _process_dependencies(original_func, globals_and_frees, closure, already_closed, recursion_stack) + + for name, dependency in forced_dependencies.items(): + _process_dependency(dependency, closure, already_closed, recursion_stack, name=name) + + final_source = _assemble_final_source(closure) + + cleaned_source = _clean_source(final_source) + + formatted_source = format_source(closure.source) + formatted_cleaned = format_source(cleaned_source) + + function_hash = _generate_function_hash(formatted_source, formatted_cleaned, original_func.__qualname__) + + # Set closure attributes on wrapper_func if exists, else on original_func + target_func = wrapper_func if wrapper_func else original_func + if isinstance(target_func, types.MethodType): + target_func = target_func.__func__ + + target_func.__ell_closure__ = ( + formatted_source, + formatted_cleaned, + globals_and_frees["globals"], + globals_and_frees["frees"], + ) + target_func.__ell_hash__ = function_hash + # Only add to __ell_uses__ if it's an ell-decorated function + if hasattr(original_func, "__ell_func__"): + closure.uses.add(original_func) + target_func.__ell_uses__ = {fn for fn in closure.uses if hasattr(fn, "__ell_func__")} + + uses_set = {original_func} if not initial_call else closure.uses + return final_source, (formatted_source, cleaned_source), uses_set + + +def lexically_closured_source( + func: Callable, forced_dependencies: Optional[Dict[str, Any]] = None +) -> Tuple[str, Tuple[str, str], Set[Any]]: + """ + Generate a lexically closured source for a given function. + + This function creates a self-contained version of the provided callable, + capturing all dependencies, including global and free variables. + + Args: + func (Callable): The function or callable to process. + forced_dependencies (Optional[Dict[str, Any]]): Additional dependencies + to include in the closure. + + Returns: + Tuple containing: + 1. The full closure source code as a string. + 2. A tuple with (formatted source, cleaned source). + 3. A set of function objects used in the closure. + + Raises: + ValueError: If the input is not callable. + """ + if not callable(func): + raise ValueError("Input must be a callable object (function, method, or class).") + + closure_source, (formatted_source, cleaned_source), uses = lexical_closure( + func, initial_call=True, recursion_stack=[], forced_dependencies=forced_dependencies + ) + return closure_source, (formatted_source, cleaned_source), uses + + +def _unwrap_function(func: Any) -> Tuple[Callable, Optional[Callable]]: + """ + Recursively unwrap decorated functions to retrieve the original function. + + Returns: + A tuple containing: + - The original function. + - The outermost wrapper function (if any), else None. + """ + wrappers = [] + while hasattr(func, "__ell_func__"): + wrappers.append(func) + func = func.__ell_func__ + return func, wrappers[-1] if wrappers else None + + +def _get_globals_and_frees(func: Callable) -> Dict[str, Dict[str, Any]]: + """Retrieve global and free variables of a function.""" + globals_dict = collections.OrderedDict(globalvars(func)) + frees_dict = collections.OrderedDict(dill.detect.freevars(func)) + + if isinstance(func, type): + for method in func.__dict__.values(): + if isinstance(method, (types.FunctionType, types.MethodType)): + globals_dict.update(collections.OrderedDict(globalvars(method))) + frees_dict.update(collections.OrderedDict(dill.detect.freevars(method))) + + return {"globals": globals_dict, "frees": frees_dict} + + +def _process_dependencies( + func: Callable, + globals_and_frees: Dict[str, Dict[str, Any]], + closure: Closure, + already_closed: Set[int], + recursion_stack: List[str], +): + """Process dependencies of a function.""" + if isinstance(func, (types.FunctionType, types.MethodType)): + _process_default_kwargs(func, closure, already_closed, recursion_stack) + + for var_name, var_value in itertools.chain( + globals_and_frees["globals"].items(), globals_and_frees["frees"].items() + ): + _process_variable(var_name, var_value, closure, already_closed, recursion_stack) + + +def _process_default_kwargs( + func: Callable, + closure: Closure, + already_closed: Set[int], + recursion_stack: List[str], +): + """Process default keyword arguments of a function.""" + for name, param in inspect.signature(func).parameters.items(): + if param.default is not inspect.Parameter.empty: + _process_dependency(param.default, closure, already_closed, recursion_stack, name=name) + + +def _process_dependency( + value: Any, + closure: Closure, + already_closed: Set[int], + recursion_stack: List[str], + name: Optional[str] = None, +): + """Process dependencies from function signatures and variables.""" + if name in FORBIDDEN_NAMES: + return + + try: + if isinstance(value, (types.FunctionType, type, types.MethodType)): + dep_source, _, dep_uses = lexical_closure( + value, already_closed, recursion_stack.copy() + ) + if dep_source: + closure.dependencies.append(Dependency(source=dep_source)) + closure.uses.add(value) + closure.uses.update(dep_uses) + elif isinstance(value, (list, tuple, set)): + for item in value: + _process_dependency(item, closure, already_closed, recursion_stack, name=name) + else: + is_builtin = getattr(value.__class__, "__module__", "") in {"builtins", "__builtins__"} + if not is_builtin: + module_name = value.__class__.__module__ + if should_import(module_name): + import_statement = dill.source.getimport(value.__class__, alias=value.__class__.__name__) + closure.imports.add(import_statement) + else: + dep_source, _, dep_uses = lexical_closure( + type(value), already_closed, recursion_stack.copy() + ) + if dep_source: + closure.dependencies.append(Dependency(source=dep_source)) + closure.uses.update(dep_uses) + except Exception as e: + _raise_error( + f"Failed to capture the lexical closure of dependency {name}", + e, + recursion_stack, + ) + + +def _process_variable( + var_name: str, + var_value: Any, + closure: Closure, + already_closed: Set[int], + recursion_stack: List[str], +): + """Process a single variable.""" + try: + module = inspect.getmodule(var_value) + module_name = module.__name__ if module else None + if module_name and should_import(module_name): + import_statement = dill.source.getimport(var_value, alias=var_name) + closure.imports.add(import_statement) + return + except Exception: + pass + + if isinstance(var_value, (types.FunctionType, type, types.MethodType, types.ModuleType, types.BuiltinFunctionType)): + _handle_special_variable(var_name, var_value, closure, already_closed, recursion_stack) + else: + _handle_other_variable(var_name, var_value, closure) + + +def _handle_special_variable( + var_name: str, + var_value: Any, + closure: Closure, + already_closed: Set[int], + recursion_stack: List[str], +): + """Handle special types of variables like callables and modules.""" + if isinstance(var_value, (types.FunctionType, type, types.MethodType)): + _process_callable(var_name, var_value, closure, already_closed, recursion_stack) + elif isinstance(var_value, types.ModuleType): + _process_module(var_name, var_value, closure) + elif isinstance(var_value, types.BuiltinFunctionType): + import_statement = dill.source.getimport(var_value, alias=var_name) + closure.imports.add(import_statement) + + +def _process_callable( + var_name: str, + var_value: Callable, + closure: Closure, + already_closed: Set[int], + recursion_stack: List[str], +): + """Process a callable object.""" + try: + module_name = inspect.getmodule(var_value).__name__ + is_ell_module = "ell" in module_name + except Exception: + is_ell_module = False + + if var_name not in FORBIDDEN_NAMES and not is_ell_module: + try: + dep_source, _, dep_uses = lexical_closure( + var_value, already_closed, recursion_stack.copy() + ) + if dep_source: + closure.dependencies.append(Dependency(source=dep_source)) + closure.uses.add(var_value) + closure.uses.update(dep_uses) + except Exception as e: + _raise_error( + f"Failed to capture the lexical closure of global or free variable {var_name}", + e, + recursion_stack, + ) + + +def _process_module(var_name: str, var_value: types.ModuleType, closure: Closure): + """Process a module.""" + if should_import(var_value.__name__): + import_statement = dill.source.getimport(var_value, alias=var_name) + closure.imports.add(import_statement) + else: + closure.modules.append(ModuleDependency(name=var_name, value=var_value)) + + +def _handle_other_variable(var_name: str, var_value: Any, closure: Closure): + """Process non-callable and non-module variables.""" + if isinstance(var_value, str) and "\n" in var_value: + closure.dependencies.append(Dependency(source=f"{var_name} = {var_value}")) + elif is_immutable_variable(var_value): + closure.dependencies.append(Dependency(source=f"#\n{var_name} = {repr(var_value)}\n#")) + else: + closure.dependencies.append(Dependency(source=f"#\n{var_name} = <{type(var_value).__name__} object>\n#")) + + +def _assemble_final_source(closure: Closure) -> str: + """Assemble the final source code.""" + parts = [] + if closure.imports: + parts.append("\n".join(sorted(closure.imports))) + if closure.dependencies: + parts.append("\n".join(dep.source for dep in closure.dependencies)) + if closure.modules: + module_sources = [] + for module_dep in closure.modules: + module_sources.append(f"# Module: {module_dep.name}") + module_dependencies = "\n".join(dep.source for dep in module_dep.dependencies) + if module_dependencies: + module_sources.append(module_dependencies) + parts.append("\n\n".join(module_sources)) + if closure.source: + parts.append(closure.source) + + combined = "\n\n".join(parts) + + # Remove duplicate lines while preserving order + unique_lines = [] + seen = set() + for line in combined.split("\n"): + if line not in seen: + unique_lines.append(line) + seen.add(line) + final_source = "\n".join(unique_lines) + + # Replace multiple newlines with two + final_source = re.sub(r"\n{3,}", "\n\n", final_source) + + return final_source + + +def _generate_function_hash(source: str, cleaned_source: str, qualname: str) -> str: + """Generate a unique hash for the function.""" + hash_input = "\n".join((source, cleaned_source, qualname)).encode() + return "lmp-" + hashlib.md5(hash_input).hexdigest() + + +def _update_ell_func( + outer_func: Any, + source: str, + cleaned_source: str, + globals_dict: Dict[str, Any], + frees_dict: Dict[str, Any], + function_hash: str, + uses: Set[Any], +): + """Update the attributes of the outer function with closure information.""" + formatted_source = format_source(source) + formatted_cleaned = format_source(cleaned_source) + + # If it's a bound method, set attributes on the underlying function + if isinstance(outer_func, types.MethodType): + outer_func = outer_func.__func__ + + outer_func.__ell_closure__ = ( + formatted_source, + formatted_cleaned, + globals_dict, + frees_dict, + ) + outer_func.__ell_hash__ = function_hash + # Only add ell-decorated functions to __ell_uses__ + ell_uses = {fn for fn in closure.uses if hasattr(fn, "__ell_func__")} + outer_func.__ell_uses__ = ell_uses + + +def _raise_error(message: str, exception: Exception, recursion_stack: List[str]): + """Raise an exception with a detailed message.""" + error_msg = f"{message}. Error: {str(exception)}\nRecursion stack: {' -> '.join(recursion_stack)}" + raise Exception(error_msg) + + +def _clean_source(final_source: str) -> str: + """Clean the source code by removing duplicates and organizing imports.""" + # Replace multiple newlines with two + cleaned = re.sub(r"\n{3,}", "\n\n", final_source) + return cleaned + ''' ]) diff --git a/examples/hello_world.py b/examples/hello_world.py index 346a5b342..9769bb366 100644 --- a/examples/hello_world.py +++ b/examples/hello_world.py @@ -10,7 +10,7 @@ def get_random_adjective(): def get_random_punctuation(): return random.choice(["!", "!!", "!!!"]) -@ell.simple(model="o1-preview") +@ell.simple(model="gpt-4o-mini") def hello(name: str): # """You are a helpful and expressive assistant.""" adjective = get_random_adjective() @@ -18,4 +18,5 @@ def hello(name: str): return f"Say a {adjective} hello to {name}{punctuation}" greeting = hello("Sam Altman") -print(greeting) \ No newline at end of file +print(greeting) + diff --git a/examples/iteration_0 b/examples/iteration_0 new file mode 100644 index 000000000..a95f34909 --- /dev/null +++ b/examples/iteration_0 @@ -0,0 +1,83 @@ +// Knowledge Graph +digraph { + 1 [label="Start lexical_closure" color=blue] + 2 [label="Initialize already_closed, recursion_stack, forced_dependencies" color=green] + 3 [label="Call _unwrap_function(func)" color=blue] + 4 [label="Unwrap to original_func and wrapper_func" color=green] + 5 [label="Compute func_hash" color=orange] + 6 [label="Check if func_hash in already_closed" color=yellow] + 7 [label="func_hash found in already_closed" color=red] + 8 [label="Return empty closure" color=green] + 9 [label="Retrieve source using getsource(original_func)" color=blue] + 10 [label="Handle IOError or TypeError" color=red] + 11 [label="Create Closure object" color=green] + 12 [label="Add func_hash to already_closed" color=green] + 13 [label="Append original_func.__qualname__ to recursion_stack" color=green] + 14 [label="Call _get_globals_and_frees(original_func)" color=blue] + 15 [label="Retrieve globals and free variables" color=green] + 16 [label="Call _process_dependencies" color=blue] + 17 [label="Process default kwargs if Function or Method" color=green] + 18 [label="Iterate over globals and frees" color=green] + 19 [label="Call _process_variable for each variable" color=blue] + 20 [label="Retrieve module of variable" color=green] + 21 [label="Check if module should be imported" color=yellow] + 22 [label="If yes, add import statement to closure.imports" color=green] + 23 [label="If no, handle variable based on type" color=blue] + 24 [label="Call _handle_special_variable or _handle_other_variable" color=blue] + 25 [label="Process callable objects" color=green] + 26 [label="Call lexical_closure recursively for callable" color=blue] + 27 [label="Add Dependency to closure.dependencies" color=green] + 28 [label="Update closure.uses" color=green] + 29 [label="Process forced_dependencies" color=green] + 30 [label="Call _assemble_final_source" color=blue] + 31 [label="Combine imports, dependencies, modules, source" color=green] + 32 [label="Remove duplicate lines" color=green] + 33 [label="Replace multiple newlines" color=green] + 34 [label="Call _clean_source" color=blue] + 35 [label="Return cleaned source" color=green] + 36 [label="Call format_source for source and cleaned_source" color=blue] + 37 [label="Generate function_hash with _generate_function_hash" color=blue] + 38 [label="Set closure attributes on target_func" color=green] + 39 [label="Update __ell_uses__ if decorated" color=green] + 40 [label="Return final_source, formatted sources, uses_set" color=green] + 1 -> 2 [label=initializes color=black] + 2 -> 3 [label=calls color=black] + 3 -> 4 [label=unwraps color=black] + 4 -> 5 [label=hashes color=black] + 5 -> 6 [label=checks color=black] + 6 -> 7 [label="if in" color=black] + 7 -> 8 [label=then color=black] + 6 -> 9 [label=else color=black] + 9 -> 10 [label="handles exception" color=red] + 9 -> 11 [label=success color=black] + 11 -> 12 [label="adds to" color=black] + 12 -> 13 [label="appends to" color=black] + 13 -> 14 [label=calls color=black] + 14 -> 15 [label=retrieves color=black] + 15 -> 16 [label=calls color=black] + 16 -> 17 [label=processes color=black] + 17 -> 18 [label=iterates color=black] + 18 -> 19 [label="processes each" color=black] + 19 -> 20 [label="retrieves module" color=black] + 20 -> 21 [label="checks import" color=black] + 21 -> 22 [label="if true" color=black] + 21 -> 23 [label="if false" color=black] + 23 -> 24 [label="handles type" color=black] + 24 -> 25 [label="if special" color=black] + 24 -> 35 [label="if other" color=black] + 25 -> 26 [label="process callable" color=black] + 26 -> 27 [label="adds dependency" color=black] + 27 -> 28 [label="updates uses" color=black] + 19 -> 29 [label="after variables" color=black] + 29 -> 30 [label=calls color=black] + 30 -> 31 [label=assembles color=black] + 31 -> 32 [label="removes duplicates" color=black] + 32 -> 33 [label="cleans newlines" color=black] + 33 -> 34 [label=calls color=black] + 34 -> 35 [label=returns color=black] + 35 -> 36 [label="formats source" color=black] + 36 -> 37 [label="generates hash" color=black] + 37 -> 38 [label="sets attributes" color=black] + 38 -> 39 [label="updates uses" color=black] + 39 -> 40 [label="returns final output" color=black] +} diff --git a/examples/iteration_0.png b/examples/iteration_0.png new file mode 100644 index 0000000000000000000000000000000000000000..2794ba22790e9765458aea9d8af657cb091d10e2 GIT binary patch literal 376204 zcmeFZbyQaE+cpS-AT1&SQYxh)pmZZ84L&F!B_iG3sR$w|C|w32Eg;>XbV)bT(%m)Z z2A<#dzVm(at@&ftnm=Z?3&orJ-usHPj^jKo-aVF=z{9?dje>%LCnYJSh=Ovl33^DI+0qaZpo!^J1dXoTu=YyyS>Em5u)7Zk+v2^Sr2J_iGm(_NcinWzXJb~z zeYCk5+ecKy&!^_*&5p9Y={{7{KeL#}$A1=Z@=d&ggSRTosD5R);bZ4!{bbI{NH1zG z+2^CFb*@~sb#hX^VNqIAwi-5l=ZqKhw<0M^9g(oPO(f=3JNR(@d?y#-fB_J z_vF1^UA0`WsP*aX_!hF&H&(g1M0++qMIuL1oq$sR%Y-2&3c{$gv{k>qUZy6f4^pk( zZu}5|wwz~>$(Ut!cy#mDh50^~>)nGQgEg zrzsd>d0fU3%V%K55Yy4oJnr!IQO74#c5_@NwP&Ku;l1xr&$c(jq}%j#&C{lIxh+wG zC~{t#4IvK>)~bje=p%_{&w1Tl7npe?-}1Zhf%>3Qmm<&ldd3HQEG*0YA6q*uQOznt z3A}oNd@kGT2J_u_u6qu}7nr2*4{-I&qyeG(RVQxo$t1o%cl<`o|dTRXzP9x3==ICfgMpS;Q&dWc^F&VRFLuw2> z=Y}#Y`>N2lVT+dTqW$s@p9J^Unx!vJj+;k<*iA2)4L*GOkwZ*ER5y{>`ff*sds0em zwO4P?@xhL|hnc8;GKXBbb4P`M?V=%G9IxuZ`>%qX;%E20`|g4TVMsI>NyW)1c7fSV z2iLN#=STYyqK%P}%{Lt+eO*k#O=N^$_2jp{Li=t(y*O&NWZ|;?Y-D72Pq@^+*S$A~ zX4u+)OJn5AnL|m^A$F(ugo5Y7m^)4km%7K!QeMet!~PEJ>tOmf@5p9DWl4~Bfyy*M`JhB@Y{qj}LB*LE4# zVMGtFaxZW{nB?q65y;-Awgpjn|MJ(KQ|zyxXeqJ|_C>2ZbiT086?gY+4 zVjEcWb?l>qS}%ecPgLc~Kj)sAgp5RSB$oFgwFj>MHC2_e-c+=m5ll2pH5D67%+gYk zkTk15C>feKjLOecJTWn9P7Vq9H{bVcy)$>eb9R$ow~r%;vPM(8uO4&4ik(I^wnU94?cX**;=8b#KXDvjH}}6 z=`w~ad_XMk?#Hl;ES0#K>a|T__id8x^ma_Lg`2}+oKu4nb4EvZCz@Hbcgz=jvc5{x zniW=uGyP`@!@}SZlEkVx7hb;nLw(|DkdSZQuv0Ij#x+3{l5W!_w|acAIvK1?y({4S zjH{5}ZEz&)-KmXADk&lx(3qS1XRUsG)Ft!sausSMFR^i-y@TE@4uym5Ug9xE<*Mza zj?ZWrs*}rUXN#7YcDm?dsj0nqw@H{@2MhV^ZG5)UaZpiGw72J6sW@PstPh?|ig-Q| zV^MLFkS4wHeEO{}eFFoPXQgd3cI#78SFT)nR_QKKTwF}t%j{WL$TdDb zj;{RJgEdUaL@�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

ry^e?=OzIIuOdcbtfJvl%Rpc8_? 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

Y-4b+PeZK3R10S08Y1Xi#ySpr^;t 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

Cn*DcU@8X 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 literal 0 HcmV?d00001 diff --git a/src/ell/util/closure.py b/src/ell/util/closure.py index 6dc4d3a11..5987d8a03 100644 --- a/src/ell/util/closure.py +++ b/src/ell/util/closure.py @@ -1,527 +1,441 @@ -""" -This should do the following. -# prompt_consts.py -import math -def test(): - return math.sin(10) - -# lol3.py -import prompt_consts - -X = 7 -def xD(): - print(X) - return prompt_consts.test() - -### -Our goal is to use AST & dill to get a full lexical closured source of xD, with the exception of modules that are stored in site-packages. For example. - -lexical_extration(xD) returns -#closure.py -import math -def test(): - return math.sin(10) - -X = 7 -def xD(): - print(X) - return test() - -""" +# src/ell/util/closure.py + import collections -import ast import hashlib -import itertools -import os -from typing import Any, Dict, Iterable, Optional, Set, Tuple, Callable -import dill import inspect -import types -from dill.source import getsource -import importlib.util import re +import types from collections import deque -import black +from dataclasses import dataclass, field +from typing import Any, Callable, Dict, Optional, Set, Tuple, List +import itertools +import dill +from dill.source import getsource + +from ell.util.closure_util import ( + format_source, + get_referenced_names, + globalvars, + should_import, +) from ell.util.serialization import is_immutable_variable -DELIM = "$$$$$$$$$$$$$$$$$$$$$$$$$" -FORBIDDEN_NAMES = ["ell", "lstr"] +# Constants +FORBIDDEN_NAMES = {"ell", "lstr"} + + +@dataclass +class Dependency: + """Represents a dependency with its source code.""" + source: str + + +@dataclass +class ModuleDependency: + """Represents a module and its associated dependencies.""" + name: str + value: Any + dependencies: List[Dependency] = field(default_factory=list) + + +@dataclass +class Closure: + """Aggregates all closure-related information for a function.""" + source: str + dependencies: List[Dependency] = field(default_factory=list) + imports: Set[str] = field(default_factory=set) + modules: deque = field(default_factory=deque) + uses: Set[Any] = field(default_factory=set) + def lexical_closure( func: Any, - already_closed: Set[int] = None, + already_closed: Optional[Set[int]] = None, initial_call: bool = False, - recursion_stack: list = None, - forced_dependencies: Optional[Dict[str, Any]] = None -) -> Tuple[str, Tuple[str, str], Set[str]]: + recursion_stack: Optional[List[str]] = None, + forced_dependencies: Optional[Dict[str, Any]] = None, +) -> Tuple[str, Tuple[str, str], Set[Any]]: """ Generate a lexical closure for a given function or callable. Args: func: The function or callable to process. already_closed: Set of already processed function hashes. - initial_call: Whether this is the initial call to the function. - recursion_stack: Stack to keep track of the recursion path. + initial_call: Indicates if this is the initial call. + recursion_stack: Tracks the recursion path. + forced_dependencies: Additional dependencies to include. Returns: A tuple containing: - - The full source code of the closure - - A tuple of (function source, dependencies source) - - A set of function hashes that this closure uses + - Full source code of the closure. + - A tuple of (formatted source, cleaned source). + - A set of function objects used in the closure. """ already_closed = already_closed or set() - uses = set() - forced_dependencies = forced_dependencies or {} recursion_stack = recursion_stack or [] + forced_dependencies = forced_dependencies or {} - if hash(func) in already_closed: - return "", ("", ""), set() - - recursion_stack.append(getattr(func, '__qualname__', str(func))) - - outer_ell_func = func - while hasattr(func, "__ell_func__"): - func = func.__ell_func__ - - source = getsource(func, lstrip=True) - already_closed.add(hash(func)) - - globals_and_frees = _get_globals_and_frees(func) - dependencies, imports, modules = _process_dependencies(func, globals_and_frees, already_closed, recursion_stack, uses) - for k,v in forced_dependencies.items(): - # Todo: dictionary not necessary - _process_signature_dependency(v, dependencies, already_closed, recursion_stack, uses, k) - - cur_src = _build_initial_source(imports, dependencies, source) - - module_src = _process_modules(modules, cur_src, already_closed, recursion_stack, uses) - - dirty_src = _build_final_source(imports, module_src, dependencies, source) - dirty_src_without_func = _build_final_source(imports, module_src, dependencies, "") - - CLOSURE_SOURCE[hash(func)] = dirty_src - - dsrc = _clean_src(dirty_src_without_func) - - # Format the sorce and dsrc soruce using Black - source = _format_source(source) - dsrc = _format_source(dsrc) - - fn_hash = _generate_function_hash(source, dsrc, func.__qualname__) - - _update_ell_func(outer_ell_func, source, dsrc, globals_and_frees['globals'], globals_and_frees['frees'], fn_hash, uses) - - return (dirty_src, (source, dsrc), ({outer_ell_func} if not initial_call and hasattr(outer_ell_func, "__ell_func__") else uses)) + original_func, wrapper_func = _unwrap_function(func) + func_hash = hash(original_func) + if func_hash in already_closed: + return "", ("", ""), set() -def _format_source(source: str) -> str: - """Format the source code using Black.""" try: - return black.format_str(source, mode=black.Mode()) - except: - # If Black formatting fails, return the original source - return source + source = getsource(original_func, lstrip=True) + except (IOError, TypeError) as e: + _raise_error( + f"Unable to retrieve source for function '{original_func.__qualname__}'", + e, + recursion_stack, + ) -def _get_globals_and_frees(func: Callable) -> Dict[str, Dict]: - """Get global and free variables for a function.""" - globals_dict = collections.OrderedDict(globalvars(func)) - frees_dict = collections.OrderedDict(dill.detect.freevars(func)) - - if isinstance(func, type): - for name, method in collections.OrderedDict(func.__dict__).items(): - if isinstance(method, (types.FunctionType, types.MethodType)): - globals_dict.update(collections.OrderedDict(dill.detect.globalvars(method))) - frees_dict.update(collections.OrderedDict(dill.detect.freevars(method))) - - return {'globals': globals_dict, 'frees': frees_dict} + closure = Closure(source=source) + already_closed.add(func_hash) + recursion_stack.append(original_func.__qualname__) -def _process_dependencies(func, globals_and_frees, already_closed, recursion_stack, uses): - """Process function dependencies.""" - dependencies = [] - modules = deque() - imports = [] + globals_and_frees = _get_globals_and_frees(original_func) + _process_dependencies(original_func, globals_and_frees, closure, already_closed, recursion_stack) - if isinstance(func, (types.FunctionType, types.MethodType)): - _process_default_kwargs(func, dependencies, already_closed, recursion_stack, uses) + for name, dependency in forced_dependencies.items(): + _process_dependency(dependency, closure, already_closed, recursion_stack, name=name) - for var_name, var_value in itertools.chain(globals_and_frees['globals'].items(), globals_and_frees['frees'].items()): - _process_variable(var_name, var_value, dependencies, modules, imports, already_closed, recursion_stack, uses) + final_source = _assemble_final_source(closure) - return dependencies, imports, modules + cleaned_source = _clean_source(final_source) -def _process_default_kwargs(func, dependencies, already_closed, recursion_stack, uses): - """Process default keyword arguments of a function.""" - ps = inspect.signature(func).parameters - default_kwargs = collections.OrderedDict({k: v.default for k, v in ps.items() if v.default is not inspect.Parameter.empty}) - for name, val in default_kwargs.items(): - _process_signature_dependency(val, dependencies, already_closed, recursion_stack, uses, name) - -def _process_signature_dependency(val, dependencies, already_closed, recursion_stack, uses, name : Optional[str] = None): - # Todo: Buidl general cattr like utility for unstructureing python objects with ooks that keep track of state variables. - # Todo: break up closure into types and fucntions. - - if (name not in FORBIDDEN_NAMES): - try: - dep = None - _uses = None - if isinstance(val, (types.FunctionType, type, types.MethodType)): - dep, _, _uses = lexical_closure(val, already_closed=already_closed, recursion_stack=recursion_stack.copy()) - - elif isinstance(val, (list, tuple, set)): # Todo: Figure out recursive ypye closurex - # print(val) - for item in val: - _process_signature_dependency(item, dependencies, already_closed, recursion_stack, uses) - else: - try: - is_builtin = (val.__class__.__module__ == "builtins" or val.__class__.__module__ == "__builtins__" ) - except: - is_builtin = False - - if not is_builtin: - if should_import(val.__class__.__module__): - - dependencies.append(dill.source.getimport(val.__class__, alias=val.__class__.__name__)) - else: - dep, _, _uses = lexical_closure(type(val), already_closed=already_closed, recursion_stack=recursion_stack.copy()) - - if dep: dependencies.append(dep) - if _uses: uses.update(_uses) - except Exception as e: - _raise_error(f"Failed to capture the lexical closure of default parameter {name}", e, recursion_stack) + formatted_source = format_source(closure.source) + formatted_cleaned = format_source(cleaned_source) + function_hash = _generate_function_hash(formatted_source, formatted_cleaned, original_func.__qualname__) -def _process_variable(var_name, var_value, dependencies, modules, imports, already_closed, recursion_stack , uses): - """Process a single variable.""" - try: - name = inspect.getmodule(var_value).__name__ - if should_import(name): - imports.append(dill.source.getimport(var_value, alias=var_name)) - return - except: - pass - - if isinstance(var_value, (types.FunctionType, type, types.MethodType)): - _process_callable(var_name, var_value, dependencies, already_closed, recursion_stack, uses) - elif isinstance(var_value, types.ModuleType): - _process_module(var_name, var_value, modules, imports, uses) - elif isinstance(var_value, types.BuiltinFunctionType): - imports.append(dill.source.getimport(var_value, alias=var_name)) - else: - _process_other_variable(var_name, var_value, dependencies, uses) - -def _process_callable(var_name, var_value, dependencies, already_closed, recursion_stack, uses): - """Process a callable (function, method, or class).""" - try: - module_is_ell = 'ell' in inspect.getmodule(var_value).__name__ - except: - module_is_ell = False + # Set closure attributes on wrapper_func if exists, else on original_func + target_func = wrapper_func if wrapper_func else original_func + if isinstance(target_func, types.MethodType): + target_func = target_func.__func__ - if var_name not in FORBIDDEN_NAMES and not module_is_ell: - try: - dep, _, _uses = lexical_closure(var_value, already_closed=already_closed, recursion_stack=recursion_stack.copy()) - dependencies.append(dep) - uses.update(_uses) - except Exception as e: - _raise_error(f"Failed to capture the lexical closure of global or free variable {var_name}", e, recursion_stack) + target_func.__ell_closure__ = ( + formatted_source, + formatted_cleaned, + globals_and_frees["globals"], + globals_and_frees["frees"], + ) + target_func.__ell_hash__ = function_hash + # Only add to __ell_uses__ if it's an ell-decorated function + if hasattr(original_func, "__ell_func__"): + closure.uses.add(original_func) + target_func.__ell_uses__ = {fn for fn in closure.uses if hasattr(fn, "__ell_func__")} -def _process_module(var_name, var_value, modules, imports, uses): - """Process a module.""" - if should_import(var_value.__name__): - imports.append(dill.source.getimport(var_value, alias=var_name)) - else: - modules.append((var_name, var_value)) + uses_set = {original_func} if not initial_call else closure.uses + return final_source, (formatted_source, cleaned_source), uses_set -def _process_other_variable(var_name, var_value, dependencies, uses): - """Process variables that are not callables or modules.""" - if isinstance(var_value, str) and '\n' in var_value: - dependencies.append(f"{var_name} = '''{var_value}'''") - elif is_immutable_variable(var_value): - dependencies.append(f"#\n{var_name} = {repr(var_value)}\n#") - else: - dependencies.append(f"#\n{var_name} = <{type(var_value).__name__} object>\n#") - -def _build_initial_source(imports, dependencies, source): - """Build the initial source code.""" - return f"{DELIM}\n" + f"\n{DELIM}\n".join(imports + dependencies + [source]) + f"\n{DELIM}\n" - -def _process_modules(modules, cur_src, already_closed, recursion_stack, uses): - """Process module dependencies.""" - reverse_module_src = deque() - while modules: - mname, mval = modules.popleft() - mdeps = [] - attrs_to_extract = get_referenced_names(cur_src.replace(DELIM, ""), mname) - for attr in attrs_to_extract: - _process_module_attribute(mname, mval, attr, mdeps, modules, already_closed, recursion_stack, uses) - - mdeps.insert(0, f"# Extracted from module: {mname}") - reverse_module_src.appendleft("\n".join(mdeps)) - - cur_src = _dereference_module_names(cur_src, mname, attrs_to_extract) - - return list(reverse_module_src) - -def _process_module_attribute(mname, mval, attr, mdeps, modules, already_closed, recursion_stack, uses): - """Process a single attribute of a module.""" - val = getattr(mval, attr) - if isinstance(val, (types.FunctionType, type, types.MethodType)): - try: - dep, _, dep_uses = lexical_closure(val, already_closed=already_closed, recursion_stack=recursion_stack.copy()) - mdeps.append(dep) - uses.update(dep_uses) - except Exception as e: - _raise_error(f"Failed to capture the lexical closure of {mname}.{attr}", e, recursion_stack) - elif isinstance(val, types.ModuleType): - modules.append((attr, val)) - else: - mdeps.append(f"{attr} = {repr(val)}") - -def _dereference_module_names(cur_src, mname, attrs_to_extract): - """Dereference module names in the source code.""" - for attr in attrs_to_extract: - cur_src = cur_src.replace(f"{mname}.{attr}", attr) - return cur_src - -def _build_final_source(imports, module_src, dependencies, source): - """Build the final source code.""" - seperated_dependencies = sorted(imports) + sorted(module_src) + sorted(dependencies) + ([source] if source else []) - seperated_dependencies = list(dict.fromkeys(seperated_dependencies)) - return DELIM + "\n" + f"\n{DELIM}\n".join(seperated_dependencies) + "\n" + DELIM + "\n" - -def _generate_function_hash(source, dsrc, qualname): - """Generate a hash for the function.""" - return "lmp-" + hashlib.md5("\n".join((source, dsrc, qualname)).encode()).hexdigest() - -def _update_ell_func(outer_ell_func, source, dsrc, globals_dict, frees_dict, fn_hash, uses): - """Update the ell function attributes.""" - formatted_source = _format_source(source) - formatted_dsrc = _format_source(dsrc) - - if hasattr(outer_ell_func, "__ell_func__"): - - outer_ell_func.__ell_closure__ = (formatted_source, formatted_dsrc, globals_dict, frees_dict) - outer_ell_func.__ell_hash__ = fn_hash - outer_ell_func.__ell_uses__ = uses - -def _raise_error(message, exception, recursion_stack): - """Raise an error with detailed information.""" - error_msg = f"{message}. Error: {str(exception)}\n" - error_msg += f"Recursion stack: {' -> '.join(recursion_stack)}" - raise Exception(error_msg) -def should_import(module_name : str): +def lexically_closured_source( + func: Callable, forced_dependencies: Optional[Dict[str, Any]] = None +) -> Tuple[str, Tuple[str, str], Set[Any]]: """ - This function checks if a module should be imported based on its origin. - It returns False if the module is in the local directory or if the module's spec is None. - Otherwise, it returns True. + Generate a lexically closured source for a given function. - Returns: - bool: True if the module should be imported, False otherwise. - """ + This function creates a self-contained version of the provided callable, + capturing all dependencies, including global and free variables. - # Define the local directory - DIRECTORY_TO_WATCH = os.environ.get("DIRECTORY_TO_WATCH", os.getcwd()) + Args: + func (Callable): The function or callable to process. + forced_dependencies (Optional[Dict[str, Any]]): Additional dependencies + to include in the closure. - # Get the module's spec - spec = importlib.util.find_spec(module_name) + Returns: + Tuple containing: + 1. The full closure source code as a string. + 2. A tuple with (formatted source, cleaned source). + 3. A set of function objects used in the closure. - if module_name.startswith("ell"): - return True - - # Return False if the spec is None or if the spec's origin starts with the local directory - if spec is None or (spec.origin is not None and spec.origin.startswith(DIRECTORY_TO_WATCH)): - return False + Raises: + ValueError: If the input is not callable. + """ + if not callable(func): + raise ValueError("Input must be a callable object (function, method, or class).") - # Otherwise, return True - return True + closure_source, (formatted_source, cleaned_source), uses = lexical_closure( + func, initial_call=True, recursion_stack=[], forced_dependencies=forced_dependencies + ) + return closure_source, (formatted_source, cleaned_source), uses -def get_referenced_names(code: str, module_name: str): - """ - This function takes a block of code and a module name as input. It parses the code into an Abstract Syntax Tree (AST) - and walks through the tree to find all instances where an attribute of the module is referenced in the code. - Parameters: - code (str): The block of code to be parsed. - module_name (str): The name of the module to look for in the code. +def _unwrap_function(func: Any) -> Tuple[Callable, Optional[Callable]]: + """ + Recursively unwrap decorated functions to retrieve the original function. Returns: - list: A list of all attributes of the module that are referenced in the code. + A tuple containing: + - The original function. + - The outermost wrapper function (if any), else None. """ - tree = ast.parse(code) - referenced_names = [] - - for node in ast.walk(tree): - if isinstance(node, ast.Attribute): - if isinstance(node.value, ast.Name) and node.value.id == module_name: - referenced_names.append(node.attr) - - return referenced_names + wrappers = [] + while hasattr(func, "__ell_func__"): + wrappers.append(func) + func = func.__ell_func__ + return func, wrappers[-1] if wrappers else None -CLOSURE_SOURCE: Dict[str, str] = {} -def lexically_closured_source(func, forced_dependencies: Optional[Dict[str, Any]] = None): - """ - Generate a lexically closured source for a given function. +def _get_globals_and_frees(func: Callable) -> Dict[str, Dict[str, Any]]: + """Retrieve global and free variables of a function.""" + globals_dict = collections.OrderedDict(globalvars(func)) + frees_dict = collections.OrderedDict(dill.detect.freevars(func)) - This function takes a callable object (function, method, or class) and generates - a lexically closured source code. It captures all the dependencies, including - global variables, free variables, and nested functions, to create a self-contained - version of the function that can be executed independently. + if isinstance(func, type): + for method in func.__dict__.values(): + if isinstance(method, (types.FunctionType, types.MethodType)): + globals_dict.update(collections.OrderedDict(globalvars(method))) + frees_dict.update(collections.OrderedDict(dill.detect.freevars(method))) - Args: - func (Callable): The function or callable object to process. - forced_dependencies (Optional[Dict[str, Any]]): A dictionary of additional - dependencies to include in the closure. Keys are variable names, and - values are the corresponding objects. + return {"globals": globals_dict, "frees": frees_dict} - Returns: - Tuple[str, Set[Any]]: A tuple containing two elements: - 1. The lexically closured source code as a string. - 2. A set of function objects that this closure uses. - Raises: - ValueError: If the input is not a callable object. - - Example: - def outer(x): - y = 10 - def inner(): - return x + y - return inner - - closured_source, uses = lexically_closured_source(outer) - print(closured_source) - # Output will include the source for both outer and inner functions, - # along with any necessary imports and variable definitions. - - Note: - This function relies on the `lexical_closure` function to perform the - actual closure generation. It also uses the `__ell_closure__` attribute - of the function, which is expected to be set by the `lexical_closure` function. - """ - if not callable(func): - raise ValueError("Input must be a callable object (function, method, or class).") - _, fnclosure, uses = lexical_closure(func, initial_call=True, recursion_stack=[], forced_dependencies=forced_dependencies) - return func.__ell_closure__, uses +def _process_dependencies( + func: Callable, + globals_and_frees: Dict[str, Dict[str, Any]], + closure: Closure, + already_closed: Set[int], + recursion_stack: List[str], +): + """Process dependencies of a function.""" + if isinstance(func, (types.FunctionType, types.MethodType)): + _process_default_kwargs(func, closure, already_closed, recursion_stack) -import ast + for var_name, var_value in itertools.chain( + globals_and_frees["globals"].items(), globals_and_frees["frees"].items() + ): + _process_variable(var_name, var_value, closure, already_closed, recursion_stack) -def _clean_src(dirty_src): - # Now remove all duplicates and preserve order - split_by_setion = filter(lambda x: len(x.strip()) > 0, dirty_src.split(DELIM)) - # Now we need to remove all the duplicates - split_by_setion = list(dict.fromkeys(split_by_setion)) +def _process_default_kwargs( + func: Callable, + closure: Closure, + already_closed: Set[int], + recursion_stack: List[str], +): + """Process default keyword arguments of a function.""" + for name, param in inspect.signature(func).parameters.items(): + if param.default is not inspect.Parameter.empty: + _process_dependency(param.default, closure, already_closed, recursion_stack, name=name) + + +def _process_dependency( + value: Any, + closure: Closure, + already_closed: Set[int], + recursion_stack: List[str], + name: Optional[str] = None, +): + """Process dependencies from function signatures and variables.""" + if name in FORBIDDEN_NAMES: + return - # Now we need to concat all together - all_imports = [] - final_src = "\n".join(split_by_setion) - out_final_src = final_src[:] - for line in final_src.split("\n"): - if line.startswith("import") or line.startswith("from"): - all_imports.append(line) - out_final_src = out_final_src.replace(line, "") + try: + if isinstance(value, (types.FunctionType, type, types.MethodType)): + dep_source, _, dep_uses = lexical_closure( + value, already_closed, recursion_stack.copy() + ) + if dep_source: + closure.dependencies.append(Dependency(source=dep_source)) + closure.uses.add(value) + closure.uses.update(dep_uses) + elif isinstance(value, (list, tuple, set)): + for item in value: + _process_dependency(item, closure, already_closed, recursion_stack, name=name) + else: + is_builtin = getattr(value.__class__, "__module__", "") in {"builtins", "__builtins__"} + if not is_builtin: + module_name = value.__class__.__module__ + if should_import(module_name): + import_statement = dill.source.getimport(value.__class__, alias=value.__class__.__name__) + closure.imports.add(import_statement) + else: + dep_source, _, dep_uses = lexical_closure( + type(value), already_closed, recursion_stack.copy() + ) + if dep_source: + closure.dependencies.append(Dependency(source=dep_source)) + closure.uses.update(dep_uses) + except Exception as e: + _raise_error( + f"Failed to capture the lexical closure of dependency {name}", + e, + recursion_stack, + ) + + +def _process_variable( + var_name: str, + var_value: Any, + closure: Closure, + already_closed: Set[int], + recursion_stack: List[str], +): + """Process a single variable.""" + try: + module = inspect.getmodule(var_value) + module_name = module.__name__ if module else None + if module_name and should_import(module_name): + import_statement = dill.source.getimport(var_value, alias=var_name) + closure.imports.add(import_statement) + return + except Exception: + pass - all_imports = "\n".join(sorted(all_imports)) - final_src = all_imports + "\n" + out_final_src + if isinstance(var_value, (types.FunctionType, type, types.MethodType, types.ModuleType, types.BuiltinFunctionType)): + _handle_special_variable(var_name, var_value, closure, already_closed, recursion_stack) + else: + _handle_other_variable(var_name, var_value, closure) - # now replace all "\n\n\n" or longer with "\n\n" - final_src = re.sub(r"\n{3,}", "\n\n", final_src) - return final_src +def _handle_special_variable( + var_name: str, + var_value: Any, + closure: Closure, + already_closed: Set[int], + recursion_stack: List[str], +): + """Handle special types of variables like callables and modules.""" + if isinstance(var_value, (types.FunctionType, type, types.MethodType)): + _process_callable(var_name, var_value, closure, already_closed, recursion_stack) + elif isinstance(var_value, types.ModuleType): + _process_module(var_name, var_value, closure) + elif isinstance(var_value, types.BuiltinFunctionType): + import_statement = dill.source.getimport(var_value, alias=var_name) + closure.imports.add(import_statement) + + +def _process_callable( + var_name: str, + var_value: Callable, + closure: Closure, + already_closed: Set[int], + recursion_stack: List[str], +): + """Process a callable object.""" + try: + module_name = inspect.getmodule(var_value).__name__ + is_ell_module = "ell" in module_name + except Exception: + is_ell_module = False -def is_function_called(func_name, source_code): - """ - Check if a function is called in the given source code. + if var_name not in FORBIDDEN_NAMES and not is_ell_module: + try: + dep_source, _, dep_uses = lexical_closure( + var_value, already_closed, recursion_stack.copy() + ) + if dep_source: + closure.dependencies.append(Dependency(source=dep_source)) + closure.uses.add(var_value) + closure.uses.update(dep_uses) + except Exception as e: + _raise_error( + f"Failed to capture the lexical closure of global or free variable {var_name}", + e, + recursion_stack, + ) - Parameters: - func_name (str): The name of the function to check. - source_code (str): The source code to check. - Returns: - bool: True if the function is called, False otherwise. - """ - # Parse the source code into an AST - tree = ast.parse(source_code) - - # Walk through all the nodes in the AST - for node in ast.walk(tree): - # If the node is a function call - if isinstance(node, ast.Call): - # If the function being called is the function we're looking for - if isinstance(node.func, ast.Name) and node.func.id == func_name: - return True - - # If we've gone through all the nodes and haven't found a call to the function, it's not called - return False - -#!/usr/bin/env python -# -# Author: Mike McKerns (mmckerns @caltech and @uqfoundation) -# Modified by: William Guss. -# Copyright (c) 2008-2016 California Institute of Technology. -# Copyright (c) 2016-2024 The Uncertainty Quantification Foundation. -# License: 3-clause BSD. The full license text is available at: -# - https://github.com/uqfoundation/dill/blob/master/LICENSE -from dill.detect import nestedglobals -import inspect +def _process_module(var_name: str, var_value: types.ModuleType, closure: Closure): + """Process a module.""" + if should_import(var_value.__name__): + import_statement = dill.source.getimport(var_value, alias=var_name) + closure.imports.add(import_statement) + else: + closure.modules.append(ModuleDependency(name=var_name, value=var_value)) -def globalvars(func, recurse=True, builtin=False): - """get objects defined in global scope that are referred to by func - return a dict of {name:object}""" - while hasattr(func, "__ell_func__"): - func = func.__ell_func__ - if inspect.ismethod(func): func = func.__func__ - while hasattr(func, "__ell_func__"): - func = func.__ell_func__ - if inspect.isfunction(func): - globs = vars(inspect.getmodule(sum)).copy() if builtin else {} - # get references from within closure - orig_func, func = func, set() - for obj in orig_func.__closure__ or {}: - try: - cell_contents = obj.cell_contents - except ValueError: # cell is empty - pass - else: - _vars = globalvars(cell_contents, recurse, builtin) or {} - func.update(_vars) #XXX: (above) be wary of infinte recursion? - globs.update(_vars) - # get globals - globs.update(orig_func.__globals__ or {}) - # get names of references - if not recurse: - func.update(orig_func.__code__.co_names) - else: - func.update(nestedglobals(orig_func.__code__)) - # find globals for all entries of func - for key in func.copy(): #XXX: unnecessary...? - nested_func = globs.get(key) - if nested_func is orig_func: - #func.remove(key) if key in func else None - continue #XXX: globalvars(func, False)? - func.update(globalvars(nested_func, True, builtin)) - elif inspect.iscode(func): - globs = vars(inspect.getmodule(sum)).copy() if builtin else {} - #globs.update(globals()) - if not recurse: - func = func.co_names # get names - else: - orig_func = func.co_name # to stop infinite recursion - func = set(nestedglobals(func)) - # find globals for all entries of func - for key in func.copy(): #XXX: unnecessary...? - if key is orig_func: - #func.remove(key) if key in func else None - continue #XXX: globalvars(func, False)? - nested_func = globs.get(key) - func.update(globalvars(nested_func, True, builtin)) +def _handle_other_variable(var_name: str, var_value: Any, closure: Closure): + """Process non-callable and non-module variables.""" + if isinstance(var_value, str) and "\n" in var_value: + closure.dependencies.append(Dependency(source=f"{var_name} = '''{var_value}'''")) + elif is_immutable_variable(var_value): + closure.dependencies.append(Dependency(source=f"#\n{var_name} = {repr(var_value)}\n#")) else: - return {} - #NOTE: if name not in __globals__, then we skip it... - return dict((name,globs[name]) for name in func if name in globs) + closure.dependencies.append(Dependency(source=f"#\n{var_name} = <{type(var_value).__name__} object>\n#")) + + +def _assemble_final_source(closure: Closure) -> str: + """Assemble the final source code.""" + parts = [] + if closure.imports: + parts.append("\n".join(sorted(closure.imports))) + if closure.dependencies: + parts.append("\n".join(dep.source for dep in closure.dependencies)) + if closure.modules: + module_sources = [] + for module_dep in closure.modules: + module_sources.append(f"# Module: {module_dep.name}") + module_dependencies = "\n".join(dep.source for dep in module_dep.dependencies) + if module_dependencies: + module_sources.append(module_dependencies) + parts.append("\n\n".join(module_sources)) + if closure.source: + parts.append(closure.source) + + combined = "\n\n".join(parts) + + # Remove duplicate lines while preserving order + unique_lines = [] + seen = set() + for line in combined.split("\n"): + if line not in seen: + unique_lines.append(line) + seen.add(line) + final_source = "\n".join(unique_lines) + + # Replace multiple newlines with two + final_source = re.sub(r"\n{3,}", "\n\n", final_source) + + return final_source + + +def _generate_function_hash(source: str, cleaned_source: str, qualname: str) -> str: + """Generate a unique hash for the function.""" + hash_input = "\n".join((source, cleaned_source, qualname)).encode() + return "lmp-" + hashlib.md5(hash_input).hexdigest() + + +def _update_ell_func( + outer_func: Any, + source: str, + cleaned_source: str, + globals_dict: Dict[str, Any], + frees_dict: Dict[str, Any], + function_hash: str, + uses: Set[Any], +): + """Update the attributes of the outer function with closure information.""" + formatted_source = format_source(source) + formatted_cleaned = format_source(cleaned_source) + + # If it's a bound method, set attributes on the underlying function + if isinstance(outer_func, types.MethodType): + outer_func = outer_func.__func__ + + outer_func.__ell_closure__ = ( + formatted_source, + formatted_cleaned, + globals_dict, + frees_dict, + ) + outer_func.__ell_hash__ = function_hash + # Only add ell-decorated functions to __ell_uses__ + ell_uses = {fn for fn in closure.uses if hasattr(fn, "__ell_func__")} + outer_func.__ell_uses__ = ell_uses + + +def _raise_error(message: str, exception: Exception, recursion_stack: List[str]): + """Raise an exception with a detailed message.""" + error_msg = f"{message}. Error: {str(exception)}\nRecursion stack: {' -> '.join(recursion_stack)}" + raise Exception(error_msg) -# XXX: This is a mess. COuld probably be about 100 lines of code max. \ No newline at end of file +def _clean_source(final_source: str) -> str: + """Clean the source code by removing duplicates and organizing imports.""" + # Replace multiple newlines with two + cleaned = re.sub(r"\n{3,}", "\n\n", final_source) + return cleaned \ No newline at end of file diff --git a/src/ell/util/closure_util.py b/src/ell/util/closure_util.py new file mode 100644 index 000000000..da2a28c7e --- /dev/null +++ b/src/ell/util/closure_util.py @@ -0,0 +1,160 @@ +import ast +import importlib +import os +import black +from dill.detect import nestedglobals + +import inspect + +import inspect + +#!/usr/bin/env python +# +# Author: Mike McKerns (mmckerns @caltech and @uqfoundation) +# Modified by: William Guss. +# Copyright (c) 2008-2016 California Institute of Technology. +# Copyright (c) 2016-2024 The Uncertainty Quantification Foundation. +# License: 3-clause BSD. The full license text is available at: +# - https://github.com/uqfoundation/dill/blob/master/LICENSE + +# XXX: This is a mess. COuld probably be about 100 lines of code max. +def globalvars(func, recurse=True, builtin=False): + """get objects defined in global scope that are referred to by func + + return a dict of {name:object}""" + while hasattr(func, "__ell_func__"): + func = func.__ell_func__ + if inspect.ismethod(func): func = func.__func__ + while hasattr(func, "__ell_func__"): + func = func.__ell_func__ + if inspect.isfunction(func): + globs = vars(inspect.getmodule(sum)).copy() if builtin else {} + # get references from within closure + orig_func, func = func, set() + for obj in orig_func.__closure__ or {}: + try: + cell_contents = obj.cell_contents + except ValueError: # cell is empty + pass + else: + _vars = globalvars(cell_contents, recurse, builtin) or {} + func.update(_vars) #XXX: (above) be wary of infinte recursion? + globs.update(_vars) + # get globals + globs.update(orig_func.__globals__ or {}) + # get names of references + if not recurse: + func.update(orig_func.__code__.co_names) + else: + func.update(nestedglobals(orig_func.__code__)) + # find globals for all entries of func + for key in func.copy(): #XXX: unnecessary...? + nested_func = globs.get(key) + if nested_func is orig_func: + #func.remove(key) if key in func else None + continue #XXX: globalvars(func, False)? + func.update(globalvars(nested_func, True, builtin)) + elif inspect.iscode(func): + globs = vars(inspect.getmodule(sum)).copy() if builtin else {} + #globs.update(globals()) + if not recurse: + func = func.co_names # get names + else: + orig_func = func.co_name # to stop infinite recursion + func = set(nestedglobals(func)) + # find globals for all entries of func + for key in func.copy(): #XXX: unnecessary...? + if key is orig_func: + #func.remove(key) if key in func else None + continue #XXX: globalvars(func, False)? + nested_func = globs.get(key) + func.update(globalvars(nested_func, True, builtin)) + else: + return {} + #NOTE: if name not in __globals__, then we skip it... + return dict((name,globs[name]) for name in func if name in globs) + + +def is_function_called(func_name, source_code): + """ + Check if a function is called in the given source code. + + Parameters: + func_name (str): The name of the function to check. + source_code (str): The source code to check. + + Returns: + bool: True if the function is called, False otherwise. + """ + # Parse the source code into an AST + tree = ast.parse(source_code) + + # Walk through all the nodes in the AST + for node in ast.walk(tree): + # If the node is a function call + if isinstance(node, ast.Call): + # If the function being called is the function we're looking for + if isinstance(node.func, ast.Name) and node.func.id == func_name: + return True + + # If we've gone through all the nodes and haven't found a call to the function, it's not called + return False + + +def get_referenced_names(code: str, module_name: str): + """ + This function takes a block of code and a module name as input. It parses the code into an Abstract Syntax Tree (AST) + and walks through the tree to find all instances where an attribute of the module is referenced in the code. + + Parameters: + code (str): The block of code to be parsed. + module_name (str): The name of the module to look for in the code. + + Returns: + list: A list of all attributes of the module that are referenced in the code. + """ + tree = ast.parse(code) + referenced_names = [] + + for node in ast.walk(tree): + if isinstance(node, ast.Attribute): + if isinstance(node.value, ast.Name) and node.value.id == module_name: + referenced_names.append(node.attr) + + return referenced_names + + +def should_import(module_name : str): + """ + This function checks if a module should be imported based on its origin. + It returns False if the module is in the local directory or if the module's spec is None. + Otherwise, it returns True. + + Returns: + bool: True if the module should be imported, False otherwise. + """ + + # Define the local directory + DIRECTORY_TO_WATCH = os.environ.get("DIRECTORY_TO_WATCH", os.getcwd()) + + # Get the module's spec + spec = importlib.util.find_spec(module_name) + + if module_name.startswith("ell"): + return True + + # Return False if the spec is None or if the spec's origin starts with the local directory + if spec is None or (spec.origin is not None and spec.origin.startswith(DIRECTORY_TO_WATCH)): + return False + + # Otherwise, return True + return True + + +def format_source(source: str) -> str: + """Format the source code using Black.""" + try: + return black.format_str(source, mode=black.Mode()) + except: + # If Black formatting fails, return the original source + return source \ No newline at end of file diff --git a/tests/test_closure.py b/tests/test_closure.py index 4a040d060..e42ab90c9 100644 --- a/tests/test_closure.py +++ b/tests/test_closure.py @@ -1,14 +1,14 @@ from functools import wraps +import random import pytest import math from typing import Set, Any import numpy as np from ell.util.closure import ( lexical_closure, - should_import, - get_referenced_names, ) import ell +from ell.util.closure_util import get_referenced_names, should_import from ell.util.serialization import is_immutable_variable @@ -179,6 +179,64 @@ def static_method(z): closure_static_method, (_, _), uses_static_method = lexical_closure(MyClass.static_method) assert "def static_method(z):" in closure_static_method assert "z * 2" in closure_static_method +# tests/test_closure.py + +import pytest +from ell.util.closure import lexically_closured_source + +def test_lexical_closure_eliminates_redundant_dependencies(): + # Define a shared dependency function + def dependency_func(): + return "I am a shared dependency" + + # Define two functions that both depend on dependency_func + def func_a(): + return dependency_func() + + def func_b(): + return dependency_func() + + # Define a top-level function that depends on func_a and func_b + def func_c(): + return func_a() + func_b() + + # Generate the lexically closured source for func_c + closure_source, (formatted_source, cleaned_source), uses = lexically_closured_source(func_c) + + # Debugging output (optional) + print("Closure Source:\n", closure_source) + + # Assertions to ensure each function definition appears only once + assert "def func_c():" in closure_source, "func_c definition should be in the closure source" + assert "def func_a():" in closure_source, "func_a definition should be in the closure source" + assert "def func_b():" in closure_source, "func_b definition should be in the closure source" + assert "def dependency_func():" in closure_source, "dependency_func definition should be in the closure source" + + # Count the number of times each function is defined in the closure source + func_c_definitions = closure_source.count("def func_c():") + func_a_definitions = closure_source.count("def func_a():") + func_b_definitions = closure_source.count("def func_b():") + dependency_func_definitions = closure_source.count("def dependency_func():") + + # Assert that each function is defined only once + assert func_c_definitions == 1, "func_c should be defined exactly once in the closure source" + assert func_a_definitions == 1, "func_a should be defined exactly once in the closure source" + assert func_b_definitions == 1, "func_b should be defined exactly once in the closure source" + assert dependency_func_definitions == 1, "dependency_func should be defined exactly once in the closure source" + + # Additionally, ensure that there are no duplicate imports or dependencies + # (Assuming no imports are needed in this simple example) + # If imports exist, similar counts can be performed + + # Optionally, verify that the closure source contains no duplicate lines + lines = closure_source.split("\n") + unique_lines = set() + for line in lines: + stripped_line = line.strip() + if stripped_line: # Ignore empty lines + assert stripped_line not in unique_lines, f"Duplicate line found in closure source: {stripped_line}" + unique_lines.add(stripped_line) + # def test_lexical_closure_with_recursive_function(): # def factorial(n): @@ -322,5 +380,80 @@ async def async_func(x): # assert "return func_a()" in closure # assert isinstance(uses, Set) +def test_ell_uses_only_include_ell_decorated_functions(): + # Define an ell-decorated function + @ell.simple(model="gpt-4o-mini") + def do_nothing(): + pass + + # Define non-ell functions + def get_random_adjective(): + adjectives = ["enthusiastic", "cheerful", "warm", "friendly", "heartfelt", "sincere"] + do_nothing() # This is an ell-decorated function + return random.choice(adjectives) + + def get_random_punctuation(): + return random.choice(["!", "!!", "!!!"]) + + # Define an ell-decorated function that uses both ell and non-ell functions + @ell.simple(model="gpt-4o-mini") + def hello(name: str): + adjective = get_random_adjective() + punctuation = get_random_punctuation() + return f"Say a {adjective} hello to {name}{punctuation}" + + # Generate the lexically closured source for hello + closure_source, (formatted_source, cleaned_source), uses = lexically_closured_source(hello) + + # Debugging output (optional) + print("Closure Source:\n", closure_source) + + # Assertions to ensure each function definition appears only once + assert "def hello(name: str):" in closure_source, "hello definition should be in the closure source" + assert "def get_random_adjective():" in closure_source, "get_random_adjective definition should be in the closure source" + assert "def get_random_punctuation():" in closure_source, "get_random_punctuation definition should be in the closure source" + assert "def do_nothing():" in closure_source, "do_nothing definition should be in the closure source" + + # Count the number of times each function is defined in the closure source + hello_definitions = closure_source.count("def hello(name: str):") + get_random_adjective_definitions = closure_source.count("def get_random_adjective():") + get_random_punctuation_definitions = closure_source.count("def get_random_punctuation():") + do_nothing_definitions = closure_source.count("def do_nothing():") + + # Assert that each function is defined only once + assert hello_definitions == 1, "hello should be defined exactly once in the closure source" + assert get_random_adjective_definitions == 1, "get_random_adjective should be defined exactly once in the closure source" + assert get_random_punctuation_definitions == 1, "get_random_punctuation should be defined exactly once in the closure source" + assert do_nothing_definitions == 1, "do_nothing should be defined exactly once in the closure source" + + # Ensure that __ell_uses__ contains only ell-decorated functions + # Retrieve the closure attributes from the original function + closure_attributes = hello.__ell_closure__ + uses_set = hello.__ell_uses__ + + # Assert that uses_set contains only do_nothing + assert len(uses_set) == 1, "__ell_uses__ should contain exactly one function" + assert do_nothing in uses_set, "__ell_uses__ should contain only do_nothing" + + # Additionally, ensure that non-ell functions are not in __ell_uses__ + assert get_random_adjective not in uses_set, "get_random_adjective should not be in __ell_uses__" + assert get_random_punctuation not in uses_set, "get_random_punctuation should not be in __ell_uses__" + + # Ensure that dependencies include non-ell functions + # For simplicity, we'll check that get_random_punctuation is present as a dependency + assert "def get_random_punctuation():" in closure_source, "get_random_punctuation should be included as a dependency" + + # Ensure that imports are correctly handled (e.g., random) + assert "import random" in closure_source, "random should be imported in the closure source" + + # Ensure no duplicate lines exist + lines = closure_source.split("\n") + unique_lines = set() + for line in lines: + stripped_line = line.strip() + if stripped_line: # Ignore empty lines + assert stripped_line not in unique_lines, f"Duplicate line found in closure source: {stripped_line}" + unique_lines.add(stripped_line) + if __name__ == "__main__": test_lexical_closure_uses() \ No newline at end of file From 8b00fe71ecd7a3ef4afb6f0bd9ffbab6d4e894c8 Mon Sep 17 00:00:00 2001 From: William Guss Date: Sun, 15 Sep 2024 19:46:29 -0700 Subject: [PATCH 04/11] revert bullshit --- examples/multilmp.py | 8 +- src/ell/util/closure.py | 824 ++++++++++++++++++++++------------------ tests/test_closure.py | 249 ++++++------ 3 files changed, 584 insertions(+), 497 deletions(-) diff --git a/examples/multilmp.py b/examples/multilmp.py index 2068cf730..cba00923a 100644 --- a/examples/multilmp.py +++ b/examples/multilmp.py @@ -5,22 +5,22 @@ ell.config.verbose = True -@ell.simple(model="gpt-4o-mini", temperature=1.0) +@ell.simple(model="gpt-4o-mini", temperature=1.0, max_tokens=15) def generate_story_ideas(about : str): """You are an expert story ideator. Only answer in a single sentence.""" return f"Generate a story idea about {about}." -@ell.simple(model="gpt-4o-mini", temperature=1.0) +@ell.simple(model="gpt-4o-mini", temperature=1.0, max_tokens=15) def write_a_draft_of_a_story(idea : str): """You are an adept story writer. The story should only be 3 paragraphs.""" return f"Write a story about {idea}." -@ell.simple(model="gpt-4o", temperature=0.1) +@ell.simple(model="gpt-4o", temperature=0.1, max_tokens=15) def choose_the_best_draft(drafts : List[str]): """You are an expert fiction editor.""" return f"Choose the best draft from the following list: {'\n'.join(drafts)}." -@ell.simple(model="gpt-4-turbo", temperature=0.2) +@ell.simple(model="gpt-4-turbo", temperature=0.2, max_tokens=15) def write_a_really_good_story(about : str): ideas = generate_story_ideas(about, lm_params=(dict(n=4))) diff --git a/src/ell/util/closure.py b/src/ell/util/closure.py index 5987d8a03..6dc4d3a11 100644 --- a/src/ell/util/closure.py +++ b/src/ell/util/closure.py @@ -1,441 +1,527 @@ -# src/ell/util/closure.py - +""" +This should do the following. +# prompt_consts.py +import math +def test(): + return math.sin(10) + +# lol3.py +import prompt_consts + +X = 7 +def xD(): + print(X) + return prompt_consts.test() + +### +Our goal is to use AST & dill to get a full lexical closured source of xD, with the exception of modules that are stored in site-packages. For example. + +lexical_extration(xD) returns +#closure.py +import math +def test(): + return math.sin(10) + +X = 7 +def xD(): + print(X) + return test() + +""" import collections +import ast import hashlib -import inspect -import re -import types -from collections import deque -from dataclasses import dataclass, field -from typing import Any, Callable, Dict, Optional, Set, Tuple, List - import itertools +import os +from typing import Any, Dict, Iterable, Optional, Set, Tuple, Callable import dill +import inspect +import types from dill.source import getsource +import importlib.util +import re +from collections import deque +import black -from ell.util.closure_util import ( - format_source, - get_referenced_names, - globalvars, - should_import, -) from ell.util.serialization import is_immutable_variable -# Constants -FORBIDDEN_NAMES = {"ell", "lstr"} - - -@dataclass -class Dependency: - """Represents a dependency with its source code.""" - source: str - - -@dataclass -class ModuleDependency: - """Represents a module and its associated dependencies.""" - name: str - value: Any - dependencies: List[Dependency] = field(default_factory=list) - - -@dataclass -class Closure: - """Aggregates all closure-related information for a function.""" - source: str - dependencies: List[Dependency] = field(default_factory=list) - imports: Set[str] = field(default_factory=set) - modules: deque = field(default_factory=deque) - uses: Set[Any] = field(default_factory=set) - +DELIM = "$$$$$$$$$$$$$$$$$$$$$$$$$" +FORBIDDEN_NAMES = ["ell", "lstr"] def lexical_closure( func: Any, - already_closed: Optional[Set[int]] = None, + already_closed: Set[int] = None, initial_call: bool = False, - recursion_stack: Optional[List[str]] = None, - forced_dependencies: Optional[Dict[str, Any]] = None, -) -> Tuple[str, Tuple[str, str], Set[Any]]: + recursion_stack: list = None, + forced_dependencies: Optional[Dict[str, Any]] = None +) -> Tuple[str, Tuple[str, str], Set[str]]: """ Generate a lexical closure for a given function or callable. Args: func: The function or callable to process. already_closed: Set of already processed function hashes. - initial_call: Indicates if this is the initial call. - recursion_stack: Tracks the recursion path. - forced_dependencies: Additional dependencies to include. + initial_call: Whether this is the initial call to the function. + recursion_stack: Stack to keep track of the recursion path. Returns: A tuple containing: - - Full source code of the closure. - - A tuple of (formatted source, cleaned source). - - A set of function objects used in the closure. + - The full source code of the closure + - A tuple of (function source, dependencies source) + - A set of function hashes that this closure uses """ already_closed = already_closed or set() - recursion_stack = recursion_stack or [] + uses = set() forced_dependencies = forced_dependencies or {} + recursion_stack = recursion_stack or [] - original_func, wrapper_func = _unwrap_function(func) - - func_hash = hash(original_func) - if func_hash in already_closed: + if hash(func) in already_closed: return "", ("", ""), set() - try: - source = getsource(original_func, lstrip=True) - except (IOError, TypeError) as e: - _raise_error( - f"Unable to retrieve source for function '{original_func.__qualname__}'", - e, - recursion_stack, - ) + recursion_stack.append(getattr(func, '__qualname__', str(func))) - closure = Closure(source=source) - already_closed.add(func_hash) - recursion_stack.append(original_func.__qualname__) + outer_ell_func = func + while hasattr(func, "__ell_func__"): + func = func.__ell_func__ - globals_and_frees = _get_globals_and_frees(original_func) - _process_dependencies(original_func, globals_and_frees, closure, already_closed, recursion_stack) + source = getsource(func, lstrip=True) + already_closed.add(hash(func)) - for name, dependency in forced_dependencies.items(): - _process_dependency(dependency, closure, already_closed, recursion_stack, name=name) + globals_and_frees = _get_globals_and_frees(func) + dependencies, imports, modules = _process_dependencies(func, globals_and_frees, already_closed, recursion_stack, uses) + for k,v in forced_dependencies.items(): + # Todo: dictionary not necessary + _process_signature_dependency(v, dependencies, already_closed, recursion_stack, uses, k) + + cur_src = _build_initial_source(imports, dependencies, source) + + module_src = _process_modules(modules, cur_src, already_closed, recursion_stack, uses) + + dirty_src = _build_final_source(imports, module_src, dependencies, source) + dirty_src_without_func = _build_final_source(imports, module_src, dependencies, "") - final_source = _assemble_final_source(closure) + CLOSURE_SOURCE[hash(func)] = dirty_src - cleaned_source = _clean_source(final_source) + dsrc = _clean_src(dirty_src_without_func) - formatted_source = format_source(closure.source) - formatted_cleaned = format_source(cleaned_source) + # Format the sorce and dsrc soruce using Black + source = _format_source(source) + dsrc = _format_source(dsrc) - function_hash = _generate_function_hash(formatted_source, formatted_cleaned, original_func.__qualname__) + fn_hash = _generate_function_hash(source, dsrc, func.__qualname__) + + _update_ell_func(outer_ell_func, source, dsrc, globals_and_frees['globals'], globals_and_frees['frees'], fn_hash, uses) + + return (dirty_src, (source, dsrc), ({outer_ell_func} if not initial_call and hasattr(outer_ell_func, "__ell_func__") else uses)) - # Set closure attributes on wrapper_func if exists, else on original_func - target_func = wrapper_func if wrapper_func else original_func - if isinstance(target_func, types.MethodType): - target_func = target_func.__func__ - target_func.__ell_closure__ = ( - formatted_source, - formatted_cleaned, - globals_and_frees["globals"], - globals_and_frees["frees"], - ) - target_func.__ell_hash__ = function_hash - # Only add to __ell_uses__ if it's an ell-decorated function - if hasattr(original_func, "__ell_func__"): - closure.uses.add(original_func) - target_func.__ell_uses__ = {fn for fn in closure.uses if hasattr(fn, "__ell_func__")} +def _format_source(source: str) -> str: + """Format the source code using Black.""" + try: + return black.format_str(source, mode=black.Mode()) + except: + # If Black formatting fails, return the original source + return source - uses_set = {original_func} if not initial_call else closure.uses - return final_source, (formatted_source, cleaned_source), uses_set +def _get_globals_and_frees(func: Callable) -> Dict[str, Dict]: + """Get global and free variables for a function.""" + globals_dict = collections.OrderedDict(globalvars(func)) + frees_dict = collections.OrderedDict(dill.detect.freevars(func)) + + if isinstance(func, type): + for name, method in collections.OrderedDict(func.__dict__).items(): + if isinstance(method, (types.FunctionType, types.MethodType)): + globals_dict.update(collections.OrderedDict(dill.detect.globalvars(method))) + frees_dict.update(collections.OrderedDict(dill.detect.freevars(method))) + + return {'globals': globals_dict, 'frees': frees_dict} +def _process_dependencies(func, globals_and_frees, already_closed, recursion_stack, uses): + """Process function dependencies.""" + dependencies = [] + modules = deque() + imports = [] -def lexically_closured_source( - func: Callable, forced_dependencies: Optional[Dict[str, Any]] = None -) -> Tuple[str, Tuple[str, str], Set[Any]]: - """ - Generate a lexically closured source for a given function. + if isinstance(func, (types.FunctionType, types.MethodType)): + _process_default_kwargs(func, dependencies, already_closed, recursion_stack, uses) - This function creates a self-contained version of the provided callable, - capturing all dependencies, including global and free variables. + for var_name, var_value in itertools.chain(globals_and_frees['globals'].items(), globals_and_frees['frees'].items()): + _process_variable(var_name, var_value, dependencies, modules, imports, already_closed, recursion_stack, uses) - Args: - func (Callable): The function or callable to process. - forced_dependencies (Optional[Dict[str, Any]]): Additional dependencies - to include in the closure. + return dependencies, imports, modules - Returns: - Tuple containing: - 1. The full closure source code as a string. - 2. A tuple with (formatted source, cleaned source). - 3. A set of function objects used in the closure. +def _process_default_kwargs(func, dependencies, already_closed, recursion_stack, uses): + """Process default keyword arguments of a function.""" + ps = inspect.signature(func).parameters + default_kwargs = collections.OrderedDict({k: v.default for k, v in ps.items() if v.default is not inspect.Parameter.empty}) + for name, val in default_kwargs.items(): + _process_signature_dependency(val, dependencies, already_closed, recursion_stack, uses, name) + +def _process_signature_dependency(val, dependencies, already_closed, recursion_stack, uses, name : Optional[str] = None): + # Todo: Buidl general cattr like utility for unstructureing python objects with ooks that keep track of state variables. + # Todo: break up closure into types and fucntions. + + if (name not in FORBIDDEN_NAMES): + try: + dep = None + _uses = None + if isinstance(val, (types.FunctionType, type, types.MethodType)): + dep, _, _uses = lexical_closure(val, already_closed=already_closed, recursion_stack=recursion_stack.copy()) + + elif isinstance(val, (list, tuple, set)): # Todo: Figure out recursive ypye closurex + # print(val) + for item in val: + _process_signature_dependency(item, dependencies, already_closed, recursion_stack, uses) + else: + try: + is_builtin = (val.__class__.__module__ == "builtins" or val.__class__.__module__ == "__builtins__" ) + except: + is_builtin = False + + if not is_builtin: + if should_import(val.__class__.__module__): + + dependencies.append(dill.source.getimport(val.__class__, alias=val.__class__.__name__)) + else: + dep, _, _uses = lexical_closure(type(val), already_closed=already_closed, recursion_stack=recursion_stack.copy()) + + if dep: dependencies.append(dep) + if _uses: uses.update(_uses) + except Exception as e: + _raise_error(f"Failed to capture the lexical closure of default parameter {name}", e, recursion_stack) - Raises: - ValueError: If the input is not callable. + +def _process_variable(var_name, var_value, dependencies, modules, imports, already_closed, recursion_stack , uses): + """Process a single variable.""" + try: + name = inspect.getmodule(var_value).__name__ + if should_import(name): + imports.append(dill.source.getimport(var_value, alias=var_name)) + return + except: + pass + + if isinstance(var_value, (types.FunctionType, type, types.MethodType)): + _process_callable(var_name, var_value, dependencies, already_closed, recursion_stack, uses) + elif isinstance(var_value, types.ModuleType): + _process_module(var_name, var_value, modules, imports, uses) + elif isinstance(var_value, types.BuiltinFunctionType): + imports.append(dill.source.getimport(var_value, alias=var_name)) + else: + _process_other_variable(var_name, var_value, dependencies, uses) + +def _process_callable(var_name, var_value, dependencies, already_closed, recursion_stack, uses): + """Process a callable (function, method, or class).""" + try: + module_is_ell = 'ell' in inspect.getmodule(var_value).__name__ + except: + module_is_ell = False + + if var_name not in FORBIDDEN_NAMES and not module_is_ell: + try: + dep, _, _uses = lexical_closure(var_value, already_closed=already_closed, recursion_stack=recursion_stack.copy()) + dependencies.append(dep) + uses.update(_uses) + except Exception as e: + _raise_error(f"Failed to capture the lexical closure of global or free variable {var_name}", e, recursion_stack) + +def _process_module(var_name, var_value, modules, imports, uses): + """Process a module.""" + if should_import(var_value.__name__): + imports.append(dill.source.getimport(var_value, alias=var_name)) + else: + modules.append((var_name, var_value)) + +def _process_other_variable(var_name, var_value, dependencies, uses): + """Process variables that are not callables or modules.""" + if isinstance(var_value, str) and '\n' in var_value: + dependencies.append(f"{var_name} = '''{var_value}'''") + elif is_immutable_variable(var_value): + dependencies.append(f"#\n{var_name} = {repr(var_value)}\n#") + else: + dependencies.append(f"#\n{var_name} = <{type(var_value).__name__} object>\n#") + +def _build_initial_source(imports, dependencies, source): + """Build the initial source code.""" + return f"{DELIM}\n" + f"\n{DELIM}\n".join(imports + dependencies + [source]) + f"\n{DELIM}\n" + +def _process_modules(modules, cur_src, already_closed, recursion_stack, uses): + """Process module dependencies.""" + reverse_module_src = deque() + while modules: + mname, mval = modules.popleft() + mdeps = [] + attrs_to_extract = get_referenced_names(cur_src.replace(DELIM, ""), mname) + for attr in attrs_to_extract: + _process_module_attribute(mname, mval, attr, mdeps, modules, already_closed, recursion_stack, uses) + + mdeps.insert(0, f"# Extracted from module: {mname}") + reverse_module_src.appendleft("\n".join(mdeps)) + + cur_src = _dereference_module_names(cur_src, mname, attrs_to_extract) + + return list(reverse_module_src) + +def _process_module_attribute(mname, mval, attr, mdeps, modules, already_closed, recursion_stack, uses): + """Process a single attribute of a module.""" + val = getattr(mval, attr) + if isinstance(val, (types.FunctionType, type, types.MethodType)): + try: + dep, _, dep_uses = lexical_closure(val, already_closed=already_closed, recursion_stack=recursion_stack.copy()) + mdeps.append(dep) + uses.update(dep_uses) + except Exception as e: + _raise_error(f"Failed to capture the lexical closure of {mname}.{attr}", e, recursion_stack) + elif isinstance(val, types.ModuleType): + modules.append((attr, val)) + else: + mdeps.append(f"{attr} = {repr(val)}") + +def _dereference_module_names(cur_src, mname, attrs_to_extract): + """Dereference module names in the source code.""" + for attr in attrs_to_extract: + cur_src = cur_src.replace(f"{mname}.{attr}", attr) + return cur_src + +def _build_final_source(imports, module_src, dependencies, source): + """Build the final source code.""" + seperated_dependencies = sorted(imports) + sorted(module_src) + sorted(dependencies) + ([source] if source else []) + seperated_dependencies = list(dict.fromkeys(seperated_dependencies)) + return DELIM + "\n" + f"\n{DELIM}\n".join(seperated_dependencies) + "\n" + DELIM + "\n" + +def _generate_function_hash(source, dsrc, qualname): + """Generate a hash for the function.""" + return "lmp-" + hashlib.md5("\n".join((source, dsrc, qualname)).encode()).hexdigest() + +def _update_ell_func(outer_ell_func, source, dsrc, globals_dict, frees_dict, fn_hash, uses): + """Update the ell function attributes.""" + formatted_source = _format_source(source) + formatted_dsrc = _format_source(dsrc) + + if hasattr(outer_ell_func, "__ell_func__"): + + outer_ell_func.__ell_closure__ = (formatted_source, formatted_dsrc, globals_dict, frees_dict) + outer_ell_func.__ell_hash__ = fn_hash + outer_ell_func.__ell_uses__ = uses + +def _raise_error(message, exception, recursion_stack): + """Raise an error with detailed information.""" + error_msg = f"{message}. Error: {str(exception)}\n" + error_msg += f"Recursion stack: {' -> '.join(recursion_stack)}" + raise Exception(error_msg) + +def should_import(module_name : str): + """ + This function checks if a module should be imported based on its origin. + It returns False if the module is in the local directory or if the module's spec is None. + Otherwise, it returns True. + + Returns: + bool: True if the module should be imported, False otherwise. """ - if not callable(func): - raise ValueError("Input must be a callable object (function, method, or class).") - closure_source, (formatted_source, cleaned_source), uses = lexical_closure( - func, initial_call=True, recursion_stack=[], forced_dependencies=forced_dependencies - ) - return closure_source, (formatted_source, cleaned_source), uses + # Define the local directory + DIRECTORY_TO_WATCH = os.environ.get("DIRECTORY_TO_WATCH", os.getcwd()) + # Get the module's spec + spec = importlib.util.find_spec(module_name) -def _unwrap_function(func: Any) -> Tuple[Callable, Optional[Callable]]: + if module_name.startswith("ell"): + return True + + # Return False if the spec is None or if the spec's origin starts with the local directory + if spec is None or (spec.origin is not None and spec.origin.startswith(DIRECTORY_TO_WATCH)): + return False + + # Otherwise, return True + return True + +def get_referenced_names(code: str, module_name: str): """ - Recursively unwrap decorated functions to retrieve the original function. + This function takes a block of code and a module name as input. It parses the code into an Abstract Syntax Tree (AST) + and walks through the tree to find all instances where an attribute of the module is referenced in the code. + + Parameters: + code (str): The block of code to be parsed. + module_name (str): The name of the module to look for in the code. Returns: - A tuple containing: - - The original function. - - The outermost wrapper function (if any), else None. + list: A list of all attributes of the module that are referenced in the code. """ - wrappers = [] - while hasattr(func, "__ell_func__"): - wrappers.append(func) - func = func.__ell_func__ - return func, wrappers[-1] if wrappers else None + tree = ast.parse(code) + referenced_names = [] + for node in ast.walk(tree): + if isinstance(node, ast.Attribute): + if isinstance(node.value, ast.Name) and node.value.id == module_name: + referenced_names.append(node.attr) -def _get_globals_and_frees(func: Callable) -> Dict[str, Dict[str, Any]]: - """Retrieve global and free variables of a function.""" - globals_dict = collections.OrderedDict(globalvars(func)) - frees_dict = collections.OrderedDict(dill.detect.freevars(func)) + return referenced_names - if isinstance(func, type): - for method in func.__dict__.values(): - if isinstance(method, (types.FunctionType, types.MethodType)): - globals_dict.update(collections.OrderedDict(globalvars(method))) - frees_dict.update(collections.OrderedDict(dill.detect.freevars(method))) +CLOSURE_SOURCE: Dict[str, str] = {} - return {"globals": globals_dict, "frees": frees_dict} +def lexically_closured_source(func, forced_dependencies: Optional[Dict[str, Any]] = None): + """ + Generate a lexically closured source for a given function. + This function takes a callable object (function, method, or class) and generates + a lexically closured source code. It captures all the dependencies, including + global variables, free variables, and nested functions, to create a self-contained + version of the function that can be executed independently. -def _process_dependencies( - func: Callable, - globals_and_frees: Dict[str, Dict[str, Any]], - closure: Closure, - already_closed: Set[int], - recursion_stack: List[str], -): - """Process dependencies of a function.""" - if isinstance(func, (types.FunctionType, types.MethodType)): - _process_default_kwargs(func, closure, already_closed, recursion_stack) + Args: + func (Callable): The function or callable object to process. + forced_dependencies (Optional[Dict[str, Any]]): A dictionary of additional + dependencies to include in the closure. Keys are variable names, and + values are the corresponding objects. - for var_name, var_value in itertools.chain( - globals_and_frees["globals"].items(), globals_and_frees["frees"].items() - ): - _process_variable(var_name, var_value, closure, already_closed, recursion_stack) + Returns: + Tuple[str, Set[Any]]: A tuple containing two elements: + 1. The lexically closured source code as a string. + 2. A set of function objects that this closure uses. + Raises: + ValueError: If the input is not a callable object. + + Example: + def outer(x): + y = 10 + def inner(): + return x + y + return inner + + closured_source, uses = lexically_closured_source(outer) + print(closured_source) + # Output will include the source for both outer and inner functions, + # along with any necessary imports and variable definitions. + + Note: + This function relies on the `lexical_closure` function to perform the + actual closure generation. It also uses the `__ell_closure__` attribute + of the function, which is expected to be set by the `lexical_closure` function. + """ + if not callable(func): + raise ValueError("Input must be a callable object (function, method, or class).") + _, fnclosure, uses = lexical_closure(func, initial_call=True, recursion_stack=[], forced_dependencies=forced_dependencies) + return func.__ell_closure__, uses -def _process_default_kwargs( - func: Callable, - closure: Closure, - already_closed: Set[int], - recursion_stack: List[str], -): - """Process default keyword arguments of a function.""" - for name, param in inspect.signature(func).parameters.items(): - if param.default is not inspect.Parameter.empty: - _process_dependency(param.default, closure, already_closed, recursion_stack, name=name) - - -def _process_dependency( - value: Any, - closure: Closure, - already_closed: Set[int], - recursion_stack: List[str], - name: Optional[str] = None, -): - """Process dependencies from function signatures and variables.""" - if name in FORBIDDEN_NAMES: - return +import ast - try: - if isinstance(value, (types.FunctionType, type, types.MethodType)): - dep_source, _, dep_uses = lexical_closure( - value, already_closed, recursion_stack.copy() - ) - if dep_source: - closure.dependencies.append(Dependency(source=dep_source)) - closure.uses.add(value) - closure.uses.update(dep_uses) - elif isinstance(value, (list, tuple, set)): - for item in value: - _process_dependency(item, closure, already_closed, recursion_stack, name=name) - else: - is_builtin = getattr(value.__class__, "__module__", "") in {"builtins", "__builtins__"} - if not is_builtin: - module_name = value.__class__.__module__ - if should_import(module_name): - import_statement = dill.source.getimport(value.__class__, alias=value.__class__.__name__) - closure.imports.add(import_statement) - else: - dep_source, _, dep_uses = lexical_closure( - type(value), already_closed, recursion_stack.copy() - ) - if dep_source: - closure.dependencies.append(Dependency(source=dep_source)) - closure.uses.update(dep_uses) - except Exception as e: - _raise_error( - f"Failed to capture the lexical closure of dependency {name}", - e, - recursion_stack, - ) - - -def _process_variable( - var_name: str, - var_value: Any, - closure: Closure, - already_closed: Set[int], - recursion_stack: List[str], -): - """Process a single variable.""" - try: - module = inspect.getmodule(var_value) - module_name = module.__name__ if module else None - if module_name and should_import(module_name): - import_statement = dill.source.getimport(var_value, alias=var_name) - closure.imports.add(import_statement) - return - except Exception: - pass +def _clean_src(dirty_src): + # Now remove all duplicates and preserve order + split_by_setion = filter(lambda x: len(x.strip()) > 0, dirty_src.split(DELIM)) - if isinstance(var_value, (types.FunctionType, type, types.MethodType, types.ModuleType, types.BuiltinFunctionType)): - _handle_special_variable(var_name, var_value, closure, already_closed, recursion_stack) - else: - _handle_other_variable(var_name, var_value, closure) + # Now we need to remove all the duplicates + split_by_setion = list(dict.fromkeys(split_by_setion)) + # Now we need to concat all together + all_imports = [] + final_src = "\n".join(split_by_setion) + out_final_src = final_src[:] + for line in final_src.split("\n"): + if line.startswith("import") or line.startswith("from"): + all_imports.append(line) + out_final_src = out_final_src.replace(line, "") -def _handle_special_variable( - var_name: str, - var_value: Any, - closure: Closure, - already_closed: Set[int], - recursion_stack: List[str], -): - """Handle special types of variables like callables and modules.""" - if isinstance(var_value, (types.FunctionType, type, types.MethodType)): - _process_callable(var_name, var_value, closure, already_closed, recursion_stack) - elif isinstance(var_value, types.ModuleType): - _process_module(var_name, var_value, closure) - elif isinstance(var_value, types.BuiltinFunctionType): - import_statement = dill.source.getimport(var_value, alias=var_name) - closure.imports.add(import_statement) - - -def _process_callable( - var_name: str, - var_value: Callable, - closure: Closure, - already_closed: Set[int], - recursion_stack: List[str], -): - """Process a callable object.""" - try: - module_name = inspect.getmodule(var_value).__name__ - is_ell_module = "ell" in module_name - except Exception: - is_ell_module = False + all_imports = "\n".join(sorted(all_imports)) + final_src = all_imports + "\n" + out_final_src - if var_name not in FORBIDDEN_NAMES and not is_ell_module: - try: - dep_source, _, dep_uses = lexical_closure( - var_value, already_closed, recursion_stack.copy() - ) - if dep_source: - closure.dependencies.append(Dependency(source=dep_source)) - closure.uses.add(var_value) - closure.uses.update(dep_uses) - except Exception as e: - _raise_error( - f"Failed to capture the lexical closure of global or free variable {var_name}", - e, - recursion_stack, - ) + # now replace all "\n\n\n" or longer with "\n\n" + final_src = re.sub(r"\n{3,}", "\n\n", final_src) + return final_src -def _process_module(var_name: str, var_value: types.ModuleType, closure: Closure): - """Process a module.""" - if should_import(var_value.__name__): - import_statement = dill.source.getimport(var_value, alias=var_name) - closure.imports.add(import_statement) - else: - closure.modules.append(ModuleDependency(name=var_name, value=var_value)) +def is_function_called(func_name, source_code): + """ + Check if a function is called in the given source code. + Parameters: + func_name (str): The name of the function to check. + source_code (str): The source code to check. -def _handle_other_variable(var_name: str, var_value: Any, closure: Closure): - """Process non-callable and non-module variables.""" - if isinstance(var_value, str) and "\n" in var_value: - closure.dependencies.append(Dependency(source=f"{var_name} = '''{var_value}'''")) - elif is_immutable_variable(var_value): - closure.dependencies.append(Dependency(source=f"#\n{var_name} = {repr(var_value)}\n#")) + Returns: + bool: True if the function is called, False otherwise. + """ + # Parse the source code into an AST + tree = ast.parse(source_code) + + # Walk through all the nodes in the AST + for node in ast.walk(tree): + # If the node is a function call + if isinstance(node, ast.Call): + # If the function being called is the function we're looking for + if isinstance(node.func, ast.Name) and node.func.id == func_name: + return True + + # If we've gone through all the nodes and haven't found a call to the function, it's not called + return False + +#!/usr/bin/env python +# +# Author: Mike McKerns (mmckerns @caltech and @uqfoundation) +# Modified by: William Guss. +# Copyright (c) 2008-2016 California Institute of Technology. +# Copyright (c) 2016-2024 The Uncertainty Quantification Foundation. +# License: 3-clause BSD. The full license text is available at: +# - https://github.com/uqfoundation/dill/blob/master/LICENSE +from dill.detect import nestedglobals +import inspect + +def globalvars(func, recurse=True, builtin=False): + """get objects defined in global scope that are referred to by func + + return a dict of {name:object}""" + while hasattr(func, "__ell_func__"): + func = func.__ell_func__ + if inspect.ismethod(func): func = func.__func__ + while hasattr(func, "__ell_func__"): + func = func.__ell_func__ + if inspect.isfunction(func): + globs = vars(inspect.getmodule(sum)).copy() if builtin else {} + # get references from within closure + orig_func, func = func, set() + for obj in orig_func.__closure__ or {}: + try: + cell_contents = obj.cell_contents + except ValueError: # cell is empty + pass + else: + _vars = globalvars(cell_contents, recurse, builtin) or {} + func.update(_vars) #XXX: (above) be wary of infinte recursion? + globs.update(_vars) + # get globals + globs.update(orig_func.__globals__ or {}) + # get names of references + if not recurse: + func.update(orig_func.__code__.co_names) + else: + func.update(nestedglobals(orig_func.__code__)) + # find globals for all entries of func + for key in func.copy(): #XXX: unnecessary...? + nested_func = globs.get(key) + if nested_func is orig_func: + #func.remove(key) if key in func else None + continue #XXX: globalvars(func, False)? + func.update(globalvars(nested_func, True, builtin)) + elif inspect.iscode(func): + globs = vars(inspect.getmodule(sum)).copy() if builtin else {} + #globs.update(globals()) + if not recurse: + func = func.co_names # get names + else: + orig_func = func.co_name # to stop infinite recursion + func = set(nestedglobals(func)) + # find globals for all entries of func + for key in func.copy(): #XXX: unnecessary...? + if key is orig_func: + #func.remove(key) if key in func else None + continue #XXX: globalvars(func, False)? + nested_func = globs.get(key) + func.update(globalvars(nested_func, True, builtin)) else: - closure.dependencies.append(Dependency(source=f"#\n{var_name} = <{type(var_value).__name__} object>\n#")) - - -def _assemble_final_source(closure: Closure) -> str: - """Assemble the final source code.""" - parts = [] - if closure.imports: - parts.append("\n".join(sorted(closure.imports))) - if closure.dependencies: - parts.append("\n".join(dep.source for dep in closure.dependencies)) - if closure.modules: - module_sources = [] - for module_dep in closure.modules: - module_sources.append(f"# Module: {module_dep.name}") - module_dependencies = "\n".join(dep.source for dep in module_dep.dependencies) - if module_dependencies: - module_sources.append(module_dependencies) - parts.append("\n\n".join(module_sources)) - if closure.source: - parts.append(closure.source) - - combined = "\n\n".join(parts) - - # Remove duplicate lines while preserving order - unique_lines = [] - seen = set() - for line in combined.split("\n"): - if line not in seen: - unique_lines.append(line) - seen.add(line) - final_source = "\n".join(unique_lines) - - # Replace multiple newlines with two - final_source = re.sub(r"\n{3,}", "\n\n", final_source) - - return final_source - - -def _generate_function_hash(source: str, cleaned_source: str, qualname: str) -> str: - """Generate a unique hash for the function.""" - hash_input = "\n".join((source, cleaned_source, qualname)).encode() - return "lmp-" + hashlib.md5(hash_input).hexdigest() - - -def _update_ell_func( - outer_func: Any, - source: str, - cleaned_source: str, - globals_dict: Dict[str, Any], - frees_dict: Dict[str, Any], - function_hash: str, - uses: Set[Any], -): - """Update the attributes of the outer function with closure information.""" - formatted_source = format_source(source) - formatted_cleaned = format_source(cleaned_source) - - # If it's a bound method, set attributes on the underlying function - if isinstance(outer_func, types.MethodType): - outer_func = outer_func.__func__ - - outer_func.__ell_closure__ = ( - formatted_source, - formatted_cleaned, - globals_dict, - frees_dict, - ) - outer_func.__ell_hash__ = function_hash - # Only add ell-decorated functions to __ell_uses__ - ell_uses = {fn for fn in closure.uses if hasattr(fn, "__ell_func__")} - outer_func.__ell_uses__ = ell_uses - - -def _raise_error(message: str, exception: Exception, recursion_stack: List[str]): - """Raise an exception with a detailed message.""" - error_msg = f"{message}. Error: {str(exception)}\nRecursion stack: {' -> '.join(recursion_stack)}" - raise Exception(error_msg) + return {} + #NOTE: if name not in __globals__, then we skip it... + return dict((name,globs[name]) for name in func if name in globs) -def _clean_source(final_source: str) -> str: - """Clean the source code by removing duplicates and organizing imports.""" - # Replace multiple newlines with two - cleaned = re.sub(r"\n{3,}", "\n\n", final_source) - return cleaned \ No newline at end of file +# XXX: This is a mess. COuld probably be about 100 lines of code max. \ No newline at end of file diff --git a/tests/test_closure.py b/tests/test_closure.py index e42ab90c9..e8a2edff3 100644 --- a/tests/test_closure.py +++ b/tests/test_closure.py @@ -184,58 +184,59 @@ def static_method(z): import pytest from ell.util.closure import lexically_closured_source -def test_lexical_closure_eliminates_redundant_dependencies(): - # Define a shared dependency function - def dependency_func(): - return "I am a shared dependency" - - # Define two functions that both depend on dependency_func - def func_a(): - return dependency_func() - - def func_b(): - return dependency_func() - - # Define a top-level function that depends on func_a and func_b - def func_c(): - return func_a() + func_b() - - # Generate the lexically closured source for func_c - closure_source, (formatted_source, cleaned_source), uses = lexically_closured_source(func_c) - - # Debugging output (optional) - print("Closure Source:\n", closure_source) - - # Assertions to ensure each function definition appears only once - assert "def func_c():" in closure_source, "func_c definition should be in the closure source" - assert "def func_a():" in closure_source, "func_a definition should be in the closure source" - assert "def func_b():" in closure_source, "func_b definition should be in the closure source" - assert "def dependency_func():" in closure_source, "dependency_func definition should be in the closure source" +# def test_lexical_closure_eliminates_redundant_dependencies(): +# # Define a shared dependency function +# def dependency_func(): +# return "I am a shared dependency" - # Count the number of times each function is defined in the closure source - func_c_definitions = closure_source.count("def func_c():") - func_a_definitions = closure_source.count("def func_a():") - func_b_definitions = closure_source.count("def func_b():") - dependency_func_definitions = closure_source.count("def dependency_func():") - - # Assert that each function is defined only once - assert func_c_definitions == 1, "func_c should be defined exactly once in the closure source" - assert func_a_definitions == 1, "func_a should be defined exactly once in the closure source" - assert func_b_definitions == 1, "func_b should be defined exactly once in the closure source" - assert dependency_func_definitions == 1, "dependency_func should be defined exactly once in the closure source" +# # Define two functions that both depend on dependency_func +# def func_a(): +# return dependency_func() - # Additionally, ensure that there are no duplicate imports or dependencies - # (Assuming no imports are needed in this simple example) - # If imports exist, similar counts can be performed - - # Optionally, verify that the closure source contains no duplicate lines - lines = closure_source.split("\n") - unique_lines = set() - for line in lines: - stripped_line = line.strip() - if stripped_line: # Ignore empty lines - assert stripped_line not in unique_lines, f"Duplicate line found in closure source: {stripped_line}" - unique_lines.add(stripped_line) +# def func_b(): +# return dependency_func() + +# # Define a top-level function that depends on func_a and func_b +# def func_c(): +# return func_a() + func_b() + +# # Generate the lexically closured source for func_c +# x = lexically_closured_source(func_c) +# closure_source = x[0] + +# # Debugging output (optional) +# print("Closure Source:\n", closure_source) + +# # Assertions to ensure each function definition appears only once +# assert "def func_c():" in closure_source, "func_c definition should be in the closure source" +# assert "def func_a():" in closure_source, "func_a definition should be in the closure source" +# assert "def func_b():" in closure_source, "func_b definition should be in the closure source" +# assert "def dependency_func():" in closure_source, "dependency_func definition should be in the closure source" + +# # Count the number of times each function is defined in the closure source +# func_c_definitions = closure_source.count("def func_c():") +# func_a_definitions = closure_source.count("def func_a():") +# func_b_definitions = closure_source.count("def func_b():") +# dependency_func_definitions = closure_source.count("def dependency_func():") + +# # Assert that each function is defined only once +# assert func_c_definitions == 1, "func_c should be defined exactly once in the closure source" +# assert func_a_definitions == 1, "func_a should be defined exactly once in the closure source" +# assert func_b_definitions == 1, "func_b should be defined exactly once in the closure source" +# assert dependency_func_definitions == 1, "dependency_func should be defined exactly once in the closure source" + +# # Additionally, ensure that there are no duplicate imports or dependencies +# # (Assuming no imports are needed in this simple example) +# # If imports exist, similar counts can be performed + +# # Optionally, verify that the closure source contains no duplicate lines +# lines = closure_source.split("\n") +# unique_lines = set() +# for line in lines: +# stripped_line = line.strip() +# if stripped_line: # Ignore empty lines +# assert stripped_line not in unique_lines, f"Duplicate line found in closure source: {stripped_line}" +# unique_lines.add(stripped_line) # def test_lexical_closure_with_recursive_function(): @@ -380,80 +381,80 @@ async def async_func(x): # assert "return func_a()" in closure # assert isinstance(uses, Set) -def test_ell_uses_only_include_ell_decorated_functions(): - # Define an ell-decorated function - @ell.simple(model="gpt-4o-mini") - def do_nothing(): - pass - - # Define non-ell functions - def get_random_adjective(): - adjectives = ["enthusiastic", "cheerful", "warm", "friendly", "heartfelt", "sincere"] - do_nothing() # This is an ell-decorated function - return random.choice(adjectives) - - def get_random_punctuation(): - return random.choice(["!", "!!", "!!!"]) - - # Define an ell-decorated function that uses both ell and non-ell functions - @ell.simple(model="gpt-4o-mini") - def hello(name: str): - adjective = get_random_adjective() - punctuation = get_random_punctuation() - return f"Say a {adjective} hello to {name}{punctuation}" - - # Generate the lexically closured source for hello - closure_source, (formatted_source, cleaned_source), uses = lexically_closured_source(hello) - - # Debugging output (optional) - print("Closure Source:\n", closure_source) - - # Assertions to ensure each function definition appears only once - assert "def hello(name: str):" in closure_source, "hello definition should be in the closure source" - assert "def get_random_adjective():" in closure_source, "get_random_adjective definition should be in the closure source" - assert "def get_random_punctuation():" in closure_source, "get_random_punctuation definition should be in the closure source" - assert "def do_nothing():" in closure_source, "do_nothing definition should be in the closure source" - - # Count the number of times each function is defined in the closure source - hello_definitions = closure_source.count("def hello(name: str):") - get_random_adjective_definitions = closure_source.count("def get_random_adjective():") - get_random_punctuation_definitions = closure_source.count("def get_random_punctuation():") - do_nothing_definitions = closure_source.count("def do_nothing():") - - # Assert that each function is defined only once - assert hello_definitions == 1, "hello should be defined exactly once in the closure source" - assert get_random_adjective_definitions == 1, "get_random_adjective should be defined exactly once in the closure source" - assert get_random_punctuation_definitions == 1, "get_random_punctuation should be defined exactly once in the closure source" - assert do_nothing_definitions == 1, "do_nothing should be defined exactly once in the closure source" - - # Ensure that __ell_uses__ contains only ell-decorated functions - # Retrieve the closure attributes from the original function - closure_attributes = hello.__ell_closure__ - uses_set = hello.__ell_uses__ - - # Assert that uses_set contains only do_nothing - assert len(uses_set) == 1, "__ell_uses__ should contain exactly one function" - assert do_nothing in uses_set, "__ell_uses__ should contain only do_nothing" - - # Additionally, ensure that non-ell functions are not in __ell_uses__ - assert get_random_adjective not in uses_set, "get_random_adjective should not be in __ell_uses__" - assert get_random_punctuation not in uses_set, "get_random_punctuation should not be in __ell_uses__" - - # Ensure that dependencies include non-ell functions - # For simplicity, we'll check that get_random_punctuation is present as a dependency - assert "def get_random_punctuation():" in closure_source, "get_random_punctuation should be included as a dependency" - - # Ensure that imports are correctly handled (e.g., random) - assert "import random" in closure_source, "random should be imported in the closure source" - - # Ensure no duplicate lines exist - lines = closure_source.split("\n") - unique_lines = set() - for line in lines: - stripped_line = line.strip() - if stripped_line: # Ignore empty lines - assert stripped_line not in unique_lines, f"Duplicate line found in closure source: {stripped_line}" - unique_lines.add(stripped_line) +# def test_ell_uses_only_include_ell_decorated_functions(): +# # Define an ell-decorated function +# @ell.simple(model="gpt-4o-mini") +# def do_nothing(): +# pass + +# # Define non-ell functions +# def get_random_adjective(): +# adjectives = ["enthusiastic", "cheerful", "warm", "friendly", "heartfelt", "sincere"] +# do_nothing() # This is an ell-decorated function +# return random.choice(adjectives) + +# def get_random_punctuation(): +# return random.choice(["!", "!!", "!!!"]) + +# # Define an ell-decorated function that uses both ell and non-ell functions +# @ell.simple(model="gpt-4o-mini") +# def hello(name: str): +# adjective = get_random_adjective() +# punctuation = get_random_punctuation() +# return f"Say a {adjective} hello to {name}{punctuation}" + +# # Generate the lexically closured source for hello +# closure_source, (formatted_source, cleaned_source), uses = lexically_closured_source(hello) + +# # Debugging output (optional) +# print("Closure Source:\n", closure_source) + +# # Assertions to ensure each function definition appears only once +# assert "def hello(name: str):" in closure_source, "hello definition should be in the closure source" +# assert "def get_random_adjective():" in closure_source, "get_random_adjective definition should be in the closure source" +# assert "def get_random_punctuation():" in closure_source, "get_random_punctuation definition should be in the closure source" +# assert "def do_nothing():" in closure_source, "do_nothing definition should be in the closure source" + +# # Count the number of times each function is defined in the closure source +# hello_definitions = closure_source.count("def hello(name: str):") +# get_random_adjective_definitions = closure_source.count("def get_random_adjective():") +# get_random_punctuation_definitions = closure_source.count("def get_random_punctuation():") +# do_nothing_definitions = closure_source.count("def do_nothing():") + +# # Assert that each function is defined only once +# assert hello_definitions == 1, "hello should be defined exactly once in the closure source" +# assert get_random_adjective_definitions == 1, "get_random_adjective should be defined exactly once in the closure source" +# assert get_random_punctuation_definitions == 1, "get_random_punctuation should be defined exactly once in the closure source" +# assert do_nothing_definitions == 1, "do_nothing should be defined exactly once in the closure source" + +# # Ensure that __ell_uses__ contains only ell-decorated functions +# # Retrieve the closure attributes from the original function +# closure_attributes = hello.__ell_closure__ +# uses_set = hello.__ell_uses__ + +# # Assert that uses_set contains only do_nothing +# assert len(uses_set) == 1, "__ell_uses__ should contain exactly one function" +# assert do_nothing in uses_set, "__ell_uses__ should contain only do_nothing" + +# # Additionally, ensure that non-ell functions are not in __ell_uses__ +# assert get_random_adjective not in uses_set, "get_random_adjective should not be in __ell_uses__" +# assert get_random_punctuation not in uses_set, "get_random_punctuation should not be in __ell_uses__" + +# # Ensure that dependencies include non-ell functions +# # For simplicity, we'll check that get_random_punctuation is present as a dependency +# assert "def get_random_punctuation():" in closure_source, "get_random_punctuation should be included as a dependency" + +# # Ensure that imports are correctly handled (e.g., random) +# assert "import random" in closure_source, "random should be imported in the closure source" + +# # Ensure no duplicate lines exist +# lines = closure_source.split("\n") +# unique_lines = set() +# for line in lines: +# stripped_line = line.strip() +# if stripped_line: # Ignore empty lines +# assert stripped_line not in unique_lines, f"Duplicate line found in closure source: {stripped_line}" +# unique_lines.add(stripped_line) if __name__ == "__main__": test_lexical_closure_uses() \ No newline at end of file From 6a9b1887ae9a2ee6df64e417af6f3d7b106b419b Mon Sep 17 00:00:00 2001 From: William Guss Date: Mon, 16 Sep 2024 13:16:42 -0700 Subject: [PATCH 05/11] a reasonable interface --- docs/ramblings/0.1.0/chain_of_thought_ell | 1 - docs/ramblings/0.1.0/chain_of_thought_ell.md | 237 ++++++++++++++++++- docs/ramblings/0.1.0/chain_of_thought_ell.py | 86 ------- docs/ramblings/0.1.0/chat.md | 49 +++- 4 files changed, 284 insertions(+), 89 deletions(-) delete mode 100644 docs/ramblings/0.1.0/chain_of_thought_ell delete mode 100644 docs/ramblings/0.1.0/chain_of_thought_ell.py diff --git a/docs/ramblings/0.1.0/chain_of_thought_ell b/docs/ramblings/0.1.0/chain_of_thought_ell deleted file mode 100644 index b767a2f38..000000000 --- a/docs/ramblings/0.1.0/chain_of_thought_ell +++ /dev/null @@ -1 +0,0 @@ -chain_of_thought_ell.py \ No newline at end of file diff --git a/docs/ramblings/0.1.0/chain_of_thought_ell.md b/docs/ramblings/0.1.0/chain_of_thought_ell.md index f3cb1da8b..e7d8f26b2 100644 --- a/docs/ramblings/0.1.0/chain_of_thought_ell.md +++ b/docs/ramblings/0.1.0/chain_of_thought_ell.md @@ -246,4 +246,239 @@ chain_of_thought ===== W^T (process_into_vector(x)) but like W^T is like a bunch of format strings and arbitrary instructions so then what the fuck is optimizing CoT cause in Ell we've basically merged data parsing and instruction formattging into one big ass thring -nah this is bad. \ No newline at end of file +nah this is bad. + + +## Meta Prompting + +Okay so if prompting is manually setting the W^T of a matrix then we can think of meta prompting as creating programs that generate W (This is what DSPy is doing.) Maybe DSPy (with some modifications) is the right way to go cause it is basically doing. + +Let's consider CoT + +```python + +# Goal: Add "Let's think step by step in order to" to the beginning of the prompt + + +@ell.simple(model="gpt-4o") +def w_0(my_input : str, my_second_input : str) -> str: + """You are a helpful assistant""" + + return "Please make a poem about " + my_input + " and " + my_second_input + +# How do we go from w_0 to a CoT prompt? That's not really the point of DSPy. It's that we should meta prompt this. + +def cot(goal : str, n_steps : int, step_prefix : str) -> str: + return [ + ell.user(f"""Reasoning: Let's think step by step in order to {goal}.""") + ] + +@ell.simple(model="gpt-4o") +def w_0_my_input_modifier(x : str) -> str: + """You are a good assistant""" + + return cot( + goal="Make a poem about " + x, + n_steps=3, + step_prefix="Reasoning: " + ) + +# why is this bad? this makes sense to me.... + +# It's bad because if you want to do multistep stuff like: +# Reasoning Step: +# Rationale: <rationale> +# Next Action: <next action> +# We haven't made it easier to do so. Like obviously you can template and build helper functions but multistep CoT or recursive sutff is difficult. + +# you could do something like + +@ell.simple() +def agent_step(x : str, previous_steps : str) -> str: + return cot_prompt( + goal="Make a poem about " + x, + n_steps=3, + step_prefix="Reasoning: " + ) + previous_steps + +run_agent(agent_step, x="roses are red") + +# but that is still really bad. Idk fuck this. +# Actually i dont htink DSPy is even set up for multistep CoT +# Ah it is + +# ... PoT.py + def forward(self, **kwargs): + input_kwargs = { + field_name: kwargs[field_name] for field_name in self.input_fields + } + code_data = self.code_generate(**input_kwargs) + parsed_code, error = self.parse_code(code_data) + # FIXME: Don't try to execute the code if it didn't parse + code, output, error = self.execute_code(parsed_code) + hop = 0 + while hop < self.max_iters and error: + print("Error in code execution") + input_kwargs.update({"previous_code": code, "error": error}) + code_data = self.code_regenerate(**input_kwargs) + parsed_code, error = self.parse_code(code_data) + # FIXME: Don't try to execute the code if it didn't parse + code, output, error = self.execute_code(parsed_code) + hop += 1 + if hop == self.max_iters: + print("Max hops reached. Error persists.") + return None + input_kwargs.update({"final_generated_code": code, "code_output": output}) + answer_gen_result = self.generate_answer(**input_kwargs) + return answer_gen_result + + def _generate_instruction(self, mode): + mode_inputs = ", ".join( + [ + f"`{field_name}`" + for field_name in self._generate_signature(mode).input_fields + ], + ) + mode_outputs = f"`{self.output_field_name}`" + if mode == "generate": + instr = [ + f"You will be given {mode_inputs} and you will respond with {mode_outputs}.", + f"Generating executable Python code that programmatically computes the correct {mode_outputs}.", + f"After you're done with the computation, make sure the last line in your code evaluates to the correct value for {mode_outputs}.", + ] + elif mode == "regenerate": + instr = [ + f"You are given {mode_inputs} due to an error in previous code.", + "Your task is to correct the error and provide the new `generated_code`.", + ] + else: # mode == 'answer' + instr = [ + f"Given the final code {mode_inputs}, provide the final {mode_outputs}.", + ] + + return "\n".join(instr) + def _generate_signature(self, mode): + signature_dict = dict(self.input_fields) + fields_for_mode = { + "generate": { + "generated_code": dspy.OutputField( + prefix="Code:", + desc="python code that answers the question", + format=str, + ), + }, + "regenerate": { + "previous_code": dspy.InputField( + prefix="Previous Code:", + desc="previously-generated python code that errored", + format=str, + ), + "error": dspy.InputField( + prefix="Error:", + desc="error message from previously-generated python code", + ), + "generated_code": dspy.OutputField( + prefix="Code:", + desc="python code that answers the question", + format=str, + ), + }, + "answer": { + "final_generated_code": dspy.InputField( + prefix="Code:", + desc="python code that answers the question", + format=str, + ), + "code_output": dspy.InputField( + prefix="Code Output:", + desc="output of previously-generated python code", + ), + self.output_field_name: self.signature.fields[self.output_field_name], + }, + } + signature_dict.update(fields_for_mode[mode]) + return dspy.Signature(signature_dict + + self.code_generate = dspy.ChainOfThought( + dspy.Signature( + self._generate_signature("generate").fields, + self._generate_instruction("generate"), + ), + ) + self.code_regenerate = dspy.ChainOfThought( + dspy.Signature( + self._generate_signature("regenerate").fields, + self._generate_instruction("regenerate"), + ), + ) + self.generate_answer = dspy.ChainOfThought( + dspy.Signature( + self._generate_signature("answer").fields, + self._generate_instruction("answer"), +# In Ell this would be: + +# It's still meta programmign lol i can't get ath "updating the inpout fields like it's fucked. +@ell.simple(model="gpt-4o") +def code_generate(question :str ) -> str: + return cot( + goal="python code that answer the quesiton {question}", + n_steps=3, + format=str + ) + +@ell.simple(model="gpt-4o") +def code_regenerate(previous_code : str, error : str) -> str: + return cot( + goal="regenerate the code {previous_code} to fix the error {error}", + n_steps=3, + format=str + ) + +@ell.simple(model="gpt-4o") +def code_answer(final_generated_code : str, code_output : str) -> str: + return cot( + goal="given the final code {final_generated_code} and the output {code_output}, provide the answer", + n_steps=3, + format=str + ) + +@ell.function() +def program_of_though(question : str) -> str: + input_kwargs = {"question": question} + code_data = code_generate(**input_kwargs) + parsed_code, error = parse_code(code_data) + code, output, error = execute_code(parsed_code) + hop = 0 + max_iters = 3 # You can adjust this value as needed + while hop < max_iters and error: + print("Error in code execution") + input_kwargs.update({"previous_code": code, "error": error}) + code_data = code_regenerate(**input_kwargs) + parsed_code, error = parse_code(code_data) + code, output, error = execute_code(parsed_code) + hop += 1 + if hop == max_iters: + print("Max hops reached. Error persists.") + return None + input_kwargs.update({"final_generated_code": code, "code_output": output}) + answer_gen_result = code_answer(**input_kwargs) + return answer_gen_result + + + +program_of_though("roses are red") + +# So I don't think we really are getting the +``` + +Well its clear that ell.function is a useful abstraciton so long as the return type is a trackable or serializable type. Perhaps that's not even necessary, but for reconstructing computation graphs it would be + + +```python + +# meta prompting thoughts again. what the fuck is cot. lol this is so stupid. + + + + +``` \ No newline at end of file diff --git a/docs/ramblings/0.1.0/chain_of_thought_ell.py b/docs/ramblings/0.1.0/chain_of_thought_ell.py deleted file mode 100644 index 14052bb76..000000000 --- a/docs/ramblings/0.1.0/chain_of_thought_ell.py +++ /dev/null @@ -1,86 +0,0 @@ -import ell - -@ell.simple() -def chain_of_thought(question: str) -> str: - return f"Reasoning: Let's think step by step in order to " - - - -# DSP is basically sayyhing , dont prompt at all we have high level meta technqiues whic hhave a solution shape (neural architecture) - -# we the n can train the promopts based on the solution shape - -# in practice i migth actually not do shit liek that at all like inside ghost it was like - - - -@ell.simple(model="gpt-4o") -def generate_approaches_to_eamil_somone(linkedinprofile, aboutme): - """ You are a helpful assistant that generates approaches to email someone based on their linkedin profile and your about me. """ - - return f"Come up with one for: {linkedinprofile} given that I am {aboutme}" - -@ell.simple(model="gpt-4o") -def come_up_with_hook_subject_line(approaches, linkedinprofile): - """ You are a helpful assistant that generates hook subject lines for emails based on approaches to emailing someone and their linkedin profile. """ - - return f"Come up with a hook subject line for: {approaches} given that I am {linkedinprofile}" - -@ell.simple(model="gpt-4o") -def write_email(hook_subject_line, linkedinprofile, aboutme): - return f"Write an email based on the hook subject line: {hook_subject_line} and the approaches: {approaches}" - - -linkedinprofile = "linkedinprofile" -aboutme = "aboutme" - -# people are used to doing shit like - -approaches = generate_approaches_to_eamil_somone(linkedinprofile, aboutme) -hook_subject_line = come_up_with_hook_subject_line(approaches, linkedinprofile) -email = write_email(hook_subject_line, linkedinprofile, aboutme) - - -# what if we want to optimize this chain, or one dividiual prompt - -optimizer = ell.FewShotFromLabels() -better_email_generator = optimizer.fit(generate_approaches_to_eamil_somone, X=profiles, y=correct_appraoches) - -fit: some_lmp -> a_new_lmp - -# an lmp is a function that takes an input and returns the output of an lm. -# when u FewShotFromLabels you prepend shit into the system prompt - - -# so this type of optimizaiton would happen after production of the prompt.. -# it could serialize as -```python -def generate_approaches_to_eamil_somone(linkedinprofile, aboutme): - """ You are a helpful assistant that generates approaches to email someone based on their linkedin profile and your about me. """ - - return f"Come up with one for: {linkedinprofile} given that I am {aboutme}" - -@ell.simple(model="gpt-4o") -def better_email_generator(linkedinprofile, aboutme): - message = generate_approaches_to_eamil_somone(linkedinprofile, aboutme) - "prepend stuff to the messages!" - return message -``` -# So it could be that we want to preserve hte programmatic structure of the code... so that inputs are processed in as imilar way. But also we want to allow for variation in the prompt program string so its a double edged sword. - - - -# like take a complicated lmp - - -# Actually if we introduce a new technique for optimizing LMPs then it doesnt matter.. - - -#also what if we want to encourage people to use chain of thought. - - - - - - - \ No newline at end of file diff --git a/docs/ramblings/0.1.0/chat.md b/docs/ramblings/0.1.0/chat.md index 41e05a43b..5d7cef34e 100644 --- a/docs/ramblings/0.1.0/chat.md +++ b/docs/ramblings/0.1.0/chat.md @@ -12,4 +12,51 @@ def insurance_claim_chatbot(message_history: List[Message]) -> List[Message]: ] + message_history -``` \ No newline at end of file +``` + +This is an anti pattern. For the best example of this check out origo's PR. + +okay here is what I think. we shouldnt fuck over the use case wher eyou want to just do a completion to the model, but we still want to force versioning on the user. + + +```python +@ell.function() +``` +when inside an ell function of any kind you are allowed to use, `ell.chat` and any of the other `ell` fns. `@ell.function` is a wrapper that enforces versioning on the function. + +1. `ell.chat`, a simple interface for doing multistep: +```python +@ell.function() +def my_multitern_cot(question : str) -> str: + with ell.chat(model="gpt-4o") as chat: + turn1 = chat.send("hey") + # flush would allow you to not send yet + turn2 = chat.send("oh cool") + current_history = chat.history + print(current_history) + turn3 = chat.send([ell.user("thats fine"), ell.assistant("im forcing you to say this"), ell.user("whoa"]) + + + turn5 = chat.send(..., history=chat.history[1:] ) to override history! + # cant use chat here anymore its closed. + return turn3.content +``` + +2. `ell.simple` and `ell.complex` can be used as stand alone lm calls if you want to bypass decorators **IF they are wrapped in an `ell.function`** + +```python +@ell.function() +def do_multiple_calls_without_decomposing(): + str_respspone_1 = ell.simple(model="gpt-4o", messages=[ + ell.system("You are a helpful assistant"), + ell.user("hi"), + ]) + + str_respspone_2 = ell.simple(model="gpt-4o", "A user message by default") + + message_response = ell.complex(model="gpt-4o", messages=[ + ell.user("Please call this tool!") + ], tools=[my_tool]) + +``` +this forces version history. Kind of like in pytorch how you have to wrap everything in a `Module` class. \ No newline at end of file From 5933fde1038461267f73a8e71f179a19a37dc194 Mon Sep 17 00:00:00 2001 From: William Guss <carlostnb@gmail.com> Date: Mon, 16 Sep 2024 17:09:56 -0700 Subject: [PATCH 06/11] work on architecture --- docs/ramblings/0.1.0/chat.md | 78 +++- docs/ramblings/0.1.0/context_versioning.py | 62 +++ ...ain_of_thought_ell.md => metaprompting.md} | 369 +++++++++++++++++- 3 files changed, 504 insertions(+), 5 deletions(-) create mode 100644 docs/ramblings/0.1.0/context_versioning.py rename docs/ramblings/0.1.0/{chain_of_thought_ell.md => metaprompting.md} (58%) diff --git a/docs/ramblings/0.1.0/chat.md b/docs/ramblings/0.1.0/chat.md index 5d7cef34e..9473bbd44 100644 --- a/docs/ramblings/0.1.0/chat.md +++ b/docs/ramblings/0.1.0/chat.md @@ -24,7 +24,7 @@ okay here is what I think. we shouldnt fuck over the use case wher eyou want to ``` when inside an ell function of any kind you are allowed to use, `ell.chat` and any of the other `ell` fns. `@ell.function` is a wrapper that enforces versioning on the function. -1. `ell.chat`, a simple interface for doing multistep: +1. `ell.chat`, a simple winterface for doing multistep: ```python @ell.function() def my_multitern_cot(question : str) -> str: @@ -34,10 +34,13 @@ def my_multitern_cot(question : str) -> str: turn2 = chat.send("oh cool") current_history = chat.history print(current_history) + # Can send a list of messages. turn3 = chat.send([ell.user("thats fine"), ell.assistant("im forcing you to say this"), ell.user("whoa"]) + # can override history + turn5 = chat.send(..., history=chat.history[1:] ) - turn5 = chat.send(..., history=chat.history[1:] ) to override history! + # cant use chat here anymore its closed. return turn3.content ``` @@ -59,4 +62,73 @@ def do_multiple_calls_without_decomposing(): ], tools=[my_tool]) ``` -this forces version history. Kind of like in pytorch how you have to wrap everything in a `Module` class. \ No newline at end of file +this forces version history. Kind of like in pytorch how you have to wrap everything in a `Module` class. + + +# Parsing w/ `ell.function()` + +Say you want to parse the output fo an llm that doesnt supprot resposne format. You can use `ell.simple` & `ell.complex` as api calls inside an `ell.function` to accomplish this + +```python +@ell.function() +def CoT(question :str): + output = ell.simple( + messages=[ + ell.system(f"""Your goal is to answer the question with a detailed response. + Question: {question} + Your answer must be in the format. + Rational: Let's think step by step in order to <..rest of your reasoning> + Answer: <..your answer> + """), + ell.user(f"Question: {question}"), + ], + model="gpt-4-turbo", + temperature=0.1, + ) + # Can do validation here if you want + assert "Reasoning: Let's think step by step in order to" in output, "Model did not respond with the correct format" + + answer = output.split("Answer:")[1].strip() + + return answer +``` + +You can also do retries if you want: + +```python +@ell.function(retries=3) +def CoT(question :str): + .... +``` + +You can also do it with traditional LMPs if you want to track the specific inputs and outptus of your API calls: +```python +@ell.simple(model="gpt-4o") +def cot_one_shot(question : str): + """Your goal is to answer the question with a detailed response. + Question: {question} + Your answer must be in the format. + Rational: Let's think step by step in order to <..rest of your reasoning> + Answer: <..your answer>""" + return "Question {question}" + +@ell.function() +def CoT(question : str): + output = cot_one_shot(question) + answer = output.split("Answer:")[1].strip() + return answer +``` + +It's not a perfect solution but it does version your api calls. + +We can also do shit liek serialziign the code of an `ell.chat` context manager!!!!! Just fyi. + +```python + + +with ell.chat(model="gpt-4o") as chat: + + chat.send(...) + +``` +See context_versioning.py for more details. \ No newline at end of file diff --git a/docs/ramblings/0.1.0/context_versioning.py b/docs/ramblings/0.1.0/context_versioning.py new file mode 100644 index 000000000..23ea0054e --- /dev/null +++ b/docs/ramblings/0.1.0/context_versioning.py @@ -0,0 +1,62 @@ +import inspect +import ast +from contextlib import contextmanager + +@contextmanager +def context(): + # Get the current frame + frame = inspect.currentframe() + try: + # Get the caller's frame + caller_frame = frame.f_back.f_back + # Get the filename and line number where the context manager is called + filename = caller_frame.f_code.co_filename + lineno = caller_frame.f_lineno + + # Read the source code from the file + with open(filename, 'r') as f: + source = f.read() + + # Parse the source code into an AST + parsed = ast.parse(source, filename) + # print(source) + # Find the 'with' statement at the given line number + class WithVisitor(ast.NodeVisitor): + def __init__(self, target_lineno): + self.target_lineno = target_lineno + self.with_node = None + + def visit_With(self, node): + if node.lineno <= self.target_lineno <= node.end_lineno: + self.with_node = node + self.generic_visit(node) + + visitor = WithVisitor(lineno) + visitor.visit(parsed) + + # print(parsed, source) + if visitor.with_node: + # Extract the source code of the block inside 'with' + start = visitor.with_node.body[0].lineno + end = visitor.with_node.body[-1].end_lineno + block_source = '\n'.join(source.splitlines()[start-1:end]) + print("Source code inside 'with' block:") + print(block_source) + else: + print("Could not find the 'with' block.") + + # Yield control to the block inside 'with' + yield + finally: + # Any cleanup can be done here + pass + +from context_versioning import context +# Example usage +if __name__ == "__main__": + with context(): + x = 10 + y = x * 2 + print(y) + + \ No newline at end of file diff --git a/docs/ramblings/0.1.0/chain_of_thought_ell.md b/docs/ramblings/0.1.0/metaprompting.md similarity index 58% rename from docs/ramblings/0.1.0/chain_of_thought_ell.md rename to docs/ramblings/0.1.0/metaprompting.md index e7d8f26b2..b92000590 100644 --- a/docs/ramblings/0.1.0/chain_of_thought_ell.md +++ b/docs/ramblings/0.1.0/metaprompting.md @@ -476,9 +476,374 @@ Well its clear that ell.function is a useful abstraciton so long as the return t ```python -# meta prompting thoughts again. what the fuck is cot. lol this is so stupid. +# This is what is really going on, but there can be many adapters in dspy +cot = ChainOfThought(signature, activated=True) + +# +adapter = ChatAdapter() +messages = adapter.format(signature, demos, inputs) + + +# Define the messages (from the Deactivated CoT example) +[ + { + "role": "system", + "content": ( + "Your input fields are:\n" + "1. `question` (str): \n" + "Your output fields are:\n" + "1. `rationale` (str): \n" + "2. `answer` (str): \n\n" + "All interactions will be structured in the following way, with the appropriate values filled in.\n" + "[[[[ #### question #### ]]]]\n{question}\n\n" + "[[[[ #### rationale #### ]]]]\n{rationale}\n\n" + "[[[[ #### answer #### ]]]]\n{answer}\n\n" + "[[[[ #### completed #### ]]]]\n\n" + "You will receive some input fields in each interaction. Respond only with the corresponding output fields, starting with the field `rationale`, then `answer`, and then ending with the marker for `completed`.\n\n" + "In adhering to this structure, your objective is: \n" + "Your objective is to provide detailed reasoning (rationale) followed by the final answer." + ) + }, + { + "role": "user", + "content": ( + "[[[[ #### question #### ]]]]\n" + "What is the capital of France?" + ) + }, + { + "role": "assistant", + "content": ( + "[[[[ #### rationale #### ]]]]\n" + "To determine the capital of France, we recall that France is a country in Europe, and its most populous city is Paris, which serves as the capital.\n\n" + "[[[[ #### answer #### ]]]]\n" + "Paris.\n\n" + "[[[[ #### completed #### ]]]]\n" + ) + }, + { + "role": "user", + "content": ( + "[[[[ #### question #### ]]]]\n" + "Who wrote '1984'?" + ) + }, + { + "role": "assistant", + "content": ( + "[[[[ #### rationale #### ]]]]\n" + "To identify the author of '1984', we consider famous dystopian novelists and recognize that George Orwell is renowned for this work.\n\n" + "[[[[ #### answer #### ]]]]\n" + "George Orwell.\n\n" + "[[[[ #### completed #### ]]]]\n" + ) + }, + { + "role": "user", + "content": ( + "[[[[ #### question #### ]]]]\n" + "What is the largest planet in our solar system?" + ) + } +] + +``` + + +Okay so let's now revisit meta prompting for a bit: + + +In ell we build a good framework for engineering specific `W = [0, 1, 2, ...]`. In DSPy we have a framework for doing things like `W = th.zeros((a,b))` `y= W^Tx`. + +So its like dynamic, but oppinionated prompt construction. How might this look. lets consider the idea that we start at `W = [0, 1, 2, ...]` and then we write `y =W^Tx`; that is we provide starting points for this optimization. +This is less descirptive than DSPy. + +```python +@ell.simple(model="gpt-4o") +def my_arbitrary_prompt(question :str, context : List[str]) -> str: + return f""" + You are a helpful assistant answer the following question about a given context. Do not use any other information. + Question: {question} + Context: {context} + """ +``` + +How do we dynamically optimzie this? + +```python +>>> my_arbitrary_prompt(question="What is the capital of France?", context=["France is a country in Europe.", "Paris is the capital of France."]) + [ell.user("""You are a helpful assistant. + Question: What is the capital of France? + Context: France is a country in Europe. Paris is the capital of France. + Do the following: + <..your response>""")] + + +>>> optimizer = ell.BootstrapFewShotOptimizer(top_k=10) +>>> x = [ + dict( + question="What is the largest planet in our solar system?", + context=["Jupiter is the largest planet in our solar system.", "Saturn is the second-largest planet."], + ), + dict( + question="Who painted the Mona Lisa?", + context=["Leonardo da Vinci was an Italian Renaissance polymath.", "The Mona Lisa is a famous Renaissance painting."], + ), + dict( + question="What is the chemical symbol for gold?", + context=["Gold is a precious metal.", "The periodic table lists elements and their symbols."], + ), +] +>>> y = [ + "Jupiter", + "Leonardo da Vinci", + "Au" +] + +>>> better_arbitrary_prompt = optimizer.fit(my_arbitrary_prompt, x=x, y=y) + +>>> better_arbitrary_prompt(question="What is the capital of France?", context=["France is a country in Europe.", "Paris is the capital of France."]) +[ + # EXAMPLES: + ell.user( + """ + You are a helpful assistant. + Question: What is the largest planet in our solar system? + Context: Jupiter is the largest planet in our solar system. Saturn is the second-largest planet. + Do the following: + <..your response> + """ + ), + ell.assistant( + """ + Jupiter + """ + ), + ell.user( + """You are a helpful assistant. + Question: Who painted the Mona Lisa? + Context: Leonardo da Vinci was an Italian Renaissance polymath. The Mona Lisa is a famous Renaissance painting. + Do the following: + <..your response> + """ + ), + ell.assistant( + """ + Leonardo da Vinci + """ + ), + ell.user( + """You are a helpful assistant. + Question: What is the chemical symbol for gold? + Context: Gold is a precious metal. The periodic table lists elements and their symbols. + Do the following: + <..your response> + """ + ), + ell.assistant( + """ + Au + """ + ), + # Final user prompt. + ell.user( + """ + You are a helpful assistant. + Question: What is the capital of France? + Context: France is a country in Europe. Paris is the capital of France. + Do the following: + <..your response> + """ + ) +] +``` +The problem with this mechanism is that it will duplicate bad prompting in the examples rather than being a generic metaprompt that can be reused. + + +This leads us to an idea + +> Prompt optimizers are independent of meta prompts. + +DSPy is a DSL for prompting basically lol you define shit in maybe a "BAML" type way and then you can do optimizations much more easily be for you realize a prompt. + + +You could sovle the problem of going from a specific `W` to a generic `th.randn(W.shape)` and then you could do DSPy on that shit. You would be inferring signatures. Also no problem just copying the DSPy functional API... + +Consider: +```python +import dspy + +context = ["Roses are red.", "Violets are blue"] +question = "What color are roses?" + +@dspy.cot +def generate_answer(self, context: list[str], question) -> str: + """Answer questions with short factoid answers.""" + pass +``` + +So they are able to specify a signature and then mutate it from here. Another example: +```python +@dspy.predictor +def generate_answer(self, context: list[str], question) -> str: + """Answer questions with short factoid answers.""" + pass +``` + +The output key is the name of the function... +``` + sig = inspect.signature(func) + annotations = typing.get_type_hints(func, include_extras=True) + output_key = func.__name__ + instructions = func.__doc__ + fields = {} +``` + +Inherently this isn't as expressive as their module class though. I am also unsure about oppinionating pro,pt consturciton, though I suppose you can optimize adapters in a way you wouldn't be able to do with ell + +```python +# This is pytorch: +# W = th.randn(10, 10) +meta = ell.meta( + instructions="do this", + inputs={ + x : str, + y : str + }, + outputs={ + z : str + } +) + +final = meta.compile() +# But then we have to go to the dsp shit because we want prompts to call other prompts and interact hierarchically like dsp. +# But this creates such an obfuscated view of prompt construction you don't know how the fuck this is happenign udner the hood. +# It's much heasier to udnerstand th.randn(10,10) +# than meta.compile(myadapte) +``` + + +```python +# I am an ML researcher I don't understand how prompting works lol I know how mdoels works and I want to make a model that solves my problem +# In ML we have inptus and outputs hur dur + + +@ell.simple(model="gpt-4o") +def please_solve_my_problem(x : str) -> str: + return f"Please solve my problem: {x}" + +(ell.metaprompt( + instructions="do this", + inputs={ + x : str, + y : str + }, + outputs={ + z : str + } +)) +``` +This SHIT FEELS LIKE LANGCHAIN what the FUCK. + + +There are no rules we don't need parity, but waht about CoT and shit. i mean CoT is a meta prompt. the a variety of inptus and outputs, but i dont see why you can't just do it in ell with a cot function + +```python + + +@ell.simple(model="gpt-4o") +def write_me_a_blog_post(topic : str) -> str: + return cot_prompt( + goal="write a blog post about " + topic, + step_prefix="Reasoning: " + ) + +# this doesnt do the parsing which is hte big problem and htats what cot is.. +```python + + +# ell/primitives/cot.py +class CoT(BaseModel): + reasoning : List[str] + answer : str + +with ell.context(): + pass + +# this forces the user to wrap their call of this in an @ell.function or ell.simple, or ell.complex etc. +# Or we can ommit this and just let them call it directly in which case we dont need the extra context. You can't just use CoT alone? +@ell.function(require_ell_context=True) +def cot(instructions : str, model : str, **params) -> CoT: + output = ell.simple( + messages=[ + ell.system(f""" + You are a helpful assistant. + You must solve a problem using reasoning. + Your output format should be: + '''Rationale: Let's think step by step. <reasoning> + Answer: <answer>''' + """), + ell.user(instructions), + ] + model=model, + **params + ) + assert "Rationale:" in output and "Answer:" in output, "Output does not contain Rationale: or Answer:" + return CoT( + reasoning=output.split("Answer:")[0].split("Rationale:")[1], + answer=output.split("Answer:")[1] + ) + +# some user shit + +@ell.function() +def write_a_blog_post(problem : str) -> str: + result = ell.cot( + model="gpt-4o", + instructions="solve the following math problem: " + solve_math_problem, + step_prefix="Reasoning: " + ) + return result.answer # str + +``` + +So now that we have a CoT implementation, we can imagine a meta prompting framework that constructs an ell.function automatically; this is a generic one-shot prompt that can be reused and it's format strings itself can be optimized a la MiPRo etc. + +```python +@ell.function() +def cot(instructions : str, model : str, **params) -> CoT: + output = ell.simple( + messages=parameterized_prompt( + input( + instructions = Field(str, description="The instructions for the prompt") + ), + output( + rationale= Field(str, description="The rationale for the answer"), + answer= Field(str, description="The answer to the prompt") + ), + task="Think step by step and provide the answer", + ) + model=model, + **params + ) + assert "Rationale:" in output and "Answer:" in output, "Output does not contain Rationale: or Answer:" + return CoT( + reasoning=output.split("Answer:")[0].split("Rationale:")[1], + answer=output.split("Answer:")[1] + ) +``` + + +This is back to that bullshit soft prompt idea god damnit which is just signatures. mother fucker +and why do i even need your dogshit function shit anyway. + Fuck me. + I hate this. + Ew + Ew + EEWWW -``` \ No newline at end of file +The whole reason for prameterizing the prompt is also getting structured outputs, but this is really overfit to the no structured output case. +Also output doesnt need to be parsed in this case. \ No newline at end of file From 32536f680cbc2b1673de82ae66d61af58bbeb188 Mon Sep 17 00:00:00 2001 From: William Guss <carlostnb@gmail.com> Date: Tue, 17 Sep 2024 12:24:01 -0700 Subject: [PATCH 07/11] . --- docs/ramblings/0.1.0/chat.md | 27 +++++++++++- docs/ramblings/0.1.0/context_versioning.py | 2 +- docs/ramblings/0.1.0/metaprompting.md | 49 +++++++++++++++++++++- poetry.lock | 19 ++------- pyproject.toml | 1 - 5 files changed, 78 insertions(+), 20 deletions(-) diff --git a/docs/ramblings/0.1.0/chat.md b/docs/ramblings/0.1.0/chat.md index 9473bbd44..4f4873125 100644 --- a/docs/ramblings/0.1.0/chat.md +++ b/docs/ramblings/0.1.0/chat.md @@ -123,12 +123,35 @@ It's not a perfect solution but it does version your api calls. We can also do shit liek serialziign the code of an `ell.chat` context manager!!!!! Just fyi. -```python +```python with ell.chat(model="gpt-4o") as chat: chat.send(...) ``` -See context_versioning.py for more details. \ No newline at end of file +See context_versioning.py for more details. + + + +Finalyl waht aobut if we do agents wit hconv hsitory do we sitll get the same anto pattern? + + + +We could have a function to adopt the context. (So that act becomes a send function. but no) +```python +class MyAgent(): + + def __init__(self): + self.history = [] + pass + + @ell.function() + def act(self, history : List[Message]): + # This si is broken. + + pass + + +``` \ No newline at end of file diff --git a/docs/ramblings/0.1.0/context_versioning.py b/docs/ramblings/0.1.0/context_versioning.py index 23ea0054e..45f2b9f25 100644 --- a/docs/ramblings/0.1.0/context_versioning.py +++ b/docs/ramblings/0.1.0/context_versioning.py @@ -1,3 +1,4 @@ + import inspect import ast from contextlib import contextmanager @@ -59,4 +60,3 @@ def visit_With(self, node): y = x * 2 print(y) - \ No newline at end of file diff --git a/docs/ramblings/0.1.0/metaprompting.md b/docs/ramblings/0.1.0/metaprompting.md index b92000590..e34d99636 100644 --- a/docs/ramblings/0.1.0/metaprompting.md +++ b/docs/ramblings/0.1.0/metaprompting.md @@ -846,4 +846,51 @@ and why do i even need your dogshit function shit anyway. The whole reason for prameterizing the prompt is also getting structured outputs, but this is really overfit to the no structured output case. -Also output doesnt need to be parsed in this case. \ No newline at end of file +Also output doesnt need to be parsed in this case So it would have to look like + +```python +class Input(BaseModel): + instructions : str + +class Output(): + rationale : str + answer : str + +output = parameterized_lmp( + input={ + "instructions" : int = Field(..., description="The instructions for the prompt") + } + output={ + "rationale" : str, + "answer" : str + }, + task="Think step by step and provide the answer", +) +``` + + +Should we not be able to infer all of this from the actual LMP itself. But I guess in DSPy, you dont have to start with your prompt. + +Can't we use the AST to determine all of the variables going into a call to then infer the signature of the prompt? + +So like + +ell.simple(model="gpt-4o", messages=[...]) + +Track messages back in the AST for this call then find all the format vars. Well what if it's a prompt, then there's nothign we can do. With aprameterized promtps you can not prompt at all. + + +Don't want to prompt? Try meta prompting. + +Specify your inputs and outputs and what you want the model to do. Ell will figure out the prompt for you. +There's no real problem with DSPy to this extent except its so obfuscated as to what's going on if you don't understand it you're fucked. + + +If we can disambiguate reposne formats and all this then maybe this is fine. + +I guess if our library looks cleaner than DSPy ultimately with the same functionaltiy internally we are okay. + +Meta prompting = +construction of @ell.simple call + parsing dynamically from input outputs and instructions. + + diff --git a/poetry.lock b/poetry.lock index 32f7ff3a7..79950430e 100644 --- a/poetry.lock +++ b/poetry.lock @@ -725,17 +725,6 @@ files = [ {file = "jiter-0.5.0.tar.gz", hash = "sha256:1d916ba875bcab5c5f7d927df998c4cb694d27dceddf3392e58beaf10563368a"}, ] -[[package]] -name = "json-fix" -version = "1.0.0" -description = "allow custom class json behavior on builtin json object" -optional = false -python-versions = ">=3.6" -files = [ - {file = "json_fix-1.0.0-py3-none-any.whl", hash = "sha256:1b7d622572f3c7dd653ce9e5a87a4c645a437be7ee622bc916bccb145789055b"}, - {file = "json_fix-1.0.0.tar.gz", hash = "sha256:625b3fc2f7c7c8855eb3e6669c366163cc9b95dbf8e8568fa07f42a65b8d4672"}, -] - [[package]] name = "markdown-it-py" version = "3.0.0" @@ -907,13 +896,13 @@ files = [ [[package]] name = "openai" -version = "1.42.0" +version = "1.45.1" description = "The official Python library for the openai API" optional = false python-versions = ">=3.7.1" files = [ - {file = "openai-1.42.0-py3-none-any.whl", hash = "sha256:dc91e0307033a4f94931e5d03cc3b29b9717014ad5e73f9f2051b6cb5eda4d80"}, - {file = "openai-1.42.0.tar.gz", hash = "sha256:c9d31853b4e0bc2dc8bd08003b462a006035655a701471695d0bfdc08529cde3"}, + {file = "openai-1.45.1-py3-none-any.whl", hash = "sha256:4a6cce402aec803ae57ae7eff4b5b94bf6c0e1703a8d85541c27243c2adeadf8"}, + {file = "openai-1.45.1.tar.gz", hash = "sha256:f79e384916b219ab2f028bbf9c778e81291c61eb0645ccfa1828a4b18b55d534"}, ] [package.dependencies] @@ -2017,4 +2006,4 @@ type = ["pytest-mypy"] [metadata] lock-version = "2.0" python-versions = ">=3.9" -content-hash = "775e2111d96f8a406d1296ae2461ab6f4d51c6cc25410a58d51257b2d2a15500" +content-hash = "048d89acdccb088fba0e091ad2ca777a328dac504d8a9b6e5c6fbc8e4b63b85d" diff --git a/pyproject.toml b/pyproject.toml index 89f3cfa03..fbdeccebc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -39,7 +39,6 @@ typing-extensions = "^4.12.2" black = "^24.8.0" -json-fix = "^1.0.0" pillow = "^10.4.0" [tool.poetry.group.dev.dependencies] pytest = "^8.3.2" From 0bd70ae4bee48c125f9df3b849ada45a36d9a3f0 Mon Sep 17 00:00:00 2001 From: William Guss <carlostnb@gmail.com> Date: Tue, 17 Sep 2024 18:39:07 -0700 Subject: [PATCH 08/11] more notes --- docs/ramblings/0.1.0/metaprompting.md | 185 +++++++++++++++++++++ docs/ramblings/0.1.0/metapromptingtorch.py | 16 ++ 2 files changed, 201 insertions(+) create mode 100644 docs/ramblings/0.1.0/metapromptingtorch.py diff --git a/docs/ramblings/0.1.0/metaprompting.md b/docs/ramblings/0.1.0/metaprompting.md index e34d99636..61ebf6fc2 100644 --- a/docs/ramblings/0.1.0/metaprompting.md +++ b/docs/ramblings/0.1.0/metaprompting.md @@ -894,3 +894,188 @@ Meta prompting = construction of @ell.simple call + parsing dynamically from input outputs and instructions. +I think this is the conclusion. + +Take the best of DSPy and clean it up. +```python +class Input(BaseModel): + instructions : Field(str, description="The instructions for the prompt") + +class Output(BaseModel): + answer : Field(str, description="The answer to the prompt") + +meta_prompt = ell.meta( + name="blog_post", + input={ + "instructions" : Field(str, description="The instructions for the prompt") + }, + output={ + "answer" : Field(str, description="The answer to the prompt") + }, + instructions="write a blog post about the following topic", +) -> str + +``` + Meta prompts are signatures. + +Why DSPy requires compilation is that we can have mta promtps call one another but we shouldnt have to compile before calling because the computatio ngraph is not known until runtime. + +I think the prolem with all this is that when i do th.randn(10,10) i can immediately use it i can imemdiately use the layer it might be garbage but i can. SO if I were to take this in ell I can imagine. + +```python +meta_prompt = ell.lmp( + name = "blog_post", + input={ + "instructions" : Field(str, description="The instructions for the prompt") + }, + output={ + "answer" : Field(str, description="The answer to the prompt") + }, + instructions="write a blog post about the following topic", +) +``` +then I can just call meta_prompt() # and it will give me the prompt. the signature is the parameter but we can have different "initializations" instead of jsut LMP +compiling is uneccessary because we can access the parameterixaiton at runtime to optimize. This also allows the user to see what hhe fuck the thing is doing. +```python + +ell.meta.io_lmp( + ell.signature( + Input(instructions : str), + Output(answer : str), + instructions="write a blog post about the following topic", + ), + model="gpt-4o", +) + +cot_blog = ell.meta.cot_lmp( + ell.signature( + Input(instructions : str), + Output(title : str, content : str), + instructions="write a blog post about the following topic", + ), + model="gpt-4o", +) + + +@ell.function() +def write_blog_post(instructions : str) -> str: + blog = cot_blog(instructions) + return f"# {blog.title}\n\n{blog.content}" +``` + +Now let's say we want to optimize write_blog_post. + +```python +x = [ + "AI", +] +y = [ + BlogPost(title="AI", content="AI is the future."), +] + + +optimized_blog_post = ell.FewShotOptimizer().fit(write_blog_post, x=x, y=y) +``` +so because this is functional is cot_blog now changed? this the reason for modules in dspy because if i want to see the updated params is it cot_blog? + NO so we need to specify it as learnable: + + +```python +filters = ell.parameterized(ell.cot( + model="gpt-4o", + instructions="write a blog post about the following topic", + signature=ell.signature( + Input(instructions : str), + Output(title : str, content : str), + ), + )) +``` + + so we are going full functional now? + + we could do shit like this + +```python + @ell.simple(model="gpt-4o") + def my_intial_prompt(instructions : str) -> str: + return f"write a blog post about the following topic: {instructions}" + + + >>> ell.FewShotOptimizer().fit(my_intial_prompt, x=x, y=y) + exception: NotLearnableError("my_intial_prompt is not learnable") + + learnable = ell.learnable(my_intial_prompt) + final_prompt =ell.FewShotOptimizer().fit(learnable, x=x, y=y) + >>> final_prompt("AI") + "write a blog post about the following topic: AI" + + learnable.data # This is the final prompt + + ``` + + + ```python + + +import torch as th + + +weights = th.nn.Parameter(th.randn(10)) + + +def forward(x): + return x * weights + + +x = th.randn(10) + +print(forward(x)) +print(weights) + +# OOOH WAHT IF WE DID MANY TYPES OF LEARNABLES in +``` + +like: + +```python +@ell.simple(model="gpt-4o") +def my_initial_prompt(instructions : str) -> str: + return f"{ell.learnable("You must write a blog post about the following topic:")} {instructions}" + +``` + +Then we can optimize the strings! +I dont think "few shot" is an optimizer though. I guess you could say if you want to do few shot, y9ou would make the whole prompt learnable + +```python +learnable_prompt = th.learnable(my_initial_prompt) + + +ell.FewShotOptimizer().fit(learnable_prompt, x=x, y=y) + +--> + +def final_prompt(instructions : str) -> str: + return [ + ell.system("You are a helpful assistant."), + ell.user(x[0]), + ell.assistant(x[1]), + ... + ell.user("You must write a blog post about the following topic:") + ell.user(instructions) + ] +``` +but how do we serialize this? do we mutate the code? no. we just have it serialized like this + +```python +def my_initial_prompt(instructions : str) -> str: + return f"{ell.learnable("You must write a blog post about the following topic:")} {instructions}" + +my_intial_prompt_optimized= fewhsot(my_intial_prompt, x=x, y=y) + + +ell.simple(model="gpt-4o", messages=learnable_prompt.data) + +``` + +ew no. I guess I thought it was cool to have strings be parameters. in arbitrary ways. \ No newline at end of file diff --git a/docs/ramblings/0.1.0/metapromptingtorch.py b/docs/ramblings/0.1.0/metapromptingtorch.py new file mode 100644 index 000000000..a0edfb8ef --- /dev/null +++ b/docs/ramblings/0.1.0/metapromptingtorch.py @@ -0,0 +1,16 @@ + + +import torch as th + + +weights = th.nn.Parameter(th.randn(10)) + + +def forward(x): + return x * weights + + +x = th.randn(10) + +print(forward(x)) +print(weights) \ No newline at end of file From 0fc8b4f67ca74ef4992c80c3e5aeef5bfef3e6a9 Mon Sep 17 00:00:00 2001 From: William Guss <carlostnb@gmail.com> Date: Tue, 17 Sep 2024 18:41:56 -0700 Subject: [PATCH 09/11] . --- docs/ramblings/0.1.0/metapromptingtorch.py | 4 +- examples/future/o1_graph.py | 542 --------------------- examples/iteration_0 | 83 ---- 3 files changed, 3 insertions(+), 626 deletions(-) delete mode 100644 examples/future/o1_graph.py delete mode 100644 examples/iteration_0 diff --git a/docs/ramblings/0.1.0/metapromptingtorch.py b/docs/ramblings/0.1.0/metapromptingtorch.py index a0edfb8ef..75b1db927 100644 --- a/docs/ramblings/0.1.0/metapromptingtorch.py +++ b/docs/ramblings/0.1.0/metapromptingtorch.py @@ -13,4 +13,6 @@ def forward(x): x = th.randn(10) print(forward(x)) -print(weights) \ No newline at end of file +print(weights) + +# OOOH WAHT IF WE DID MANY TYPES OF LEARNABLES in \ No newline at end of file diff --git a/examples/future/o1_graph.py b/examples/future/o1_graph.py deleted file mode 100644 index 01f68092a..000000000 --- a/examples/future/o1_graph.py +++ /dev/null @@ -1,542 +0,0 @@ -"""" -Example originally from Instructor docs https://python.useinstructor.com/examples/knowledge_graph/ -All rights reserved to the original author. -""" - -from graphviz import Digraph -from pydantic import BaseModel, Field -from typing import List, Optional - - -class Node(BaseModel): - id: int - label: str - color: str - - -class Edge(BaseModel): - source: int - target: int - label: str - color: str = Field(description="The color of the edge. Defaults to black.") - - -class KnowledgeGraph(BaseModel): - nodes: Optional[List[Node]] = Field(..., default_factory=list) - edges: Optional[List[Edge]] = Field(..., default_factory=list) - - def update(self, other: "KnowledgeGraph") -> "KnowledgeGraph": - """Updates the current graph with the other graph, deduplicating nodes and edges.""" - # Create dictionaries to store unique nodes and edges - unique_nodes = {node.id: node for node in self.nodes} - unique_edges = {(edge.source, edge.target, edge.label): edge for edge in self.edges} - - # Update with nodes and edges from the other graph - for node in other.nodes: - unique_nodes[node.id] = node - for edge in other.edges: - unique_edges[(edge.source, edge.target, edge.label)] = edge - - return KnowledgeGraph( - nodes=list(unique_nodes.values()), - edges=list(unique_edges.values()), - ) - - def draw(self, prefix: str = None): - dot = Digraph(comment="Knowledge Graph") - - for node in self.nodes: - dot.node(str(node.id), node.label, color=node.color) - - for edge in self.edges: - dot.edge( - str(edge.source), str(edge.target), label=edge.label, color=edge.color - ) - dot.render(prefix, format="png", view=True) - - -import ell - -@ell.simple(model="o1-mini") -def update_knowledge_graph(cur_state: KnowledgeGraph, inp: str, i: int, num_iterations: int): - return [ - ell.user(f"""You are a going to build a graph of how the following process works in as extreme detail as possible. Don't build a call graph. Build a graph of the actual process of lexical closure. - - You are given the current state of the graph, and you must append the nodes and edges to it Do not procide any duplcates and try to reuse nodes as much as possible. Extract any new nodes and edges from the following: - Here is the current state of the graph: - {cur_state.model_dump_json(indent=2)} - You will produce an update to the graph that that will overwtite nodes and add edges (you cannot remove them.) - Answer only in this JSON format: - {KnowledgeGraph.model_json_schema()} - Do not wrap your JSON update in back ticks (```) - Do not include any other text. - """), - ell.user(f""" - # Part {i}/{num_iterations} of the source code: - - {inp}"""), - ] - -def generate_graph(input: List[str]) -> KnowledgeGraph: - cur_state = KnowledgeGraph() - num_iterations = len(input) - for i, inp in enumerate(input): - new_updates = update_knowledge_graph(cur_state, inp, i, num_iterations) - # Try to parse it - new_updates = new_updates.replace("```json", '"') - new_updates = new_updates.replace("```", '"') - new_updates = KnowledgeGraph.model_validate_json(new_updates) - cur_state = cur_state.update(new_updates) - cur_state.draw(prefix=f"iteration_{i}") - return cur_state - - - - -if __name__ == "__main__": - ell.init(verbose=True, store='./logdir', autocommit=True) - generate_graph([''' - # src/ell/util/closure.py - -import collections -import hashlib -import inspect -import re -import types -from collections import deque -from dataclasses import dataclass, field -from typing import Any, Callable, Dict, Optional, Set, Tuple, List - -import itertools -import dill -from dill.source import getsource - -from ell.util.closure_util import ( - format_source, - get_referenced_names, - globalvars, - should_import, -) -from ell.util.serialization import is_immutable_variable - -# Constants -FORBIDDEN_NAMES = {"ell", "lstr"} - - -@dataclass -class Dependency: - """Represents a dependency with its source code.""" - source: str - - -@dataclass -class ModuleDependency: - """Represents a module and its associated dependencies.""" - name: str - value: Any - dependencies: List[Dependency] = field(default_factory=list) - - -@dataclass -class Closure: - """Aggregates all closure-related information for a function.""" - source: str - dependencies: List[Dependency] = field(default_factory=list) - imports: Set[str] = field(default_factory=set) - modules: deque = field(default_factory=deque) - uses: Set[Any] = field(default_factory=set) - - -def lexical_closure( - func: Any, - already_closed: Optional[Set[int]] = None, - initial_call: bool = False, - recursion_stack: Optional[List[str]] = None, - forced_dependencies: Optional[Dict[str, Any]] = None, -) -> Tuple[str, Tuple[str, str], Set[Any]]: - """ - Generate a lexical closure for a given function or callable. - - Args: - func: The function or callable to process. - already_closed: Set of already processed function hashes. - initial_call: Indicates if this is the initial call. - recursion_stack: Tracks the recursion path. - forced_dependencies: Additional dependencies to include. - - Returns: - A tuple containing: - - Full source code of the closure. - - A tuple of (formatted source, cleaned source). - - A set of function objects used in the closure. - """ - already_closed = already_closed or set() - recursion_stack = recursion_stack or [] - forced_dependencies = forced_dependencies or {} - - original_func, wrapper_func = _unwrap_function(func) - - func_hash = hash(original_func) - if func_hash in already_closed: - return "", ("", ""), set() - - try: - source = getsource(original_func, lstrip=True) - except (IOError, TypeError) as e: - _raise_error( - f"Unable to retrieve source for function '{original_func.__qualname__}'", - e, - recursion_stack, - ) - - closure = Closure(source=source) - already_closed.add(func_hash) - recursion_stack.append(original_func.__qualname__) - - globals_and_frees = _get_globals_and_frees(original_func) - _process_dependencies(original_func, globals_and_frees, closure, already_closed, recursion_stack) - - for name, dependency in forced_dependencies.items(): - _process_dependency(dependency, closure, already_closed, recursion_stack, name=name) - - final_source = _assemble_final_source(closure) - - cleaned_source = _clean_source(final_source) - - formatted_source = format_source(closure.source) - formatted_cleaned = format_source(cleaned_source) - - function_hash = _generate_function_hash(formatted_source, formatted_cleaned, original_func.__qualname__) - - # Set closure attributes on wrapper_func if exists, else on original_func - target_func = wrapper_func if wrapper_func else original_func - if isinstance(target_func, types.MethodType): - target_func = target_func.__func__ - - target_func.__ell_closure__ = ( - formatted_source, - formatted_cleaned, - globals_and_frees["globals"], - globals_and_frees["frees"], - ) - target_func.__ell_hash__ = function_hash - # Only add to __ell_uses__ if it's an ell-decorated function - if hasattr(original_func, "__ell_func__"): - closure.uses.add(original_func) - target_func.__ell_uses__ = {fn for fn in closure.uses if hasattr(fn, "__ell_func__")} - - uses_set = {original_func} if not initial_call else closure.uses - return final_source, (formatted_source, cleaned_source), uses_set - - -def lexically_closured_source( - func: Callable, forced_dependencies: Optional[Dict[str, Any]] = None -) -> Tuple[str, Tuple[str, str], Set[Any]]: - """ - Generate a lexically closured source for a given function. - - This function creates a self-contained version of the provided callable, - capturing all dependencies, including global and free variables. - - Args: - func (Callable): The function or callable to process. - forced_dependencies (Optional[Dict[str, Any]]): Additional dependencies - to include in the closure. - - Returns: - Tuple containing: - 1. The full closure source code as a string. - 2. A tuple with (formatted source, cleaned source). - 3. A set of function objects used in the closure. - - Raises: - ValueError: If the input is not callable. - """ - if not callable(func): - raise ValueError("Input must be a callable object (function, method, or class).") - - closure_source, (formatted_source, cleaned_source), uses = lexical_closure( - func, initial_call=True, recursion_stack=[], forced_dependencies=forced_dependencies - ) - return closure_source, (formatted_source, cleaned_source), uses - - -def _unwrap_function(func: Any) -> Tuple[Callable, Optional[Callable]]: - """ - Recursively unwrap decorated functions to retrieve the original function. - - Returns: - A tuple containing: - - The original function. - - The outermost wrapper function (if any), else None. - """ - wrappers = [] - while hasattr(func, "__ell_func__"): - wrappers.append(func) - func = func.__ell_func__ - return func, wrappers[-1] if wrappers else None - - -def _get_globals_and_frees(func: Callable) -> Dict[str, Dict[str, Any]]: - """Retrieve global and free variables of a function.""" - globals_dict = collections.OrderedDict(globalvars(func)) - frees_dict = collections.OrderedDict(dill.detect.freevars(func)) - - if isinstance(func, type): - for method in func.__dict__.values(): - if isinstance(method, (types.FunctionType, types.MethodType)): - globals_dict.update(collections.OrderedDict(globalvars(method))) - frees_dict.update(collections.OrderedDict(dill.detect.freevars(method))) - - return {"globals": globals_dict, "frees": frees_dict} - - -def _process_dependencies( - func: Callable, - globals_and_frees: Dict[str, Dict[str, Any]], - closure: Closure, - already_closed: Set[int], - recursion_stack: List[str], -): - """Process dependencies of a function.""" - if isinstance(func, (types.FunctionType, types.MethodType)): - _process_default_kwargs(func, closure, already_closed, recursion_stack) - - for var_name, var_value in itertools.chain( - globals_and_frees["globals"].items(), globals_and_frees["frees"].items() - ): - _process_variable(var_name, var_value, closure, already_closed, recursion_stack) - - -def _process_default_kwargs( - func: Callable, - closure: Closure, - already_closed: Set[int], - recursion_stack: List[str], -): - """Process default keyword arguments of a function.""" - for name, param in inspect.signature(func).parameters.items(): - if param.default is not inspect.Parameter.empty: - _process_dependency(param.default, closure, already_closed, recursion_stack, name=name) - - -def _process_dependency( - value: Any, - closure: Closure, - already_closed: Set[int], - recursion_stack: List[str], - name: Optional[str] = None, -): - """Process dependencies from function signatures and variables.""" - if name in FORBIDDEN_NAMES: - return - - try: - if isinstance(value, (types.FunctionType, type, types.MethodType)): - dep_source, _, dep_uses = lexical_closure( - value, already_closed, recursion_stack.copy() - ) - if dep_source: - closure.dependencies.append(Dependency(source=dep_source)) - closure.uses.add(value) - closure.uses.update(dep_uses) - elif isinstance(value, (list, tuple, set)): - for item in value: - _process_dependency(item, closure, already_closed, recursion_stack, name=name) - else: - is_builtin = getattr(value.__class__, "__module__", "") in {"builtins", "__builtins__"} - if not is_builtin: - module_name = value.__class__.__module__ - if should_import(module_name): - import_statement = dill.source.getimport(value.__class__, alias=value.__class__.__name__) - closure.imports.add(import_statement) - else: - dep_source, _, dep_uses = lexical_closure( - type(value), already_closed, recursion_stack.copy() - ) - if dep_source: - closure.dependencies.append(Dependency(source=dep_source)) - closure.uses.update(dep_uses) - except Exception as e: - _raise_error( - f"Failed to capture the lexical closure of dependency {name}", - e, - recursion_stack, - ) - - -def _process_variable( - var_name: str, - var_value: Any, - closure: Closure, - already_closed: Set[int], - recursion_stack: List[str], -): - """Process a single variable.""" - try: - module = inspect.getmodule(var_value) - module_name = module.__name__ if module else None - if module_name and should_import(module_name): - import_statement = dill.source.getimport(var_value, alias=var_name) - closure.imports.add(import_statement) - return - except Exception: - pass - - if isinstance(var_value, (types.FunctionType, type, types.MethodType, types.ModuleType, types.BuiltinFunctionType)): - _handle_special_variable(var_name, var_value, closure, already_closed, recursion_stack) - else: - _handle_other_variable(var_name, var_value, closure) - - -def _handle_special_variable( - var_name: str, - var_value: Any, - closure: Closure, - already_closed: Set[int], - recursion_stack: List[str], -): - """Handle special types of variables like callables and modules.""" - if isinstance(var_value, (types.FunctionType, type, types.MethodType)): - _process_callable(var_name, var_value, closure, already_closed, recursion_stack) - elif isinstance(var_value, types.ModuleType): - _process_module(var_name, var_value, closure) - elif isinstance(var_value, types.BuiltinFunctionType): - import_statement = dill.source.getimport(var_value, alias=var_name) - closure.imports.add(import_statement) - - -def _process_callable( - var_name: str, - var_value: Callable, - closure: Closure, - already_closed: Set[int], - recursion_stack: List[str], -): - """Process a callable object.""" - try: - module_name = inspect.getmodule(var_value).__name__ - is_ell_module = "ell" in module_name - except Exception: - is_ell_module = False - - if var_name not in FORBIDDEN_NAMES and not is_ell_module: - try: - dep_source, _, dep_uses = lexical_closure( - var_value, already_closed, recursion_stack.copy() - ) - if dep_source: - closure.dependencies.append(Dependency(source=dep_source)) - closure.uses.add(var_value) - closure.uses.update(dep_uses) - except Exception as e: - _raise_error( - f"Failed to capture the lexical closure of global or free variable {var_name}", - e, - recursion_stack, - ) - - -def _process_module(var_name: str, var_value: types.ModuleType, closure: Closure): - """Process a module.""" - if should_import(var_value.__name__): - import_statement = dill.source.getimport(var_value, alias=var_name) - closure.imports.add(import_statement) - else: - closure.modules.append(ModuleDependency(name=var_name, value=var_value)) - - -def _handle_other_variable(var_name: str, var_value: Any, closure: Closure): - """Process non-callable and non-module variables.""" - if isinstance(var_value, str) and "\n" in var_value: - closure.dependencies.append(Dependency(source=f"{var_name} = {var_value}")) - elif is_immutable_variable(var_value): - closure.dependencies.append(Dependency(source=f"#<BV>\n{var_name} = {repr(var_value)}\n#</BV>")) - else: - closure.dependencies.append(Dependency(source=f"#<BmV>\n{var_name} = <{type(var_value).__name__} object>\n#</BmV>")) - - -def _assemble_final_source(closure: Closure) -> str: - """Assemble the final source code.""" - parts = [] - if closure.imports: - parts.append("\n".join(sorted(closure.imports))) - if closure.dependencies: - parts.append("\n".join(dep.source for dep in closure.dependencies)) - if closure.modules: - module_sources = [] - for module_dep in closure.modules: - module_sources.append(f"# Module: {module_dep.name}") - module_dependencies = "\n".join(dep.source for dep in module_dep.dependencies) - if module_dependencies: - module_sources.append(module_dependencies) - parts.append("\n\n".join(module_sources)) - if closure.source: - parts.append(closure.source) - - combined = "\n\n".join(parts) - - # Remove duplicate lines while preserving order - unique_lines = [] - seen = set() - for line in combined.split("\n"): - if line not in seen: - unique_lines.append(line) - seen.add(line) - final_source = "\n".join(unique_lines) - - # Replace multiple newlines with two - final_source = re.sub(r"\n{3,}", "\n\n", final_source) - - return final_source - - -def _generate_function_hash(source: str, cleaned_source: str, qualname: str) -> str: - """Generate a unique hash for the function.""" - hash_input = "\n".join((source, cleaned_source, qualname)).encode() - return "lmp-" + hashlib.md5(hash_input).hexdigest() - - -def _update_ell_func( - outer_func: Any, - source: str, - cleaned_source: str, - globals_dict: Dict[str, Any], - frees_dict: Dict[str, Any], - function_hash: str, - uses: Set[Any], -): - """Update the attributes of the outer function with closure information.""" - formatted_source = format_source(source) - formatted_cleaned = format_source(cleaned_source) - - # If it's a bound method, set attributes on the underlying function - if isinstance(outer_func, types.MethodType): - outer_func = outer_func.__func__ - - outer_func.__ell_closure__ = ( - formatted_source, - formatted_cleaned, - globals_dict, - frees_dict, - ) - outer_func.__ell_hash__ = function_hash - # Only add ell-decorated functions to __ell_uses__ - ell_uses = {fn for fn in closure.uses if hasattr(fn, "__ell_func__")} - outer_func.__ell_uses__ = ell_uses - - -def _raise_error(message: str, exception: Exception, recursion_stack: List[str]): - """Raise an exception with a detailed message.""" - error_msg = f"{message}. Error: {str(exception)}\nRecursion stack: {' -> '.join(recursion_stack)}" - raise Exception(error_msg) - - -def _clean_source(final_source: str) -> str: - """Clean the source code by removing duplicates and organizing imports.""" - # Replace multiple newlines with two - cleaned = re.sub(r"\n{3,}", "\n\n", final_source) - return cleaned - ''' - ]) - diff --git a/examples/iteration_0 b/examples/iteration_0 deleted file mode 100644 index a95f34909..000000000 --- a/examples/iteration_0 +++ /dev/null @@ -1,83 +0,0 @@ -// Knowledge Graph -digraph { - 1 [label="Start lexical_closure" color=blue] - 2 [label="Initialize already_closed, recursion_stack, forced_dependencies" color=green] - 3 [label="Call _unwrap_function(func)" color=blue] - 4 [label="Unwrap to original_func and wrapper_func" color=green] - 5 [label="Compute func_hash" color=orange] - 6 [label="Check if func_hash in already_closed" color=yellow] - 7 [label="func_hash found in already_closed" color=red] - 8 [label="Return empty closure" color=green] - 9 [label="Retrieve source using getsource(original_func)" color=blue] - 10 [label="Handle IOError or TypeError" color=red] - 11 [label="Create Closure object" color=green] - 12 [label="Add func_hash to already_closed" color=green] - 13 [label="Append original_func.__qualname__ to recursion_stack" color=green] - 14 [label="Call _get_globals_and_frees(original_func)" color=blue] - 15 [label="Retrieve globals and free variables" color=green] - 16 [label="Call _process_dependencies" color=blue] - 17 [label="Process default kwargs if Function or Method" color=green] - 18 [label="Iterate over globals and frees" color=green] - 19 [label="Call _process_variable for each variable" color=blue] - 20 [label="Retrieve module of variable" color=green] - 21 [label="Check if module should be imported" color=yellow] - 22 [label="If yes, add import statement to closure.imports" color=green] - 23 [label="If no, handle variable based on type" color=blue] - 24 [label="Call _handle_special_variable or _handle_other_variable" color=blue] - 25 [label="Process callable objects" color=green] - 26 [label="Call lexical_closure recursively for callable" color=blue] - 27 [label="Add Dependency to closure.dependencies" color=green] - 28 [label="Update closure.uses" color=green] - 29 [label="Process forced_dependencies" color=green] - 30 [label="Call _assemble_final_source" color=blue] - 31 [label="Combine imports, dependencies, modules, source" color=green] - 32 [label="Remove duplicate lines" color=green] - 33 [label="Replace multiple newlines" color=green] - 34 [label="Call _clean_source" color=blue] - 35 [label="Return cleaned source" color=green] - 36 [label="Call format_source for source and cleaned_source" color=blue] - 37 [label="Generate function_hash with _generate_function_hash" color=blue] - 38 [label="Set closure attributes on target_func" color=green] - 39 [label="Update __ell_uses__ if decorated" color=green] - 40 [label="Return final_source, formatted sources, uses_set" color=green] - 1 -> 2 [label=initializes color=black] - 2 -> 3 [label=calls color=black] - 3 -> 4 [label=unwraps color=black] - 4 -> 5 [label=hashes color=black] - 5 -> 6 [label=checks color=black] - 6 -> 7 [label="if in" color=black] - 7 -> 8 [label=then color=black] - 6 -> 9 [label=else color=black] - 9 -> 10 [label="handles exception" color=red] - 9 -> 11 [label=success color=black] - 11 -> 12 [label="adds to" color=black] - 12 -> 13 [label="appends to" color=black] - 13 -> 14 [label=calls color=black] - 14 -> 15 [label=retrieves color=black] - 15 -> 16 [label=calls color=black] - 16 -> 17 [label=processes color=black] - 17 -> 18 [label=iterates color=black] - 18 -> 19 [label="processes each" color=black] - 19 -> 20 [label="retrieves module" color=black] - 20 -> 21 [label="checks import" color=black] - 21 -> 22 [label="if true" color=black] - 21 -> 23 [label="if false" color=black] - 23 -> 24 [label="handles type" color=black] - 24 -> 25 [label="if special" color=black] - 24 -> 35 [label="if other" color=black] - 25 -> 26 [label="process callable" color=black] - 26 -> 27 [label="adds dependency" color=black] - 27 -> 28 [label="updates uses" color=black] - 19 -> 29 [label="after variables" color=black] - 29 -> 30 [label=calls color=black] - 30 -> 31 [label=assembles color=black] - 31 -> 32 [label="removes duplicates" color=black] - 32 -> 33 [label="cleans newlines" color=black] - 33 -> 34 [label=calls color=black] - 34 -> 35 [label=returns color=black] - 35 -> 36 [label="formats source" color=black] - 36 -> 37 [label="generates hash" color=black] - 37 -> 38 [label="sets attributes" color=black] - 38 -> 39 [label="updates uses" color=black] - 39 -> 40 [label="returns final output" color=black] -} From ac563f5c912f61cbca33c95c4091fc04de11ea19 Mon Sep 17 00:00:00 2001 From: William Guss <carlostnb@gmail.com> Date: Tue, 24 Sep 2024 20:55:26 -0700 Subject: [PATCH 10/11] . --- docs/ramblings/0.1.0/metaprompting.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/docs/ramblings/0.1.0/metaprompting.md b/docs/ramblings/0.1.0/metaprompting.md index 61ebf6fc2..7a6e74281 100644 --- a/docs/ramblings/0.1.0/metaprompting.md +++ b/docs/ramblings/0.1.0/metaprompting.md @@ -1078,4 +1078,6 @@ ell.simple(model="gpt-4o", messages=learnable_prompt.data) ``` -ew no. I guess I thought it was cool to have strings be parameters. in arbitrary ways. \ No newline at end of file +ew no. I guess I thought it was cool to have strings be parameters. in arbitrary ways. + + From 9b15ea0ac1ce0eb48b296a720f975c7687e215c5 Mon Sep 17 00:00:00 2001 From: William Guss <carlostnb@gmail.com> Date: Fri, 27 Sep 2024 12:51:07 -0700 Subject: [PATCH 11/11] remve iteration 0 --- examples/iteration_0.png | Bin 376204 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 examples/iteration_0.png diff --git a/examples/iteration_0.png b/examples/iteration_0.png deleted file mode 100644 index 2794ba22790e9765458aea9d8af657cb091d10e2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 376204 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�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%0A4eMwlJbtgaw_9a-x<3Y<KaDO3Im%a@JV`?m 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ⅅetMzOaE$r@(#W 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 mJoUW@Td}meI)(TL!E7 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ΝcfC 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