date_collected
stringclasses 1
value | repo_name
stringlengths 6
116
| file_name
stringlengths 2
220
| file_contents
stringlengths 13
357k
| prompts
sequence |
|---|---|---|---|---|
2024-01-10 | kumar045/langchain | tests~unit_tests~test_sql_database.py | # flake8: noqa=E501
"""Test SQL database wrapper."""
from sqlalchemy import Column, Integer, MetaData, String, Table, create_engine, insert
from langchain.sql_database import SQLDatabase
metadata_obj = MetaData()
user = Table(
"user",
metadata_obj,
Column("user_id", Integer, primary_key=True),
Column("user_name", String(16), nullable=False),
)
company = Table(
"company",
metadata_obj,
Column("company_id", Integer, primary_key=True),
Column("company_location", String, nullable=False),
)
def test_table_info() -> None:
"""Test that table info is constructed properly."""
engine = create_engine("sqlite:///:memory:")
metadata_obj.create_all(engine)
db = SQLDatabase(engine)
output = db.table_info
expected_output = """
CREATE TABLE user (
user_id INTEGER NOT NULL,
user_name VARCHAR(16) NOT NULL,
PRIMARY KEY (user_id)
)
SELECT * FROM 'user' LIMIT 3;
user_id user_name
CREATE TABLE company (
company_id INTEGER NOT NULL,
company_location VARCHAR NOT NULL,
PRIMARY KEY (company_id)
)
SELECT * FROM 'company' LIMIT 3;
company_id company_location
"""
assert sorted(" ".join(output.split())) == sorted(" ".join(expected_output.split()))
def test_table_info_w_sample_rows() -> None:
"""Test that table info is constructed properly."""
engine = create_engine("sqlite:///:memory:")
metadata_obj.create_all(engine)
values = [
{"user_id": 13, "user_name": "Harrison"},
{"user_id": 14, "user_name": "Chase"},
]
stmt = insert(user).values(values)
with engine.begin() as conn:
conn.execute(stmt)
db = SQLDatabase(engine, sample_rows_in_table_info=2)
output = db.table_info
expected_output = """
CREATE TABLE company (
company_id INTEGER NOT NULL,
company_location VARCHAR NOT NULL,
PRIMARY KEY (company_id)
)
SELECT * FROM 'company' LIMIT 2;
company_id company_location
CREATE TABLE user (
user_id INTEGER NOT NULL,
user_name VARCHAR(16) NOT NULL,
PRIMARY KEY (user_id)
)
SELECT * FROM 'user' LIMIT 2;
user_id user_name
13 Harrison
14 Chase
"""
assert sorted(output.split()) == sorted(expected_output.split())
def test_sql_database_run() -> None:
"""Test that commands can be run successfully and returned in correct format."""
engine = create_engine("sqlite:///:memory:")
metadata_obj.create_all(engine)
stmt = insert(user).values(user_id=13, user_name="Harrison")
with engine.begin() as conn:
conn.execute(stmt)
db = SQLDatabase(engine)
command = "select user_name from user where user_id = 13"
output = db.run(command)
expected_output = "[('Harrison',)]"
assert output == expected_output
def test_sql_database_run_update() -> None:
"""Test commands which return no rows return an empty string."""
engine = create_engine("sqlite:///:memory:")
metadata_obj.create_all(engine)
stmt = insert(user).values(user_id=13, user_name="Harrison")
with engine.begin() as conn:
conn.execute(stmt)
db = SQLDatabase(engine)
command = "update user set user_name='Updated' where user_id = 13"
output = db.run(command)
expected_output = ""
assert output == expected_output
| [] |
2024-01-10 | Nishantsingh45/chatbot1.0 | chatbot_app~urls.py | from django.urls import path
from . import views
import openai
urlpatterns = [
path('',views.chatbot,name='chatbot'),
path('login',views.login,name='login'),
path('register',views.register,name='register'),
path('logout',views.logout,name='logout'),
] | [] |
2024-01-10 | CoAxLab/stable-baselines3 | stable_baselines3~common~policies.py | from typing import Union, Type, Dict, List, Tuple, Optional, Any, Callable
from functools import partial
import gym
import torch as th
import torch.nn as nn
import numpy as np
from stable_baselines3.common.preprocessing import preprocess_obs, is_image_space
from stable_baselines3.common.torch_layers import (FlattenExtractor, BaseFeaturesExtractor, create_mlp,
NatureCNN, MlpExtractor)
from stable_baselines3.common.utils import get_device, is_vectorized_observation
from stable_baselines3.common.vec_env import VecTransposeImage
from stable_baselines3.common.distributions import (make_proba_distribution, Distribution,
DiagGaussianDistribution, CategoricalDistribution,
MultiCategoricalDistribution, BernoulliDistribution,
StateDependentNoiseDistribution)
class BasePolicy(nn.Module):
"""
The base policy object
:param observation_space: (gym.spaces.Space) The observation space of the environment
:param action_space: (gym.spaces.Space) The action space of the environment
:param device: (Union[th.device, str]) Device on which the code should run.
:param features_extractor_class: (Type[BaseFeaturesExtractor]) Features extractor to use.
:param features_extractor_kwargs: (Optional[Dict[str, Any]]) Keyword arguments
to pass to the feature extractor.
:param features_extractor: (nn.Module) Network to extract features
(a CNN when using images, a nn.Flatten() layer otherwise)
:param normalize_images: (bool) Whether to normalize images or not,
dividing by 255.0 (True by default)
:param optimizer_class: (Type[th.optim.Optimizer]) The optimizer to use,
``th.optim.Adam`` by default
:param optimizer_kwargs: (Optional[Dict[str, Any]]) Additional keyword arguments,
excluding the learning rate, to pass to the optimizer
:param squash_output: (bool) For continuous actions, whether the output is squashed
or not using a ``tanh()`` function.
"""
def __init__(self,
observation_space: gym.spaces.Space,
action_space: gym.spaces.Space,
device: Union[th.device, str] = 'auto',
features_extractor_class: Type[BaseFeaturesExtractor] = FlattenExtractor,
features_extractor_kwargs: Optional[Dict[str, Any]] = None,
features_extractor: Optional[nn.Module] = None,
normalize_images: bool = True,
optimizer_class: Type[th.optim.Optimizer] = th.optim.Adam,
optimizer_kwargs: Optional[Dict[str, Any]] = None,
squash_output: bool = False):
super(BasePolicy, self).__init__()
if optimizer_kwargs is None:
optimizer_kwargs = {}
if features_extractor_kwargs is None:
features_extractor_kwargs = {}
self.observation_space = observation_space
self.action_space = action_space
self.device = get_device(device)
self.features_extractor = features_extractor
self.normalize_images = normalize_images
self._squash_output = squash_output
self.optimizer_class = optimizer_class
self.optimizer_kwargs = optimizer_kwargs
self.optimizer = None # type: Optional[th.optim.Optimizer]
self.features_extractor_class = features_extractor_class
self.features_extractor_kwargs = features_extractor_kwargs
def extract_features(self, obs: th.Tensor) -> th.Tensor:
"""
Preprocess the observation if needed and extract features.
:param obs: (th.Tensor)
:return: (th.Tensor)
"""
assert self.features_extractor is not None, 'No feature extractor was set'
preprocessed_obs = preprocess_obs(obs, self.observation_space, normalize_images=self.normalize_images)
return self.features_extractor(preprocessed_obs)
@property
def squash_output(self) -> bool:
""" (bool) Getter for squash_output."""
return self._squash_output
@staticmethod
def init_weights(module: nn.Module, gain: float = 1) -> None:
"""
Orthogonal initialization (used in PPO and A2C)
"""
if isinstance(module, (nn.Linear, nn.Conv2d)):
nn.init.orthogonal_(module.weight, gain=gain)
module.bias.data.fill_(0.0)
@staticmethod
def _dummy_schedule(_progress_remaining: float) -> float:
""" (float) Useful for pickling policy."""
return 0.0
def forward(self, *_args, **kwargs):
raise NotImplementedError()
def _predict(self, observation: th.Tensor, deterministic: bool = False) -> th.Tensor:
"""
Get the action according to the policy for a given observation.
:param observation: (th.Tensor)
:param deterministic: (bool) Whether to use stochastic or deterministic actions
:return: (th.Tensor) Taken action according to the policy
"""
raise NotImplementedError()
def predict(self,
observation: np.ndarray,
state: Optional[np.ndarray] = None,
mask: Optional[np.ndarray] = None,
deterministic: bool = False) -> Tuple[np.ndarray, Optional[np.ndarray]]:
"""
Get the policy action and state from an observation (and optional state).
Includes sugar-coating to handle different observations (e.g. normalizing images).
:param observation: (np.ndarray) the input observation
:param state: (Optional[np.ndarray]) The last states (can be None, used in recurrent policies)
:param mask: (Optional[np.ndarray]) The last masks (can be None, used in recurrent policies)
:param deterministic: (bool) Whether or not to return deterministic actions.
:return: (Tuple[np.ndarray, Optional[np.ndarray]]) the model's action and the next state
(used in recurrent policies)
"""
# if state is None:
# state = self.initial_state
# if mask is None:
# mask = [False for _ in range(self.n_envs)]
observation = np.array(observation)
# Handle the different cases for images
# as PyTorch use channel first format
if is_image_space(self.observation_space):
if (observation.shape == self.observation_space.shape
or observation.shape[1:] == self.observation_space.shape):
pass
else:
# Try to re-order the channels
transpose_obs = VecTransposeImage.transpose_image(observation)
if (transpose_obs.shape == self.observation_space.shape
or transpose_obs.shape[1:] == self.observation_space.shape):
observation = transpose_obs
vectorized_env = is_vectorized_observation(observation, self.observation_space)
observation = observation.reshape((-1,) + self.observation_space.shape)
observation = th.as_tensor(observation).to(self.device)
with th.no_grad():
actions = self._predict(observation, deterministic=deterministic)
# Convert to numpy
actions = actions.cpu().numpy()
# Rescale to proper domain when using squashing
if isinstance(self.action_space, gym.spaces.Box) and self.squash_output:
actions = self.unscale_action(actions)
clipped_actions = actions
# Clip the actions to avoid out of bound error when using gaussian distribution
if isinstance(self.action_space, gym.spaces.Box) and not self.squash_output:
clipped_actions = np.clip(actions, self.action_space.low, self.action_space.high)
if not vectorized_env:
if state is not None:
raise ValueError("Error: The environment must be vectorized when using recurrent policies.")
clipped_actions = clipped_actions[0]
return clipped_actions, state
def scale_action(self, action: np.ndarray) -> np.ndarray:
"""
Rescale the action from [low, high] to [-1, 1]
(no need for symmetric action space)
:param action: (np.ndarray) Action to scale
:return: (np.ndarray) Scaled action
"""
low, high = self.action_space.low, self.action_space.high
return 2.0 * ((action - low) / (high - low)) - 1.0
def unscale_action(self, scaled_action: np.ndarray) -> np.ndarray:
"""
Rescale the action from [-1, 1] to [low, high]
(no need for symmetric action space)
:param scaled_action: Action to un-scale
"""
low, high = self.action_space.low, self.action_space.high
return low + (0.5 * (scaled_action + 1.0) * (high - low))
def _get_data(self) -> Dict[str, Any]:
"""
Get data that need to be saved in order to re-create the policy.
This corresponds to the arguments of the constructor.
:return: (Dict[str, Any])
"""
return dict(
observation_space=self.observation_space,
action_space=self.action_space,
# Passed to the constructor by child class
# squash_output=self.squash_output,
# features_extractor=self.features_extractor
normalize_images=self.normalize_images,
)
def save(self, path: str) -> None:
"""
Save policy to a given location.
:param path: (str)
"""
th.save({'state_dict': self.state_dict(), 'data': self._get_data()}, path)
@classmethod
def load(cls, path: str, device: Union[th.device, str] = 'auto') -> 'BasePolicy':
"""
Load policy from path.
:param path: (str)
:param device: ( Union[th.device, str]) Device on which the policy should be loaded.
:return: (BasePolicy)
"""
device = get_device(device)
saved_variables = th.load(path, map_location=device)
# Create policy object
model = cls(**saved_variables['data'])
# Load weights
model.load_state_dict(saved_variables['state_dict'])
model.to(device)
return model
def load_from_vector(self, vector: np.ndarray):
"""
Load parameters from a 1D vector.
:param vector: (np.ndarray)
"""
th.nn.utils.vector_to_parameters(th.FloatTensor(vector).to(self.device), self.parameters())
def parameters_to_vector(self) -> np.ndarray:
"""
Convert the parameters to a 1D vector.
:return: (np.ndarray)
"""
return th.nn.utils.parameters_to_vector(self.parameters()).detach().cpu().numpy()
class ActorCriticPolicy(BasePolicy):
"""
Policy class for actor-critic algorithms (has both policy and value prediction).
Used by A2C, PPO and the likes.
:param observation_space: (gym.spaces.Space) Observation space
:param action_space: (gym.spaces.Space) Action space
:param lr_schedule: (Callable) Learning rate schedule (could be constant)
:param net_arch: ([int or dict]) The specification of the policy and value networks.
:param device: (str or th.device) Device on which the code should run.
:param activation_fn: (Type[nn.Module]) Activation function
:param ortho_init: (bool) Whether to use or not orthogonal initialization
:param use_sde: (bool) Whether to use State Dependent Exploration or not
:param log_std_init: (float) Initial value for the log standard deviation
:param full_std: (bool) Whether to use (n_features x n_actions) parameters
for the std instead of only (n_features,) when using gSDE
:param sde_net_arch: ([int]) Network architecture for extracting features
when using gSDE. If None, the latent features from the policy will be used.
Pass an empty list to use the states as features.
:param use_expln: (bool) Use ``expln()`` function instead of ``exp()`` to ensure
a positive standard deviation (cf paper). It allows to keep variance
above zero and prevent it from growing too fast. In practice, ``exp()`` is usually enough.
:param squash_output: (bool) Whether to squash the output using a tanh function,
this allows to ensure boundaries when using gSDE.
:param features_extractor_class: (Type[BaseFeaturesExtractor]) Features extractor to use.
:param features_extractor_kwargs: (Optional[Dict[str, Any]]) Keyword arguments
to pass to the feature extractor.
:param normalize_images: (bool) Whether to normalize images or not,
dividing by 255.0 (True by default)
:param optimizer_class: (Type[th.optim.Optimizer]) The optimizer to use,
``th.optim.Adam`` by default
:param optimizer_kwargs: (Optional[Dict[str, Any]]) Additional keyword arguments,
excluding the learning rate, to pass to the optimizer
"""
def __init__(self,
observation_space: gym.spaces.Space,
action_space: gym.spaces.Space,
lr_schedule: Callable,
net_arch: Optional[List[Union[int, Dict[str, List[int]]]]] = None,
device: Union[th.device, str] = 'auto',
activation_fn: Type[nn.Module] = nn.Tanh,
ortho_init: bool = True,
use_sde: bool = False,
log_std_init: float = 0.0,
full_std: bool = True,
sde_net_arch: Optional[List[int]] = None,
use_expln: bool = False,
squash_output: bool = False,
features_extractor_class: Type[BaseFeaturesExtractor] = FlattenExtractor,
features_extractor_kwargs: Optional[Dict[str, Any]] = None,
normalize_images: bool = True,
optimizer_class: Type[th.optim.Optimizer] = th.optim.Adam,
optimizer_kwargs: Optional[Dict[str, Any]] = None):
if optimizer_kwargs is None:
optimizer_kwargs = {}
# Small values to avoid NaN in ADAM optimizer
if optimizer_class == th.optim.Adam:
optimizer_kwargs['eps'] = 1e-5
super(ActorCriticPolicy, self).__init__(observation_space,
action_space,
device,
features_extractor_class,
features_extractor_kwargs,
optimizer_class=optimizer_class,
optimizer_kwargs=optimizer_kwargs,
squash_output=squash_output)
# Default network architecture, from stable-baselines
if net_arch is None:
if features_extractor_class == FlattenExtractor:
net_arch = [dict(pi=[64, 64], vf=[64, 64])]
else:
net_arch = []
self.net_arch = net_arch
self.activation_fn = activation_fn
self.ortho_init = ortho_init
self.features_extractor = features_extractor_class(self.observation_space,
**self.features_extractor_kwargs)
self.features_dim = self.features_extractor.features_dim
self.normalize_images = normalize_images
self.log_std_init = log_std_init
dist_kwargs = None
# Keyword arguments for gSDE distribution
if use_sde:
dist_kwargs = {
'full_std': full_std,
'squash_output': squash_output,
'use_expln': use_expln,
'learn_features': sde_net_arch is not None
}
self.sde_features_extractor = None
self.sde_net_arch = sde_net_arch
self.use_sde = use_sde
self.dist_kwargs = dist_kwargs
# Action distribution
self.action_dist = make_proba_distribution(action_space, use_sde=use_sde, dist_kwargs=dist_kwargs)
self._build(lr_schedule)
def _get_data(self) -> Dict[str, Any]:
data = super()._get_data()
data.update(dict(
net_arch=self.net_arch,
activation_fn=self.activation_fn,
use_sde=self.use_sde,
log_std_init=self.log_std_init,
squash_output=self.dist_kwargs['squash_output'] if self.dist_kwargs else None,
full_std=self.dist_kwargs['full_std'] if self.dist_kwargs else None,
sde_net_arch=self.dist_kwargs['sde_net_arch'] if self.dist_kwargs else None,
use_expln=self.dist_kwargs['use_expln'] if self.dist_kwargs else None,
lr_schedule=self._dummy_schedule, # dummy lr schedule, not needed for loading policy alone
ortho_init=self.ortho_init,
optimizer_class=self.optimizer_class,
optimizer_kwargs=self.optimizer_kwargs,
features_extractor_class=self.features_extractor_class,
features_extractor_kwargs=self.features_extractor_kwargs
))
return data
def reset_noise(self, n_envs: int = 1) -> None:
"""
Sample new weights for the exploration matrix.
:param n_envs: (int)
"""
assert isinstance(self.action_dist,
StateDependentNoiseDistribution), 'reset_noise() is only available when using gSDE'
self.action_dist.sample_weights(self.log_std, batch_size=n_envs)
def _build(self, lr_schedule: Callable) -> None:
"""
Create the networks and the optimizer.
:param lr_schedule: (Callable) Learning rate schedule
lr_schedule(1) is the initial learning rate
"""
# Note: If net_arch is None and some features extractor is used,
# net_arch here is an empty list and mlp_extractor does not
# really contain any layers (acts like an identity module).
self.mlp_extractor = MlpExtractor(self.features_dim, net_arch=self.net_arch,
activation_fn=self.activation_fn, device=self.device)
latent_dim_pi = self.mlp_extractor.latent_dim_pi
# Separate feature extractor for gSDE
if self.sde_net_arch is not None:
self.sde_features_extractor, latent_sde_dim = create_sde_features_extractor(self.features_dim,
self.sde_net_arch,
self.activation_fn)
if isinstance(self.action_dist, DiagGaussianDistribution):
self.action_net, self.log_std = self.action_dist.proba_distribution_net(latent_dim=latent_dim_pi,
log_std_init=self.log_std_init)
elif isinstance(self.action_dist, StateDependentNoiseDistribution):
latent_sde_dim = latent_dim_pi if self.sde_net_arch is None else latent_sde_dim
self.action_net, self.log_std = self.action_dist.proba_distribution_net(latent_dim=latent_dim_pi,
latent_sde_dim=latent_sde_dim,
log_std_init=self.log_std_init)
elif isinstance(self.action_dist, CategoricalDistribution):
self.action_net = self.action_dist.proba_distribution_net(latent_dim=latent_dim_pi)
elif isinstance(self.action_dist, MultiCategoricalDistribution):
self.action_net = self.action_dist.proba_distribution_net(latent_dim=latent_dim_pi)
elif isinstance(self.action_dist, BernoulliDistribution):
self.action_net = self.action_dist.proba_distribution_net(latent_dim=latent_dim_pi)
self.value_net = nn.Linear(self.mlp_extractor.latent_dim_vf, 1)
# Init weights: use orthogonal initialization
# with small initial weight for the output
if self.ortho_init:
# TODO: check for features_extractor
# Values from stable-baselines.
# feature_extractor/mlp values are
# originally from openai/baselines (default gains/init_scales).
module_gains = {
self.features_extractor: np.sqrt(2),
self.mlp_extractor: np.sqrt(2),
self.action_net: 0.01,
self.value_net: 1
}
for module, gain in module_gains.items():
module.apply(partial(self.init_weights, gain=gain))
# Setup optimizer with initial learning rate
self.optimizer = self.optimizer_class(self.parameters(), lr=lr_schedule(1), **self.optimizer_kwargs)
def forward(self, obs: th.Tensor,
deterministic: bool = False) -> Tuple[th.Tensor, th.Tensor, th.Tensor]:
"""
Forward pass in all the networks (actor and critic)
:param obs: (th.Tensor) Observation
:param deterministic: (bool) Whether to sample or use deterministic actions
:return: (Tuple[th.Tensor, th.Tensor, th.Tensor]) action, value and log probability of the action
"""
latent_pi, latent_vf, latent_sde = self._get_latent(obs)
# Evaluate the values for the given observations
values = self.value_net(latent_vf)
distribution = self._get_action_dist_from_latent(latent_pi, latent_sde=latent_sde)
actions = distribution.get_actions(deterministic=deterministic)
log_prob = distribution.log_prob(actions)
return actions, values, log_prob
def _get_latent(self, obs: th.Tensor) -> Tuple[th.Tensor, th.Tensor, th.Tensor]:
"""
Get the latent code (i.e., activations of the last layer of each network)
for the different networks.
:param obs: (th.Tensor) Observation
:return: (Tuple[th.Tensor, th.Tensor, th.Tensor]) Latent codes
for the actor, the value function and for gSDE function
"""
# Preprocess the observation if needed
features = self.extract_features(obs)
latent_pi, latent_vf = self.mlp_extractor(features)
# Features for sde
latent_sde = latent_pi
if self.sde_features_extractor is not None:
latent_sde = self.sde_features_extractor(features)
return latent_pi, latent_vf, latent_sde
def _get_action_dist_from_latent(self, latent_pi: th.Tensor,
latent_sde: Optional[th.Tensor] = None) -> Distribution:
"""
Retrieve action distribution given the latent codes.
:param latent_pi: (th.Tensor) Latent code for the actor
:param latent_sde: (Optional[th.Tensor]) Latent code for the gSDE exploration function
:return: (Distribution) Action distribution
"""
mean_actions = self.action_net(latent_pi)
if isinstance(self.action_dist, DiagGaussianDistribution):
return self.action_dist.proba_distribution(mean_actions, self.log_std)
elif isinstance(self.action_dist, CategoricalDistribution):
# Here mean_actions are the logits before the softmax
return self.action_dist.proba_distribution(action_logits=mean_actions)
elif isinstance(self.action_dist, MultiCategoricalDistribution):
# Here mean_actions are the flattened logits
return self.action_dist.proba_distribution(action_logits=mean_actions)
elif isinstance(self.action_dist, BernoulliDistribution):
# Here mean_actions are the logits (before rounding to get the binary actions)
return self.action_dist.proba_distribution(action_logits=mean_actions)
elif isinstance(self.action_dist, StateDependentNoiseDistribution):
return self.action_dist.proba_distribution(mean_actions, self.log_std, latent_sde)
else:
raise ValueError('Invalid action distribution')
def _predict(self, observation: th.Tensor, deterministic: bool = False) -> th.Tensor:
"""
Get the action according to the policy for a given observation.
:param observation: (th.Tensor)
:param deterministic: (bool) Whether to use stochastic or deterministic actions
:return: (th.Tensor) Taken action according to the policy
"""
latent_pi, _, latent_sde = self._get_latent(observation)
distribution = self._get_action_dist_from_latent(latent_pi, latent_sde)
return distribution.get_actions(deterministic=deterministic)
def evaluate_actions(self, obs: th.Tensor,
actions: th.Tensor) -> Tuple[th.Tensor, th.Tensor, th.Tensor]:
"""
Evaluate actions according to the current policy,
given the observations.
:param obs: (th.Tensor)
:param actions: (th.Tensor)
:return: (th.Tensor, th.Tensor, th.Tensor) estimated value, log likelihood of taking those actions
and entropy of the action distribution.
"""
latent_pi, latent_vf, latent_sde = self._get_latent(obs)
distribution = self._get_action_dist_from_latent(latent_pi, latent_sde)
log_prob = distribution.log_prob(actions)
values = self.value_net(latent_vf)
return values, log_prob, distribution.entropy()
class ActorCriticCnnPolicy(ActorCriticPolicy):
"""
CNN policy class for actor-critic algorithms (has both policy and value prediction).
Used by A2C, PPO and the likes.
:param observation_space: (gym.spaces.Space) Observation space
:param action_space: (gym.spaces.Space) Action space
:param lr_schedule: (Callable) Learning rate schedule (could be constant)
:param net_arch: ([int or dict]) The specification of the policy and value networks.
:param device: (str or th.device) Device on which the code should run.
:param activation_fn: (Type[nn.Module]) Activation function
:param ortho_init: (bool) Whether to use or not orthogonal initialization
:param use_sde: (bool) Whether to use State Dependent Exploration or not
:param log_std_init: (float) Initial value for the log standard deviation
:param full_std: (bool) Whether to use (n_features x n_actions) parameters
for the std instead of only (n_features,) when using gSDE
:param sde_net_arch: ([int]) Network architecture for extracting features
when using gSDE. If None, the latent features from the policy will be used.
Pass an empty list to use the states as features.
:param use_expln: (bool) Use ``expln()`` function instead of ``exp()`` to ensure
a positive standard deviation (cf paper). It allows to keep variance
above zero and prevent it from growing too fast. In practice, ``exp()`` is usually enough.
:param squash_output: (bool) Whether to squash the output using a tanh function,
this allows to ensure boundaries when using gSDE.
:param features_extractor_class: (Type[BaseFeaturesExtractor]) Features extractor to use.
:param features_extractor_kwargs: (Optional[Dict[str, Any]]) Keyword arguments
to pass to the feature extractor.
:param normalize_images: (bool) Whether to normalize images or not,
dividing by 255.0 (True by default)
:param optimizer_class: (Type[th.optim.Optimizer]) The optimizer to use,
``th.optim.Adam`` by default
:param optimizer_kwargs: (Optional[Dict[str, Any]]) Additional keyword arguments,
excluding the learning rate, to pass to the optimizer
"""
def __init__(self,
observation_space: gym.spaces.Space,
action_space: gym.spaces.Space,
lr_schedule: Callable,
net_arch: Optional[List[Union[int, Dict[str, List[int]]]]] = None,
device: Union[th.device, str] = 'auto',
activation_fn: Type[nn.Module] = nn.Tanh,
ortho_init: bool = True,
use_sde: bool = False,
log_std_init: float = 0.0,
full_std: bool = True,
sde_net_arch: Optional[List[int]] = None,
use_expln: bool = False,
squash_output: bool = False,
features_extractor_class: Type[BaseFeaturesExtractor] = NatureCNN,
features_extractor_kwargs: Optional[Dict[str, Any]] = None,
normalize_images: bool = True,
optimizer_class: Type[th.optim.Optimizer] = th.optim.Adam,
optimizer_kwargs: Optional[Dict[str, Any]] = None):
super(ActorCriticCnnPolicy, self).__init__(observation_space,
action_space,
lr_schedule,
net_arch,
device,
activation_fn,
ortho_init,
use_sde,
log_std_init,
full_std,
sde_net_arch,
use_expln,
squash_output,
features_extractor_class,
features_extractor_kwargs,
normalize_images,
optimizer_class,
optimizer_kwargs)
def create_sde_features_extractor(features_dim: int,
sde_net_arch: List[int],
activation_fn: Type[nn.Module]) -> Tuple[nn.Sequential, int]:
"""
Create the neural network that will be used to extract features
for the gSDE exploration function.
:param features_dim: (int)
:param sde_net_arch: ([int])
:param activation_fn: (Type[nn.Module])
:return: (nn.Sequential, int)
"""
# Special case: when using states as features (i.e. sde_net_arch is an empty list)
# don't use any activation function
sde_activation = activation_fn if len(sde_net_arch) > 0 else None
latent_sde_net = create_mlp(features_dim, -1, sde_net_arch, activation_fn=sde_activation, squash_output=False)
latent_sde_dim = sde_net_arch[-1] if len(sde_net_arch) > 0 else features_dim
sde_features_extractor = nn.Sequential(*latent_sde_net)
return sde_features_extractor, latent_sde_dim
_policy_registry = dict() # type: Dict[Type[BasePolicy], Dict[str, Type[BasePolicy]]]
def get_policy_from_name(base_policy_type: Type[BasePolicy], name: str) -> Type[BasePolicy]:
"""
Returns the registered policy from the base type and name.
See `register_policy` for registering policies and explanation.
:param base_policy_type: (Type[BasePolicy]) the base policy class
:param name: (str) the policy name
:return: (Type[BasePolicy]) the policy
"""
if base_policy_type not in _policy_registry:
raise ValueError(f"Error: the policy type {base_policy_type} is not registered!")
if name not in _policy_registry[base_policy_type]:
raise ValueError(f"Error: unknown policy type {name},"
f"the only registed policy type are: {list(_policy_registry[base_policy_type].keys())}!")
return _policy_registry[base_policy_type][name]
def register_policy(name: str, policy: Type[BasePolicy]) -> None:
"""
Register a policy, so it can be called using its name.
e.g. SAC('MlpPolicy', ...) instead of SAC(MlpPolicy, ...).
The goal here is to standardize policy naming, e.g.
all algorithms can call upon "MlpPolicy" or "CnnPolicy",
and they receive respective policies that work for them.
Consider following:
OnlinePolicy
-- OnlineMlpPolicy ("MlpPolicy")
-- OnlineCnnPolicy ("CnnPolicy")
OfflinePolicy
-- OfflineMlpPolicy ("MlpPolicy")
-- OfflineCnnPolicy ("CnnPolicy")
Two policies have name "MlpPolicy" and two have "CnnPolicy".
In `get_policy_from_name`, the parent class (e.g. OnlinePolicy)
is given and used to select and return the correct policy.
:param name: (str) the policy name
:param policy: (Type[BasePolicy]) the policy class
"""
sub_class = None
for cls in BasePolicy.__subclasses__():
if issubclass(policy, cls):
sub_class = cls
break
if sub_class is None:
raise ValueError(f"Error: the policy {policy} is not of any known subclasses of BasePolicy!")
if sub_class not in _policy_registry:
_policy_registry[sub_class] = {}
if name in _policy_registry[sub_class]:
# Check if the registered policy is same
# we try to register. If not so,
# do not override and complain.
if _policy_registry[sub_class][name] != policy:
raise ValueError(f"Error: the name {name} is already registered for a different policy, will not override.")
_policy_registry[sub_class][name] = policy
| [] |
2024-01-10 | Redbeard-himalaya/modelscope | modelscope~models~cv~image_probing_model~backbone.py | # The implementation is adopted from OpenAI-CLIP,
# made pubicly available under the MIT License at https://github.com/openai/CLIP
import math
import sys
from collections import OrderedDict
from functools import reduce
from operator import mul
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from PIL import Image
from torchvision import models
from .utils import convert_weights, load_pretrained
class Bottleneck(nn.Module):
expansion = 4
def __init__(self, inplanes, planes, stride=1):
super().__init__()
# all conv layers have stride 1. an avgpool is performed
# after the second convolution when stride > 1
self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False)
self.bn1 = nn.BatchNorm2d(planes)
self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False)
self.bn2 = nn.BatchNorm2d(planes)
self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity()
self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False)
self.bn3 = nn.BatchNorm2d(planes * self.expansion)
self.relu = nn.ReLU(inplace=True)
self.downsample = None
self.stride = stride
if stride > 1 or inplanes != planes * Bottleneck.expansion:
# downsampling layer is prepended with an avgpool,
# and the subsequent convolution has stride 1
self.downsample = nn.Sequential(
OrderedDict([('-1', nn.AvgPool2d(stride)),
('0',
nn.Conv2d(
inplanes,
planes * self.expansion,
1,
stride=1,
bias=False)),
('1', nn.BatchNorm2d(planes * self.expansion))]))
def forward(self, x: torch.Tensor):
identity = x
out = self.relu(self.bn1(self.conv1(x)))
out = self.relu(self.bn2(self.conv2(out)))
out = self.avgpool(out)
out = self.bn3(self.conv3(out))
if self.downsample is not None:
identity = self.downsample(x)
out += identity
out = self.relu(out)
return out
class AttentionPool2d(nn.Module):
def __init__(self,
spacial_dim: int,
embed_dim: int,
num_heads: int,
output_dim: int = None):
super().__init__()
self.positional_embedding = nn.Parameter(
torch.randn(spacial_dim**2 + 1, embed_dim) / embed_dim**0.5)
self.k_proj = nn.Linear(embed_dim, embed_dim)
self.q_proj = nn.Linear(embed_dim, embed_dim)
self.v_proj = nn.Linear(embed_dim, embed_dim)
self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim)
self.num_heads = num_heads
def forward(self, x):
x = x.reshape(x.shape[0], x.shape[1],
x.shape[2] * x.shape[3]).permute(2, 0, 1)
x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0)
x = x + self.positional_embedding[:, None, :].to(x.dtype)
x, _ = F.multi_head_attention_forward(
query=x,
key=x,
value=x,
embed_dim_to_check=x.shape[-1],
num_heads=self.num_heads,
q_proj_weight=self.q_proj.weight,
k_proj_weight=self.k_proj.weight,
v_proj_weight=self.v_proj.weight,
in_proj_weight=None,
in_proj_bias=torch.cat(
[self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]),
bias_k=None,
bias_v=None,
add_zero_attn=False,
dropout_p=0,
out_proj_weight=self.c_proj.weight,
out_proj_bias=self.c_proj.bias,
use_separate_proj_weight=True,
training=self.training,
need_weights=False)
return x[0]
class LayerNorm(nn.LayerNorm):
"""Subclass torch's LayerNorm to handle fp16."""
def forward(self, x: torch.Tensor):
orig_type = x.dtype
ret = super().forward(x.type(torch.float32))
return ret.type(orig_type)
class QuickGELU(nn.Module):
def forward(self, x: torch.Tensor):
return x * torch.sigmoid(1.702 * x)
class ResidualAttentionBlock(nn.Module):
def __init__(self,
d_model: int,
n_head: int,
attn_mask: torch.Tensor = None):
super().__init__()
self.attn = nn.MultiheadAttention(d_model, n_head)
self.ln_1 = LayerNorm(d_model)
self.mlp = nn.Sequential(
OrderedDict([('c_fc', nn.Linear(d_model, d_model * 4)),
('gelu', QuickGELU()),
('c_proj', nn.Linear(d_model * 4, d_model))]))
self.ln_2 = LayerNorm(d_model)
self.attn_mask = attn_mask
def attention(self, x: torch.Tensor):
self.attn_mask = self.attn_mask.to(
dtype=x.dtype,
device=x.device) if self.attn_mask is not None else None
return self.attn(
x, x, x, need_weights=False, attn_mask=self.attn_mask)[0]
def forward(self, x: torch.Tensor, idx):
features = {}
x_norm = self.ln_1(x)
features['layer_{}_pre_attn'.format(idx)] = x_norm.permute(1, 0, 2)
attn = self.attention(x_norm)
features['layer_{}_attn'.format(idx)] = attn.permute(1, 0, 2)
x = x + attn
mlp = self.mlp(self.ln_2(x))
features['layer_{}_mlp'.format(idx)] = mlp.permute(1, 0, 2)
x = x + mlp
return x, features
class Transformer(nn.Module):
def __init__(self,
width: int,
layers: int,
heads: int,
attn_mask: torch.Tensor = None):
super().__init__()
self.width = width
self.layers = layers
self.resblocks = nn.ModuleList()
for i in range(layers):
block = ResidualAttentionBlock(width, heads, attn_mask)
self.resblocks.append(block)
def forward(self, x: torch.Tensor):
features = {}
for idx, block in enumerate(self.resblocks):
x, block_feats = block(x, idx)
features.update(block_feats)
return x, features
class VisualTransformer(nn.Module):
def __init__(self, input_resolution: int, patch_size: int, width: int,
layers: int, heads: int, output_dim: int):
super().__init__()
print(input_resolution, patch_size, width, layers, heads, output_dim)
self.input_resolution = input_resolution
self.output_dim = output_dim
self.conv1 = nn.Conv2d(
in_channels=3,
out_channels=width,
kernel_size=patch_size,
stride=patch_size,
bias=False)
scale = width**-0.5
self.class_embedding = nn.Parameter(scale * torch.randn(width))
self.positional_embedding = nn.Parameter(scale * torch.randn(
(input_resolution // patch_size)**2 + 1, width))
self.ln_pre = LayerNorm(width)
self.transformer = Transformer(width, layers, heads)
self.ln_post = LayerNorm(width)
self.proj = nn.Parameter(scale * torch.randn(width, output_dim))
def forward(self, x: torch.Tensor, return_all=True):
x = self.conv1(x) # shape = [*, width, grid, grid]
x = x.reshape(x.shape[0], x.shape[1],
-1) # shape = [*, width, grid ** 2]
x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width]
zeros = torch.zeros(
x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device)
# shape = [*, grid ** 2 + 1, width]
x = torch.cat([self.class_embedding.to(x.dtype) + zeros, x], dim=1)
x = x + self.positional_embedding.to(x.dtype)
x = self.ln_pre(x)
x = x.permute(1, 0, 2) # NLD -> LND
x, features = self.transformer(x)
x = x.permute(1, 0, 2) # LND -> NLD
x = self.ln_post(x[:, 0, :])
if return_all:
features['pre_logits'] = x
return features
if self.proj is not None:
x = x @ self.proj
return x
class CLIPNet(nn.Module):
def __init__(self, arch_name, pretrained, **kwargs):
super(CLIPNet, self).__init__()
if arch_name == 'CLIP_ViTB32':
self.clip = VisualTransformer(
input_resolution=224,
patch_size=32,
width=768,
layers=12,
heads=12,
output_dim=512)
elif arch_name in ('CLIP_ViTB16', 'CLIP_ViTB16_FP16'):
self.clip = VisualTransformer(
input_resolution=224,
patch_size=16,
width=768,
layers=12,
heads=12,
output_dim=512)
elif arch_name in ('CLIP_ViTL14', 'CLIP_ViTL14_FP16'):
self.clip = VisualTransformer(
input_resolution=224,
patch_size=14,
width=1024,
layers=24,
heads=16,
output_dim=768)
else:
raise KeyError(f'Unsupported arch_name for CLIP, {arch_name}')
def forward(self, input_data):
output = self.clip(input_data)
return output
def CLIP(arch_name='CLIP_RN50',
use_pretrain=False,
load_from='',
state_dict=None,
**kwargs):
model = CLIPNet(arch_name=arch_name, pretrained=None, **kwargs)
if use_pretrain:
if arch_name.endswith('FP16'):
convert_weights(model.clip)
load_pretrained(model.clip, state_dict, load_from)
return model
class ProbingModel(torch.nn.Module):
def __init__(self, feat_size, num_classes):
super(ProbingModel, self).__init__()
self.linear = torch.nn.Linear(feat_size, num_classes)
def forward(self, x):
return self.linear(x)
| [] |
2024-01-10 | hkoziolek/LLM-CodeGen-RAG | CodeGen.py | from langchain.vectorstores import FAISS
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.chat_models import ChatOpenAI
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from langchain.chains import RetrievalQA
my_openai_api_key = "" # Insert your OpenAI API key here
llm = ChatOpenAI( # Instantiate your favorite language model here
openai_api_key=my_openai_api_key,
model_name="gpt-4",
callbacks=[StreamingStdOutCallbackHandler()],
streaming=True,
verbose=True,
temperature=0
)
embeddings = OpenAIEmbeddings(openai_api_key=my_openai_api_key)
vectorstore = FAISS.load_local("faiss_index_oscat", embeddings)
qa = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever = vectorstore.as_retriever(search_kwargs={'k': 6}),
verbose=True,
return_source_documents=True
)
# Modify the prompt below to your liking
prompt = """Write a self-contained IEC 61131-3 ST function block:
Create a PID controller with dynamic anti-wind up and manual control input for temperature control in an ammonium nitrates reactor.
Set point = 180.0, Kp = 50.0, Ki = 1.2, Kd = 10.0, limits between -100 and +100.
Add a timer to only set the PID controller to automatic mode after 10 seconds.
Use pre-specified function blocks.
Assign each used function module to a local variable, do not call it directly.
Do not include comments in the code. Do not use // or (* *).
Do not write code for the inner body of instantiated function blocks.
Use upper-case letters and underscores for function block names.
Use lower-case and upper-case letters for variable names.
Do not provide explanations, only the source code.
The generated ST Code must follow this format:
FUNCTION_BLOCK <name of the function block>
VAR_INPUT (** here define input variables **) END_VAR
VAR_OUTPUT (** here define output variables **) END_VAR
VAR (** here define internal temp variables **) END_VAR
(** here write ST code of this function block**)
END_FUNCTION_BLOCK
"""
print("Prompt:\n", prompt)
print("-----------------------------------------------------------------------\n")
print("Answer:")
result = qa({"query": prompt})
print("The following", len(result["source_documents"]), "pages were used from the source document:\n")
pagenum = 0
for document in result["source_documents"]:
print("-----------------------------------------------------------------------\n")
pagenum += 1
print("Page number:", pagenum)
print("Page content:\n")
print(document.page_content, "\n")
print(document.metadata, "\n\n") | [
"Write a self-contained IEC 61131-3 ST function block:\n\nCreate a PID controller with dynamic anti-wind up and manual control input for temperature control in an ammonium nitrates reactor.\nSet point = 180.0, Kp = 50.0, Ki = 1.2, Kd = 10.0, limits between -100 and +100. \nAdd a timer to only set the PID controller to automatic mode after 10 seconds.\n\nUse pre-specified function blocks. \nAssign each used function module to a local variable, do not call it directly.\nDo not include comments in the code. Do not use // or (* *).\nDo not write code for the inner body of instantiated function blocks.\nUse upper-case letters and underscores for function block names.\nUse lower-case and upper-case letters for variable names.\nDo not provide explanations, only the source code.\n\nThe generated ST Code must follow this format:\n\nFUNCTION_BLOCK <name of the function block>\nVAR_INPUT (** here define input variables **) END_VAR\nVAR_OUTPUT (** here define output variables **) END_VAR\nVAR (** here define internal temp variables **) END_VAR\n(** here write ST code of this function block**) \nEND_FUNCTION_BLOCK\n"
] |
2024-01-10 | myrithok/James | api~jamesLDA.py | # Library imports
from gensim.models import coherencemodel, ldamodel, wrappers
import os
import sys
# Add James to path
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
# Project imports
from api.jamesClasses import jamesResults
from api.jamesConfig import cfg
def buildTopicModel(corpus, topicNum):
'''
This method is used to build a gensim topic model with the given number of
topics for a given corpus.
Parameters
----------
corpus: jamesCorpus
the corpus to be modeled, as a jamesCorpus
object (imported from jamesClasses)
topicNum: int
the number of topics to generate
Output
------
gensim.models.ldamodel
the topic model generated from the input corpus
'''
# Add the path to mallet, imported from jamesConfig, to the environment
os.environ['MALLET_HOME'] = cfg['path']['malletpath']
# Build the topic model for the given number of topics using mallet, which
# is built locally, and a mallet wrapper imported from gensim.models
malletModel = wrappers.LdaMallet(cfg['path']['malletfile'], corpus=corpus.getBoW(), num_topics=topicNum, id2word=corpus.dic,
random_seed=cfg['malletsettings']['random_seed'])
# Convert the mallet model to an ldamodel
ldaModel = wrappers.ldamallet.malletmodel2ldamodel(malletModel,
gamma_threshold=cfg['malletsettings']['gamma_threshold'],
iterations=cfg['malletsettings']['iterations'])
# Return the topic model
return ldaModel
def buildCoherenceModel(topicModel, corpus):
'''
This method is used to construct a coherencemodel (imported from gensim.models)
from a generated topic model and the corpus.
Parameters
----------
topicModel: gensim.models.ldamodel
the topic model used to build the coherence model
corpus: jamesCorpus
the corpus used to generate the topic model
Output
------
gensim.models.coherencemodel
a coherence model (imported from gensim.models) for the input
topic model
'''
return coherencemodel.CoherenceModel(model=topicModel, texts=corpus.getLemmatized(),
dictionary=corpus.dic, corpus=corpus.getBoW(),
coherence=cfg['coherencetype'])
def getResults(topicModel, coherenceModel, corpus):
'''
This method is used to construct a jamesResults object (imported from jamesClasses)
containing the topic results of a given topic model, coherence model, and corpus
Parameters
----------
topicModel: gensim.models.ldamodel
the topic model whose results are being returned
coherenceModel: gensim.models.coherencemodel
the coherence model for the given topic model
corpus: jamesCorpus
the corpus used to generate the input topic model as a
jamesCorpus object (imported from jamesClasses)
Output
------
jamesResults
a jamesResults object (imported from jamesClasses) containing
the topic results
'''
return jamesResults([topic[0] for topic in topicModel.top_topics(corpus.getBoW(),topn=cfg['topicwords'])],
float(coherenceModel.get_coherence()),
[float(coherence) for coherence in coherenceModel.get_coherence_per_topic()])
def getTopics(bow, topicModel):
'''
This method is used to find the topic distribution of a given document or sentence
It is used by jamesMain to find the topic distribution of documents for the result set,
and to find the topic distribution of each sentence for sentiment weighting
Parameters
----------
bow: list
a preprocessed bag of words to be checked against the topic model
topicModel: gensim.models.ldamodel
the topic model being used to check the topics of a bag of words
Output
------
list
the topic distribution as a list of (topic number, weight) pairs, where
the topic number is an integer, and the weight is a float
'''
return topicModel.get_document_topics(bow, minimum_probability=cfg['malletsettings']['minimum_probability'])
| [] |
2024-01-10 | caressgents/close | bot_main.py | import time
from multiprocessing import Process, Event
from flask import Flask, jsonify
from config import CRM_PHONE_NUMBER
from crm_api import CRMAPI
import re
import logging
import os
import openai
import sys
# Define a Handler which writes INFO messages or higher to the sys.stderr (this could be your console)
console = logging.StreamHandler(sys.stderr)
console.setLevel(logging.INFO)
# Define a Handler for the log file
file_handler = logging.FileHandler('app.log')
file_handler.setLevel(logging.DEBUG)
# Set a format which is simpler for console use
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(name)s - %(message)s')
# Tell the handler to use this format
console.setFormatter(formatter)
file_handler.setFormatter(formatter)
logging.basicConfig(
level=logging.DEBUG,
handlers=[file_handler, console]
)
app = Flask(__name__)
bot_thread = None
crm_api = CRMAPI()
# Initialize OpenAI with your API key
openai.api_key = os.getenv("OPENAI_API_KEY")
def get_wall_height(sms_text):
logging.info(f"Analyzing SMS text for wall height: {sms_text}")
prompt = f"In the following SMS text, a customer is discussing the wall height of a trailer they're interested in. The height will be a number somewhere in their response, either 2, 3, or 4, possibly 2', 4', 5' and will be in their natural language or conversation, here is the text you need to analyze and extract the single digit wall height from: \"{sms_text}\". Could you tell me the wall height the customer is referring to? YOU MUST respond with a single numerical digit only, no additional text or explanation."
response = openai.ChatCompletion.create(
model="gpt-4",
messages=[
{"role": "system", "content": "You are a helpful assistant and follow directions perfectly"},
{"role": "user", "content": prompt},
]
)
wall_height_response = response['choices'][0]['message']['content'].strip()
# Extract just the number from the AI's response
match = re.search(r'\d+', wall_height_response)
if match is not None:
wall_height = match.group()
else:
wall_height = "No wall height found in the response"
# Or alternatively, raise a more descriptive error
# raise ValueError("No wall height found in the response")
logging.info(f"Extracted wall height: {wall_height}")
return wall_height
def extract_information(lead_data):
logging.debug(f"Extracting information from lead data: {lead_data}")
notes = [note['note'] for note in lead_data.get('notes', [])]
combined_data = ' '.join(notes)
hitch_type_pattern = r"(bumper pull|gooseneck)"
trailer_size_pattern = r"(6x10|6x12|7x14|7x16|7x18|7x20|8x20)"
hitch_type = re.search(hitch_type_pattern, combined_data, re.IGNORECASE)
trailer_size = re.search(trailer_size_pattern, combined_data)
if hitch_type:
hitch_type = hitch_type.group(0)
if trailer_size:
trailer_size = trailer_size.group(0)
return hitch_type, trailer_size
def select_template(hitch_type, trailer_size, wall_height, templates):
logging.info(f"Selecting template for hitch type: {hitch_type}, trailer size: {trailer_size}, wall height: {wall_height}") # Add this line
# Format the attributes into a string similar to template names
formatted_attributes = f"{hitch_type} {trailer_size}x{wall_height}"
# Normalize the attributes string to compare with normalized template names
normalized_attributes = formatted_attributes.lower().replace(' ', '')
for template in templates:
# Normalize the template name
normalized_template_name = template['name'].lower().replace(' ', '')
if normalized_attributes in normalized_template_name:
logging.info(f"Selected template: {template}") # Add this line
return template
logging.info("No matching template found") # Add this line
return None
def analyze_data_with_ai(data):
# Use OpenAI's GPT-4 model to analyze the data
logging.debug(f"Sending data to AI for analysis: {data}")
logging.info(f"Analyzing data with AI: {data}")
response = openai.ChatCompletion.create(
model="gpt-4",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": data},
]
)
ai_response = response['choices'][0]['message']['content'].strip()
logging.info(f"AI response: {ai_response}")
return
def run_bot():
logging.debug("Starting bot run...")
logging.info("Running the bot...")
specific_statuses = ['stat_GKAEbEJMZeyQlU7IYFOpd6PorjXupqmcNmmSzQBbcVJ',
'stat_6cqDnnaff2GYLV52VABicFqCV6cat7pyJn7wCJALGWz']
# Fetch all leads with the specific statuses
lead_ids = crm_api.get_leads_with_specific_statuses(specific_statuses)
logging.info(f"Fetched {len(lead_ids)} leads with the specific statuses.")
# Keep track of leads that have been processed
processed_leads = []
while True:
try:
templates = crm_api.get_sms_templates()
logging.info(f"Fetched {len(templates)} templates.")
sent_counter = 0
human_intervention_counter = 0
failed_counter = 0
# Process all leads, not just the new incoming ones
for lead_id in lead_ids:
# Skip if lead has already been processed
if lead_id in processed_leads:
continue
try:
logging.info(f"Processing lead {lead_id}...")
incoming_sms = crm_api.get_latest_incoming_sms(lead_id)
outgoing_sms = crm_api.get_latest_outgoing_sms(lead_id)
# Proceed only if there's a new incoming SMS that hasn't been responded to yet
if incoming_sms is not None and (outgoing_sms is None or incoming_sms["date_created"] > outgoing_sms["date_created"]):
lead_data = crm_api.get_lead_data(lead_id)
if lead_data is None:
logging.error(f"Failed to get lead data for lead {lead_id}")
continue
# Extract the first phone number of the first contact
contacts = lead_data.get('contacts', [])
if contacts and 'phones' in contacts[0] and contacts[0]['phones']:
remote_phone = contacts[0]['phones'][0]['phone']
else:
logging.error(f"No phone number found for lead {lead_id}")
continue
lead_data['notes'] = crm_api.get_lead_notes(lead_id)
hitch_type, trailer_size = extract_information(lead_data)
if hitch_type is None or trailer_size is None:
logging.info("Insufficient lead data for hitch type or trailer size")
continue
wall_height = get_wall_height(incoming_sms['text'])
if wall_height:
template = select_template(hitch_type, trailer_size, wall_height, templates)
if template:
ai_response = analyze_data_with_ai(incoming_sms['text'])
logging.info(f"AI response for incoming SMS: {ai_response}")
if crm_api.send_message(lead_id, '', incoming_sms['id'], template['id']):
sent_counter += 1
logging.info(f"Successfully sent SMS template for lead {lead_id}")
else:
crm_api.update_lead_status(lead_id, 'stat_w1TTOIbT1rYA24hSNF3c2pjazxxD0C05TQRgiVUW0A3')
human_intervention_counter += 1
logging.info(f"Updated status to 'Human Intervention' for lead {lead_id} due to SMS sending failure")
else:
crm_api.update_lead_status(lead_id, 'stat_w1TTOIbT1rYA24hSNF3c2pjazxxD0C05TQRgiVUW0A3')
human_intervention_counter += 1
logging.info(f"Updated status to 'Human Intervention' for lead {lead_id} due to no matching template")
else:
crm_api.update_lead_status(lead_id, 'stat_w1TTOIbT1rYA24hSNF3c2pjazxxD0C05TQRgiVUW0A3')
human_intervention_counter += 1
logging.info(f"Updated status to 'Human Intervention' for lead {lead_id} due to no valid wall height found in SMS")
except Exception as e:
logging.exception(f"Failed to process lead {lead_id}")
failed_counter += 1
# Add lead to the list of processed leads
processed_leads.append(lead_id)
logging.info(f"Sent {sent_counter} messages, marked {human_intervention_counter} leads for human intervention, failed to process {failed_counter} leads")
except Exception as e:
logging.exception("Failed to fetch tasks")
time.sleep(5)
@app.route('/start', methods=['POST'])
def start_bot():
logging.debug("Received start request")
global bot_thread
if bot_thread is None or not bot_thread.is_alive():
bot_thread = Thread(target=run_bot)
bot_thread.start()
logging.info("Bot thread started.")
return jsonify(success=True)
@app.route('/stop', methods=['POST'])
def stop_bot():
logging.debug("Receieved stop request")
global bot_thread
if bot_thread is not None and bot_thread.is_alive():
bot_thread = None
logging.info("Bot thread stopped.")
return jsonify(success=True)
@app.route('/logs', methods=['GET'])
def get_logs():
logging.debug("Received logs request")
with open('app.log', 'r') as f:
return f.read()
if __name__ == "__main__":
app.run(host='0.0.0.0', port=5000) | [
"In the following SMS text, a customer is discussing the wall height of a trailer they're interested in. The height will be a number somewhere in their response, either 2, 3, or 4, possibly 2', 4', 5' and will be in their natural language or conversation, here is the text you need to analyze and extract the single digit wall height from: \"PLACEHOLDER\". Could you tell me the wall height the customer is referring to? YOU MUST respond with a single numerical digit only, no additional text or explanation.",
"You are a helpful assistant.",
"You are a helpful assistant and follow directions perfectly",
"placeholder"
] |
2024-01-10 | jflynn93/streamlit-example | streamlit_app.py | #import tensorflow as tf
import openai
import pinecone
import streamlit as st
from time import sleep
from PIL import Image
title = '<p style="font-family:Calibri;color:#006A4E;font-size: 42px;">Budd-E</p>'
st.markdown(title,unsafe_allow_html=True)
if 'user_input' not in st.session_state:
st.session_state['user_input'] = ''
if 'generated' not in st.session_state:
st.session_state['generated'] = []
if 'past' not in st.session_state:
st.session_state['past'] = []
if 'query' not in st.session_state:
st.session_state['query'] = ''
# get secret vars
openai.api_key = st.secrets["OPENAI_API_KEY"]
pinecone_api_key = st.secrets["pinecone_api_key"]
my_environ = st.secrets["my_environ"]
# set embedding model
index_name = st.secrets["index_name"]
def generate_response(prompt):
completion = openai.Completion.create(
engine = 'text-davinci-003',
prompt=prompt,
max_tokens = 1024,
n=1,
stop=None,
temperature=0.1
)
message = completion['choices'][0]['text'].strip()
return message
def retrieve_base(query):
res = openai.Embedding.create(
input = [query],
model = "text-embedding-ada-002"
)
xq = res['data'][0]['embedding']
res = index.query(xq,top_k=3,include_metadata=True)
context = [
x['metadata']['text'] for x in res['matches']
]
prompt_start = (
"Answer the question based on the context below. Act as a very knowledgeable, friendly, stoner.\n\n"+
"Context:\n"
)
prompt_end = (
f"\n\nQuestion: {query}\nAnswer:"
)
for i in range(0,len(context)):
if len("\n\n---\n\n".join(context[:i])) >= 3750:
prompt = (
prompt_start +
"\n\n---\n\n".join(context[:i-1])+
prompt_end
)
break
elif i == len(context)-1:
prompt = (
prompt_start +
"\n\n---\n\n".join(context)+
prompt_end
)
return prompt
# initialize connection to pinecone
pinecone.init(
api_key=pinecone_api_key,
environment=my_environ # may be different, check at app.pinecone
)
# Send to pinecone
index = pinecone.Index(index_name)
def clear_submit():
st.session_state.query = st.session_state.input
st.session_state.input = ''
query = st.text_area("Provide a prompt",key='input',on_change = clear_submit)
if st.session_state.query:
st.session_state['user_input']=st.session_state.query
with st.spinner("Loading"):
output = generate_response(retrieve_base(st.session_state.user_input))
st.session_state['past'].append(st.session_state.user_input)
st.session_state['generated'].append(output)
if st.session_state.generated:
for i in range(len(st.session_state['generated'])-1,-1,-1):
container = st.container()
col1, col2 = container.columns([4,20])
with col1:
col1.image(Image.open('face.png').resize((50,29)) )
with col2:
st.write(st.session_state['past'][i],is_user=True,key=str(i)+'_user')
container = st.container()
col1, col2 = container.columns([4,20])
with col1:
col1.image(Image.open('weed.png').resize((40,40)) )
with col2:
st.write(st.session_state["generated"][i],key=str(i))
container.divider()
| [
"\n\nQuestion: PLACEHOLDER\nAnswer:",
"\n\n---\n\n",
"Answer the question based on the context below. Act as a very knowledgeable, friendly, stoner.\n\nContext:\n"
] |
2024-01-10 | junison17/langchain | essay.py | from dotenv import load_dotenv
load_dotenv()
import streamlit as st
from langchain.chat_models import ChatOpenAI
chat_model = ChatOpenAI()
st.title('에세이 작성')
content = st.text_input('주제를 정해주세요.')
if st.button('요청하기'):
with st.spinner('waiting...'):
result = chat_model.predict(content+"에대한 essay를 모두에게 공감이가고 낭만적으로 에세이 문장구조에 맞게 작성하고줘")
st.write(result) | [] |
2024-01-10 | jpfariaa/chatbot-2.0 | loader.py | from flask import Flask, request
from twilio.twiml.messaging_response import MessagingResponse
from langchain.document_loaders.base import Document
from langchain.indexes import VectorstoreIndexCreator
from langchain.utilities import ApifyWrapper
import os
os.environ["OPENAI_API_KEY"] = "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"
os.environ["APIFY_API_TOKEN"] = "apify_api_F0dQ71Q5UMGCj6FpKgNk7FnD6BDgCF1TZTZv"
apify = ApifyWrapper()
loader = apify.call_actor(
actor_id="apify/website-content-crawler",
run_input={"startUrls": [{"url": "https://www.vitoria.es.gov.br/perguntas_respostas.php"}]},
dataset_mapping_function=lambda item: Document(
page_content=item["text"] or "", metadata={"source": item["url"]}
),
)
index = VectorstoreIndexCreator().from_loaders([loader])
app = Flask(__name__)
@app.route("/whatsapp", methods=['POST'])
def whatsapp_reply():
"""Responde a mensagens de WhatsApp entrantes."""
incoming_message = request.values.get('Body', '').lower()
print(incoming_message)
# result = index.query_with_sources(query)
resp = MessagingResponse()
msg = resp.message()
msg.body(str(incoming_message))
return str(resp)
if __name__ == "main":
app.run(debug=True)
| [] |
2024-01-10 | tuyojr/ISW_TA | python~gui_programming.py | from tkinter import *
from tkinter import filedialog as fd
import tkinter.messagebox
from PIL import Image, ImageTk
import time
import wikipedia
from gtts import gTTS
import os
import speech_recognition as sr
import pyttsx3
import openai
# # this is a GUI module
# # tkinter is an interface to the Tk GUI toolkit
# # Frame is a predefined class in tkinter. It is a container widget which is used to contain other widgets.
# # It works like a container which is responsible for arranging the position of other widgets.
# class Window(Frame):
# def __init__(self, master = None):
# Frame.__init__(self, master)
# self.master = master
# # root is the main window
# # initialize the tkinter window
# root = Tk()
# # object of the frame class
# app = Window(root)
# # set the window title
# root.wm_title("GUI Programming")
# # mainloop() is an infinite loop used to run the application,
# # wait for an event to occur and process the event as long as the window is not closed
# root.mainloop()
# BUTTON CLASS
# class Window(Frame):
# def __init__(self, master = None):
# Frame.__init__(self, master)
# self.master = master
# # widget can take all window
# self.pack(fill=BOTH, expand=1)
# # create a button instance and link it to the callback function (exit button)
# exitButton = Button(self, text="Exit", fg='white', bg='gray', command=self.clickExitButton)
# # place the button at the top left corner
# # exitButton.place(x=0, y=0)
# exitButton.pack(side=LEFT)
# def clickExitButton(self):
# print("Exit button clicked.")
# exit()
# root = Tk()
# app = Window(root)
# root.wm_title("Tkinter Button")
# root.geometry("320x200")
# root.mainloop()
# def dowork():
# print("Hello World!")
# def exit_frame():
# print("Program exited successfully!")
# exit()
# root = Tk()
# root.wm_title("Tkinter Test")
# root.geometry('320x200')
# f = Frame(root)
# # pack the frame into the root window
# f.pack()
# b = Button(f, text='Say', command=dowork)
# # pack the button into the frame which is inside the root window.
# b.pack()
# b2 = Button(f, text='Exit', fg='white', bg='gray', command=exit_frame)
# b2.pack()
# root.mainloop()
# MENU CLASS
# class Window(Frame):
# def __init__(self, master=None):
# Frame.__init__(self, master)
# self.master = master
# menu = Menu(self.master)
# self.master.config(menu=menu)
# fileMenu = Menu(menu)
# fileMenu.add_command(label="Item")
# fileMenu.add_command(label="Exit", command=self.exitProgram)
# menu.add_cascade(label="File", menu=fileMenu)
# editMenu = Menu(menu)
# editMenu.add_command(label="Undo")
# editMenu.add_command(label="Redo")
# menu.add_cascade(label="Edit", menu=editMenu)
# databaseMenu = Menu(menu)
# databaseMenu.add_command(label="Insert", command=self.insert)
# databaseMenu.add_command(label="Update", command=self.update)
# databaseMenu.add_command(label="Create", command=self.create)
# databaseMenu.add_command(label="Delete", command=self.delete)
# menu.add_cascade(label="Database", menu=databaseMenu)
# def exitProgram(self):
# print("Program exited successfully!")
# exit()
# def insert(self):
# print("Records inserted to database successfully!")
# def update(self):
# print("Database record updated successfully!")
# def create(self):
# print("Table created in database successfully!")
# def delete(self):
# print("Record deleted from database successfully!")
# root = Tk()
# app = Window(root)
# root.wm_title("Menu Window")
# root.mainloop()
# LABEL CLASS
# class Window(Frame):
# def __init__(self, master=None):
# Frame.__init__(self, master)
# self.master = master
# self.pack(fill=BOTH, expand=1)
# text = Label(self, text='Just do it')
# text.place(x=7, y=90)
# # text.pack()
# root = Tk()
# app = Window(root)
# root.wm_title("Label Window")
# root.geometry("700x600")
# root.mainloop()
# class App(Frame):
# def __init__(self, master=None):
# Frame.__init__(self, master)
# self.master = master
# self.label = Label(text="", fg='blue', font=("Helvetica", 18))
# self.label.place(x=50, y=80)
# self.update_clock()
# def update_clock(self):
# now = time.strftime("%H:%M:%S")
# self.label.config(text=now)
# self.after(1000, self.update_clock)
# root = Tk()
# app = App(root)
# root.wm_title("Label Class Window")
# root.geometry("200x200")
# root.after(1000, app.update_clock)
# root.mainloop()
# # IMAGE CLASS
# class Window(Frame):
# def __init__(self, master=None):
# Frame.__init__(self, master)
# self.master = master
# self.pack(fill=BOTH, expand=1)
# load = Image.open("C:\\Users\\Adedolapo.Olutuyo\\Documents\\ISW_TA\\python\\shisui.jpg")
# # load = Image.urlopen("https://github.com/tuyojr/ISW_TA/blob/main/python/shisui.jpg")
# render = ImageTk.PhotoImage(load)
# img = Label(self, image=render)
# img.image = render
# img.place(x=0,y=0)
# root = Tk()
# app = Window(root)
# root.wm_title("Image and Label")
# root.geometry("700x500")
# root.mainloop()
# Tkinter Scale
# SCALE CLASS
# allows you add a scale or a slider to your window. Example is a volume control.
# It has a minimum and maximum value you can define
# window = Tk()
# window.title("Scale Window")
# window.geometry("500x300")
# label = Label(window, bg='white', fg='black', width=20, text='empty')
# label.pack()
# def print_selection(v):
# label.config(text='you have selected ' + v)
# scale = Scale(window, label='try me', from_=0, to=10, orient=VERTICAL, length=200, showvalue=0, tickinterval=1, resolution=0.01, command=print_selection)
# scale.pack()
# window.mainloop()
# # Tkinter Frame
# # it lets you organize and group widgets
# # 1. pack() - it organizes widgets in blocks before placing them in the parent widget
# # 2. grid() - it organizes widgets in a table-like structure in the parent widget
# def say_hi():
# print("hello ~ l")
# root = Tk()
# frame1 = Frame(root)
# frame2 = Frame(root)
# root.title("tkinter frame")
# label=Label(frame1, bg="gray", text="Label", justify=LEFT)
# label.pack(side=LEFT)
# hi_there = Button(frame2, bg="cyan", text="say hi", command=say_hi)
# hi_there.pack()
# frame1.pack(padx=1,pady=1)
# frame2.pack(padx=10,pady=10)
# root.mainloop()
# # Tkinter Frame Photo
# # this example adds a photo to the frame
# root = Tk()
# textLabel = Label(root, text="Label", justify=LEFT, padx=10,)
# textLabel.pack(side=LEFT)
# image = Image.open("C:\\Users\\Adedolapo.Olutuyo\\Documents\\ISW_TA\\python\\shisui.jpg")
# photo = ImageTk.PhotoImage(image)
# imgLabel = Label(root, image=photo)
# imgLabel.pack(side=RIGHT)
# mainloop()
# # Tkinter Listbox
# # A listbox shows a list of options. It won't do anything by default.
# # You can link a list box to a function.
# # To add new items, you can use the insert() method.
# window = Tk()
# window.title("Listbox Window")
# window.geometry('500x300')
# var1 = StringVar()
# label = Label(window, bg='gray', fg='black', font=('Arial', 12), width=10, textvariable=var1)
# label.pack()
# def print_selection():
# value = listbox_object.get(listbox_object.curselection())
# var1.set(value)
# button1 = Button(window, text='print selection', width=15, height=2, command=print_selection)
# button1.pack()
# var2 = StringVar()
# var2.set((1, 2, 3, 4))
# listbox_object = Listbox(window, listvariable=var2)
# list_items = [11, 22, 33, 44]
# for item in list_items:
# listbox_object.insert('end', item)
# listbox_object.insert(1, 'first')
# listbox_object.insert(2, 'second')
# listbox_object.delete(2)
# listbox_object.pack()
# window.mainloop()
# # Tkinter Messagebox
# # it is a little popup showing a message. Sometimes it is accompanied by an icon.
# def buttonClick():
# tkinter.messagebox.showinfo('PopUp', 'SIKE!!!')
# # tkinter.messagebox.showwarning('title', 'message')
# # tkinter.messagebox.showerror('title', 'message')
# root = Tk()
# root.title('PopUpBox')
# root.geometry('100x100')
# root.resizable(True, False)
# Button(root, text='click me!', command=buttonClick).pack()
# root.mainloop()
# def callback():
# name = fd.askopenfilename()
# image = Image.open(name)
# resized = image.resize((384, 240))
# photo = ImageTk.PhotoImage(resized)
# imgLabel = Label(image=photo)
# imgLabel.image = photo
# imgLabel.pack()
# error_message = 'Erorr!'
# Button(text='Click to Open File', command=callback).pack(fill=X)
# mainloop()
# # Tkinter Canvas
# root = Tk()
# # create canvas
# myCanvas = Canvas(root, bg='white', height=300, width=300)
# # draw arcs
# coord = 10, 10, 100, 100
# arc = myCanvas.create_arc(coord, start=0, extent=150, fill='gray')
# arc2 = myCanvas.create_arc(coord, start=150, extent=215, fill='cyan')
# line = myCanvas.create_line(300, 300, 10, 10, fill='red')
# # add window to show
# myCanvas.pack()
# root.mainloop()
# # Tkinter Entry
# # It allows users input text into the desktop software.
# # It comes with a label and an input field.
# top = Tk()
# label = Label(top, text='Username')
# label.pack(side=LEFT)
# entry = Entry(top, bd=5)
# entry.pack(side=RIGHT)
# top.mainloop()
# top = Tk()
# label = Label(top, text='Username')
# label.pack(side=LEFT)
# var1 = StringVar()
# entry = Entry(top, bd=5, textvariable=var1)
# entry.pack(side=LEFT)
# def link():
# print(var1.get())
# button = Button(top, text='Submit', command=link)
# button.pack()
# top.mainloop()
# window = Tk()
# window.title("Entry Window")
# window.geometry('500x300')
# entry1 = Entry(window, show=None, font=('Arial', 14))
# entry2 = Entry(window, show='@', font=('Arial', 14))
# entry1.pack()
# entry2.pack()
# window.mainloop()
# # Tkinter Radiobutton
# # It lets you select from a variety of items. It is similar to a listbox.
# # It only lets you select just one option.
# # You can achieve that by adding the same variable as parameter for radiobuttons.
# window = Tk()
# window.title("Radiobutton Window")
# window.geometry('500x300')
# var = StringVar()
# var.set(' ')
# label = Label(window, bg='white', width=20, text='empty')
# label.pack()
# def print_selection():
# label.config(text='you have selected ' + var.get())
# radio_button1 = Radiobutton(window, text='Option A', variable=var, value='A')
# radio_button1.pack()
# radio_button2 = Radiobutton(window, text='Option B', variable=var, value='B')
# radio_button2.pack()
# radio_button3 = Radiobutton(window, text='Option C', variable=var, value='C')
# radio_button3.pack()
# button = Button(window, text='print selection', width=13, height=1, command=print_selection)
# button.pack()
# window.mainloop()
# # Tkinter Checkbox
# # It lets you select multiple options. They are like on/off switches and there can be multiple of them.
# # You can achieve that by adding the same variable as parameter for checkboxes.
# window = Tk()
# window.title("Checkbox Window")
# window.geometry('500x300')
# label = Label(window, bg='white', width=20, text='empty')
# label.pack()
# def print_selection():
# if (var1.get() == 1) & (var2.get() == 0):
# label.config(text='I love only Python')
# elif (var1.get() == 0) & (var2.get() == 1):
# label.config(text='I love only C++')
# elif (var1.get() == 0) & (var2.get() == 0):
# label.config(text='I do not love either')
# else:
# label.config(text='I love both')
# var1 = IntVar()
# var2 = IntVar()
# checkbox1 = Checkbutton(window, text='Python', variable=var1, onvalue=1, offvalue=0)
# checkbox1.pack()
# checkbox2 = Checkbutton(window, text='C++', variable=var2, onvalue=1, offvalue=0)
# checkbox2.pack()
# button = Button(window, text='print selection', width=13, height=1, command=print_selection)
# button.pack()
# window.mainloop()
# # Tkinter Wikipedia Module
# # The wikipedia module is a multilingual module that lets you search for articles on wikipedia.
# # finding result for a search
# # sentences = 10 refers to the numbers of line
# result = wikipedia.summary("Sherlock Holmes", sentences=10)
# # printing the result
# print(result)
# # Tkinter Google Text to Speech (gTTS) Module
# myTxt = "All the heavens and all the hells are within you!"
# language = 'en'
# myobj = gTTS(text=myTxt, lang=language, slow=False)
# myobj.save("h_and_h.mp3")
# os.system('mediaplayer h_and_h.mp3')
# # combining tkinter, wikipedia, and gTTS
# window = Tk()
# window.title("Wikipedia and gTTS")
# window.geometry('500x300')
# entry = Entry(window, show=None, font=('Arial', 14))
# entry.pack()
# def search():
# result = wikipedia.summary(entry.get(), sentences=2)
# language = 'en'
# resultObj = gTTS(text=result, lang=language, slow=False)
# print("Search Found!")
# resultObj.save("result.mp3")
# os.system('mediaplayer result.mp3')
# button = Button(window, text='Search', width=13, height=1, command=search)
# button.pack()
# window.mainloop()
# # pip install speechrecognition
# # pip install pyaudio
# def recognize_speech():
# r = sr.Recognizer() #initialize the recognizer
# with sr.Microphone() as source:
# audio1 = r.listen(source)
# mytext = r.recognize_google(audio1)
# mytext = mytext.lower()
# print(mytext)
# # Create the main Tkinter window
# window = Tk()
# window.title("Speech Recognition")
# # Create a button to start speech recognition
# recognize_button = Button(window, text="Recognize Speech", command=recognize_speech)
# recognize_button.pack()
# # Start the Tkinter event loop
# window.mainloop()
# def wiiki():
# res= wikipedia.summary(recognize_speech())
# text_entry.insert(END, res)
# def recognize_speech():
# recognizer = sr.Recognizer()
# with sr.Microphone() as source:
# audio = recognizer.listen(source)
# try:
# recognized_text = recognizer.recognize_google(audio)
# text_entry.delete(1.0, END) # Clear previous text
# except sr.UnknownValueError:
# text_entry.delete(1.0, END) # Clear previous text
# text_entry.insert(END, "Speech recognition could not understand audio")
# except sr.RequestError as e:
# text_entry.delete(1.0, END) # Clear previous text
# text_entry.insert(END, f"Could not request results from Google Speech Recognition service; {e}")
# return recognized_text
# # Create the main Tkinter window
# window = Tk()
# window.title("Speech To Text To Wiki")
# window.geometry('400x400')
# # Create a text entry field
# text_entry = Text(window, height=10, width=50)
# text_entry.pack()
# # Create a button to start speech recognition
# recognize_button = Button(window, text="Recognize Speech", command=wiiki)
# recognize_button.pack()
# window.mainloop()
# # Start the Tkinter event loop
# openai.api_key = "api_key"
# prompt = "The future is now, no?."
# model = "text-davinci-003"
# response = openai.Completion.create(engine=model, prompt=prompt, max_tokens=50)
# generated_text = response.choices[0].text
# print(generated_text) | [] |
2024-01-10 | merrickfox/LLM-APIs | guidance-cloud-api~guidance-broker~guidance-api.py | from flask import Flask, request, jsonify
import guidance
import os
import time
import requests
import json
import sys
import logging
port_number = os.getenv('TG_GUIDANCE_PORT_NUMBER', '9555')
guidance_url = f"http://127.0.0.1:{port_number}"
api_endpoint = f"http://127.0.0.1:{port_number}/api/v1/call"
print("guidance_url: ", guidance_url, file=sys.stdout)
timeout_limit = 60 * 60 # Timeout limit set to 60 minutes
time_start = time.time()
# Headers and data for the post request
headers = {
"Content-Type": "application/json",
}
data = {
"prompt": "Hello, world!",
"stop": ["stop_token"],
"stop_regex": "stop_regex",
"temperature": 0.5,
"n": 1,
"max_tokens": 200,
"logprobs": 10,
"top_p": 1.0,
"echo": False,
"logit_bias": {},
"token_healing": True,
"pattern": "pattern"
}
while True:
try:
print("Attempting to connect to guidance...", file=sys.stdout)
response = requests.post(api_endpoint, headers=headers, data=json.dumps(data))
if response.status_code == 200:
break
except requests.ConnectionError:
print("Connection refused waiting to retry....", file=sys.stdout)
time.sleep(10)
if time.time() - time_start > timeout_limit:
print("Connection timeout", file=sys.stderr)
raise Exception("Connection timeout")
guidance.llm = guidance.llms.TGWUI(guidance_url)
app = Flask(__name__)
logging.getLogger('flask').addHandler(logging.StreamHandler())
@app.route('/guidance-api', methods=['POST'])
def do_guidance_call():
try:
print("Received request at /guidance-api", file=sys.stdout) # Log at the start of function
data = request.get_json()
args = data.get('args', {})
res_fields = data.get('res_fields', [])
payload = data.get('payload', "")
print("payload: ", payload, file=sys.stdout)
execute_prompt = guidance(payload)
res = execute_prompt(**args)
print("res: ", res["response"], file=sys.stdout)
res_dict = {field: getattr(res, field, None) for field in res_fields}
return jsonify({"data": res_dict})
except Exception as e:
print("An error occurred:", e, file=sys.stderr) # Log exceptions
logging.exception(e)
return jsonify({"error": str(e)})
if __name__ == '__main__':
app.run(host='0.0.0.0', port=8181)
| [] |
2024-01-10 | lshang0311/genai-notes | chunking_strategies.py | from langchain.text_splitter import CharacterTextSplitter
"""
https://www.pinecone.io/learn/chunking-strategies/
Issues with `Chunking`:
If our chunks are too small or too large, it may lead to imprecise search results or missed opportunities to surface
relevant content.
"""
# TODO:
| [] |
2024-01-10 | lshang0311/genai-notes | LangSmith~run_langsmith_example.py | from langchain.chat_models import ChatOpenAI
llm = ChatOpenAI()
response = llm.predict("Hello!")
print(response)
| [] |
2024-01-10 | lshang0311/genai-notes | how_to_call_functions_with_chat_models.py | import json
import openai
import requests
from tenacity import retry, wait_random_exponential, stop_after_attempt
from termcolor import colored
GPT_MODEL = "gpt-3.5-turbo-0613"
"""
How to call functions with chat models
Ref:
https://github.com/openai/openai-cookbook/blob/main/examples/How_to_call_functions_with_chat_models.ipynb
"""
@retry(wait=wait_random_exponential(min=1, max=40), stop=stop_after_attempt(3))
def chat_completion_request(messages, functions=None, function_call=None, model=GPT_MODEL):
headers = {
"Content-Type": "application/json",
"Authorization": "Bearer " + openai.api_key,
}
json_data = {"model": model, "messages": messages}
if functions is not None:
json_data.update({"functions": functions})
if function_call is not None:
json_data.update({"function_call": function_call})
try:
response = requests.post(
"https://api.openai.com/v1/chat/completions",
headers=headers,
json=json_data,
)
return response
except Exception as e:
print("Unable to generate ChatCompletion response")
print(f"Exception: {e}")
return e
# ex - 1
messages = []
messages.append({
"role": "system",
"content": "Don't make assumptions about what values to plug into functions. "
"Ask for clarification if a user request is ambiguous."
})
messages.append({"role": "user", "content": "What's the weather like today"})
chat_response = chat_completion_request(
messages
)
assistant_message = chat_response.json()["choices"][0]["message"]
print(assistant_message)
"""
Output of `assistant_message`:
{'role': 'assistant', 'content': "I'm sorry, but you didn't mention the location. Can you please provide me with the name of the city or town?"}
"""
messages.append(assistant_message)
# ex -2 (add the function)
# TODO:
print()
| [
"Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous.",
"What's the weather like today"
] |
2024-01-10 | lshang0311/genai-notes | examples_llamaindex~llm_initialization.py | import os
import openai
from langchain.chat_models import AzureChatOpenAI
from langchain.embeddings import OpenAIEmbeddings
def init_llm():
OPENAI_DEPLOYMENT_NAME = os.getenv("OPENAI_DEPLOYMENT_NAME")
OPENAI_MODEL_NAME = os.getenv("OPENAI_MODEL_NAME")
openai.api_key = os.environ['OPENAI_API_KEY']
openai.api_base = os.environ['OPENAI_API_BASE']
openai.api_version = os.environ['OPENAI_API_VERSION']
openai.api_type = os.environ['OPENAI_API_TYPE']
temperature = 0
max_tokens = 5000
llm = AzureChatOpenAI(
deployment_name=OPENAI_DEPLOYMENT_NAME,
model=OPENAI_MODEL_NAME,
temperature=temperature,
max_tokens=max_tokens
)
return llm
def init_embeddings():
embeddings = OpenAIEmbeddings(
deployment=os.environ['EMBEDDING_DEPLOYMENT'],
model=os.environ['EMBEDDING_MODEL'],
openai_api_key=os.environ['Embedding_API_MY_KEY'],
openai_api_base=os.environ['EMBEDDING_OPENAI_API_BASE'],
openai_api_type=os.environ['OPENAI_API_TYPE']
)
return embeddings
| [] |
2024-01-10 | lshang0311/genai-notes | example_langchain_agent_tools.py | from langchain.agents import Tool
from langchain.agents import initialize_agent
from langchain.chat_models import ChatOpenAI
"""
See LangChain doc:
https://python.langchain.com/docs/modules/agents/tools/how_to/custom_tools
Follow this example:
https://blog.gopenai.com/langchain-agent-tools-for-running-functions-and-apis-dc123337eb4d
"""
def login(param):
"""provide your login logic/API call here and handle both cases i.e success and failure """
return {"response": "logged in successfully"}
def chat(param):
"""If you're implementing a chatbot then when user will ask for any information then you can use this function to implement that logic using langchain and openai"""
return {"response": "your response"}
def logout(param):
"""provide your logout logic/API call here and handle both cases i.e success and failure """
print(param)
return {"response": "logged out successfully"}
loginTool = Tool(
name="loginTool",
func=login,
description="use to run the login functionality"
)
logoutTool = Tool(
name="logoutTool",
func=logout,
description="use to run the logout functionality"
)
chatTool = Tool(
name="chatTool",
func=chat,
description="use when you need to give information about the project. Anything irrelevant, just say I don't know."
)
tools = [
loginTool,
logoutTool,
chatTool
]
llm = ChatOpenAI(temperature=0)
agent = initialize_agent(
tools,
llm,
agent="zero-shot-react-description",
verbose=True
)
print(agent.agent.llm_chain.prompt.template)
# TODO: reinitialize `agent.agent.llm_chain.prompt.template` for the desired behaviours
# ---------------
# Example run - 1
# ---------------
# Agent runs function `logout` with parameter `2ndw33d3fnn`
result = agent.run("logout my profile. my session id is 2ndw33d3fnn")
print(result)
# ---------------
# Example run - 2
# ---------------
# Agent runs function `chat`
result = agent.run("Hi copilot, dinner idea?")
print(result)
print()
| [] |
2024-01-10 | Abhijith14/Project-CodeTSR | davinci.py | import openai
import os
import re
def output(prompt):
openai.api_key = os.environ["OPENAI_TOKEN"]
# Set the model and prompt
model_engine = "text-davinci-003"
max_tokenG = 4096 # max for davinci-003
try:
prompt_text = openai.Completion.create(
engine=model_engine,
prompt=prompt,
max_tokens=5000,
n=1,
stop=None,
temperature=0.5,
)
except Exception as e:
match = re.search(r'\((\d+) in your prompt[\);]?', str(e))
max_tokenG = max_tokenG - int(match.group(1))
# Get the number of tokens in the generated text
generated_text = openai.Completion.create(
engine=model_engine,
prompt=prompt,
max_tokens=max_tokenG,
n=1,
stop=None,
temperature=1,
).choices[0].text
#generated_tokens = len(generated_text.split())
#print(generated_text.strip())
return generated_text.strip()
| [] |
2024-01-10 | amacati/dextgen | envs~rotations.py | """Rotation utility functions from OpenAI's mujoco-worldgen repository.
Functions have been extended to our 6D embedding.
https://github.com/openai/mujoco-worldgen/blob/master/mujoco_worldgen/util/rotation.py.
"""
# Copyright (c) 2009-2017, Matthew Brett and Christoph Gohlke
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
# IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# Many methods borrow heavily or entirely from transforms3d:
# https://github.com/matthew-brett/transforms3d
# They have mostly been modified to support batched operations.
import numpy as np
"""
Rotations
=========
Note: these have caused many subtle bugs in the past.
Be careful while updating these methods and while using them in clever ways.
See MuJoCo documentation here: http://mujoco.org/book/modeling.html#COrientation
Conventions
-----------
- All functions accept batches as well as individual rotations
- All rotation conventions match respective MuJoCo defaults
- All angles are in radians
- Matricies follow LR convention
- Euler Angles are all relative with 'xyz' axes ordering
- See specific representation for more information
Representations
---------------
Euler
There are many euler angle frames -- here we will strive to use the default
in MuJoCo, which is eulerseq='xyz'.
This frame is a relative rotating frame, about x, y, and z axes in order.
Relative rotating means that after we rotate about x, then we use the
new (rotated) y, and the same for z.
Quaternions
These are defined in terms of rotation (angle) about a unit vector (x, y, z)
We use the following <q0, q1, q2, q3> convention:
q0 = cos(angle / 2)
q1 = sin(angle / 2) * x
q2 = sin(angle / 2) * y
q3 = sin(angle / 2) * z
This is also sometimes called qw, qx, qy, qz.
Note that quaternions are ambiguous, because we can represent a rotation by
angle about vector <x, y, z> and -angle about vector <-x, -y, -z>.
To choose between these, we pick "first nonzero positive", where we
make the first nonzero element of the quaternion positive.
This can result in mismatches if you're converting an quaternion that is not
"first nonzero positive" to a different representation and back.
Axis Angle
(Not currently implemented)
These are very straightforward. Rotation is angle about a unit vector.
XY Axes
(Not currently implemented)
We are given x axis and y axis, and z axis is cross product of x and y.
Z Axis
This is NOT RECOMMENDED. Defines a unit vector for the Z axis,
but rotation about this axis is not well defined.
Instead pick a fixed reference direction for another axis (e.g. X)
and calculate the other (e.g. Y = Z cross-product X),
then use XY Axes rotation instead.
SO3
(Not currently implemented)
While not supported by MuJoCo, this representation has a lot of nice features.
We expect to add support for these in the future.
TODO / Missing
--------------
- Rotation integration or derivatives (e.g. velocity conversions)
- More representations (SO3, etc)
- Random sampling (e.g. sample uniform random rotation)
- Performance benchmarks/measurements
- (Maybe) define everything as to/from matricies, for simplicity
"""
# For testing whether a number is close to zero
_FLOAT_EPS = np.finfo(np.float64).eps
_EPS4 = _FLOAT_EPS * 4.0
def mat2euler(mat: np.ndarray) -> np.ndarray:
"""Convert Rotation Matrix to Euler Angles.
Args:
mat: Rotation matrix.
See rotation.py for notes
"""
mat = np.asarray(mat, dtype=np.float64)
assert mat.shape[-2:] == (3, 3), "Invalid shape matrix {}".format(mat)
cy = np.sqrt(mat[..., 2, 2] * mat[..., 2, 2] + mat[..., 1, 2] * mat[..., 1, 2])
condition = cy > _EPS4
euler = np.empty(mat.shape[:-1], dtype=np.float64)
euler[..., 2] = np.where(
condition,
-np.arctan2(mat[..., 0, 1], mat[..., 0, 0]),
-np.arctan2(-mat[..., 1, 0], mat[..., 1, 1]),
)
euler[..., 1] = np.where(condition, -np.arctan2(-mat[..., 0, 2], cy),
-np.arctan2(-mat[..., 0, 2], cy))
euler[..., 0] = np.where(condition, -np.arctan2(mat[..., 1, 2], mat[..., 2, 2]), 0.0)
return euler
def euler2quat(euler: np.ndarray) -> np.ndarray:
"""Convert Euler Angles to Quaternions.
See rotation.py for notes.
Args:
euler: Array of euler angles.
Returns:
An array of quaternions.
"""
euler = np.asarray(euler, dtype=np.float64)
assert euler.shape[-1] == 3, f"Invalid shape euler {euler}"
ai, aj, ak = euler[..., 2] / 2, -euler[..., 1] / 2, euler[..., 0] / 2
si, sj, sk = np.sin(ai), np.sin(aj), np.sin(ak)
ci, cj, ck = np.cos(ai), np.cos(aj), np.cos(ak)
cc, cs = ci * ck, ci * sk
sc, ss = si * ck, si * sk
quat = np.empty(euler.shape[:-1] + (4,), dtype=np.float64)
quat[..., 0] = cj * cc + sj * ss
quat[..., 3] = cj * sc - sj * cs
quat[..., 2] = -(cj * ss + sj * cc)
quat[..., 1] = cj * cs - sj * sc
return quat
def mat2quat(mat: np.ndarray) -> np.ndarray:
"""Convert Rotation Matrices to Quaternions.
See rotation.py for notes.
Args:
mat: Array of rotations matrices.
Returns:
An array of quaternions.
"""
mat = np.asarray(mat, dtype=np.float64)
assert mat.shape[-2:] == (3, 3), f"Invalid shape matrix {mat}"
Qxx, Qyx, Qzx = mat[..., 0, 0], mat[..., 0, 1], mat[..., 0, 2]
Qxy, Qyy, Qzy = mat[..., 1, 0], mat[..., 1, 1], mat[..., 1, 2]
Qxz, Qyz, Qzz = mat[..., 2, 0], mat[..., 2, 1], mat[..., 2, 2]
# Fill only lower half of symmetric matrix
K = np.zeros(mat.shape[:-2] + (4, 4), dtype=np.float64)
K[..., 0, 0] = Qxx - Qyy - Qzz
K[..., 1, 0] = Qyx + Qxy
K[..., 1, 1] = Qyy - Qxx - Qzz
K[..., 2, 0] = Qzx + Qxz
K[..., 2, 1] = Qzy + Qyz
K[..., 2, 2] = Qzz - Qxx - Qyy
K[..., 3, 0] = Qyz - Qzy
K[..., 3, 1] = Qzx - Qxz
K[..., 3, 2] = Qxy - Qyx
K[..., 3, 3] = Qxx + Qyy + Qzz
K /= 3.0
# TODO: vectorize this -- probably could be made faster
q = np.empty(K.shape[:-2] + (4,))
it = np.nditer(q[..., 0], flags=["multi_index"])
while not it.finished:
# Use Hermitian eigenvectors, values for speed
vals, vecs = np.linalg.eigh(K[it.multi_index])
# Select largest eigenvector, reorder to w,x,y,z quaternion
q[it.multi_index] = vecs[[3, 0, 1, 2], np.argmax(vals)]
# Prefer quaternion with positive w
# (q * -1 corresponds to same rotation as q)
if q[it.multi_index][0] < 0:
q[it.multi_index] *= -1
it.iternext()
return q
def fastmat2quat(mat: np.ndarray) -> np.ndarray:
"""Faster matrix to quaternion conversion.
See https://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/
"""
assert mat.shape[-2:] == (3, 3), f"Invalid shape matrix {mat}"
tr0 = 1.0 + mat[..., 0, 0] + mat[..., 1, 1] + mat[..., 2, 2]
tr1 = 1.0 + mat[..., 0, 0] - mat[..., 1, 1] - mat[..., 2, 2]
tr2 = 1.0 - mat[..., 0, 0] + mat[..., 1, 1] - mat[..., 2, 2]
tr3 = 1.0 - mat[..., 0, 0] - mat[..., 1, 1] + mat[..., 2, 2]
# Calculate which conversion to take for which matrix for best numeric stability
q = np.empty(mat.shape[:-2] + (4,))
# idx1 = np.logical_and(tr1 > tr2, tr1 > tr3)
# idx2 = np.logical_and(tr2 > tr1, tr2 > tr3)
# idx3 = np.logical_not(np.logical_or(idx1, idx2))
idx0 = tr0 > 0
nidx0 = np.logical_not(idx0)
idx1 = np.logical_and(np.logical_and(tr1 > tr2, tr1 > tr3), nidx0)
idx2 = np.logical_and(np.logical_and(tr2 > tr1, tr2 > tr3), nidx0)
idx3 = np.logical_and(np.logical_not(np.logical_or(idx1, idx2)), nidx0)
s0 = np.sqrt(tr0[idx0]) * 2
s1 = np.sqrt(tr1[idx1]) * 2
s2 = np.sqrt(tr2[idx2]) * 2
s3 = np.sqrt(tr3[idx3]) * 2
q[idx0, 0] = 0.25 * s0
q[idx0, 1] = (mat[idx0, 2, 1] - mat[idx0, 1, 2]) / s0
q[idx0, 2] = (mat[idx0, 0, 2] - mat[idx0, 2, 0]) / s0
q[idx0, 3] = (mat[idx0, 1, 0] - mat[idx0, 0, 1]) / s0
q[idx1, 0] = (mat[idx1, 2, 1] - mat[idx1, 1, 2]) / s1
q[idx1, 1] = 0.25 * s1
q[idx1, 2] = (mat[idx1, 0, 1] + mat[idx1, 1, 0]) / s1
q[idx1, 3] = (mat[idx1, 0, 2] + mat[idx1, 2, 0]) / s1
q[idx2, 0] = (mat[idx2, 0, 2] - mat[idx2, 2, 0]) / s2
q[idx2, 1] = (mat[idx2, 0, 1] + mat[idx2, 1, 0]) / s2
q[idx2, 2] = 0.25 * s2
q[idx2, 3] = (mat[idx2, 1, 2] + mat[idx2, 2, 1]) / s2
q[idx3, 0] = (mat[idx3, 1, 0] - mat[idx3, 0, 1]) / s3
q[idx3, 1] = (mat[idx3, 0, 2] + mat[idx3, 2, 0]) / s3
q[idx3, 2] = (mat[idx3, 1, 2] + mat[idx3, 2, 1]) / s3
q[idx3, 3] = 0.25 * s3
q[q[..., 0] < 0, :] *= -1 # Prefer quaternion with positive w
return q
def quat2mat(quat: np.ndarray) -> np.ndarray:
"""Convert Quaternions to Euler Angles.
See rotation.py for notes.
Args:
quat: Array of quaternions.
Returns:
An array of euler angles.
"""
quat = np.asarray(quat, dtype=np.float64)
assert quat.shape[-1] == 4, f"Invalid shape quat {quat}"
w, x, y, z = quat[..., 0], quat[..., 1], quat[..., 2], quat[..., 3]
Nq = np.sum(quat * quat, axis=-1)
s = 2.0 / Nq
X, Y, Z = x * s, y * s, z * s
wX, wY, wZ = w * X, w * Y, w * Z
xX, xY, xZ = x * X, x * Y, x * Z
yY, yZ, zZ = y * Y, y * Z, z * Z
mat = np.empty(quat.shape[:-1] + (3, 3), dtype=np.float64)
mat[..., 0, 0] = 1.0 - (yY + zZ)
mat[..., 0, 1] = xY - wZ
mat[..., 0, 2] = xZ + wY
mat[..., 1, 0] = xY + wZ
mat[..., 1, 1] = 1.0 - (xX + zZ)
mat[..., 1, 2] = yZ - wX
mat[..., 2, 0] = xZ - wY
mat[..., 2, 1] = yZ + wX
mat[..., 2, 2] = 1.0 - (xX + yY)
return np.where((Nq > _FLOAT_EPS)[..., np.newaxis, np.newaxis], mat, np.eye(3))
def quat_mul(q0: np.ndarray, q1: np.ndarray) -> np.ndarray:
"""Multiply Quaternions.
Args:
q0: First array of quaternions.
q1: Second array of quaternions.
Returns:
The multiplied quaternions.
"""
assert q0.shape == q1.shape
assert q0.shape[-1] == 4
assert q1.shape[-1] == 4
w0 = q0[..., 0]
x0 = q0[..., 1]
y0 = q0[..., 2]
z0 = q0[..., 3]
w1 = q1[..., 0]
x1 = q1[..., 1]
y1 = q1[..., 2]
z1 = q1[..., 3]
w = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1
x = w0 * x1 + x0 * w1 + y0 * z1 - z0 * y1
y = w0 * y1 + y0 * w1 + z0 * x1 - x0 * z1
z = w0 * z1 + z0 * w1 + x0 * y1 - y0 * x1
q = np.array([w, x, y, z])
if q.ndim == 2:
q = q.swapaxes(0, 1)
assert q.shape == q0.shape
return q
def quat_conjugate(q: np.array) -> np.array:
"""Conjugate Quaternions.
Args:
q: Array of quaternions.
Returns:
The conjugated quaternions.
"""
inv_q = -q
inv_q[..., 0] *= -1
return inv_q
def vec2quat(x: np.ndarray) -> np.ndarray:
"""Convert vectors to UnitQuaternions.
Args:
x: Vector or tensor of vectors.
Returns:
The normalized quaternions.
"""
assert x.shape[-1] == 4
q = x / np.linalg.norm(x, axis=-1, keepdims=True)
# Prefer quaternion with positive w
# (q * -1 corresponds to same rotation as q)
q[q[..., 0] < 0] *= -1
return q
def axisangle2quat(x: float, y: float, z: float, a: float) -> np.ndarray:
"""Convert a single axis-angle to a Quaternion.
Args:
x: X-axis component.
y: Y-axis component.
z: Z-axis component.
a: Angle around the axis in radians.
Returns:
The quaternion.
"""
sin_a = np.sin(a / 2.)
x *= sin_a
y *= sin_a
z *= sin_a
q = np.array([np.cos(a / 2.), x, y, z])
return q / np.linalg.norm(q)
def quat2embedding(quat: np.ndarray) -> np.ndarray:
"""Convert Quaternions to Embeddings.
Args:
quat: An array of quaternions.
Returns:
The embeddings.
"""
assert quat.shape[-1] == 4
return mat2embedding(quat2mat(quat))
def embedding2quat(embedding: np.ndarray, regularize: bool = False) -> np.ndarray:
"""Convert Embeddings to Quaternions.
The embeddings are assumed to have the form [a11, a12, a13, a21, a22, a23].
Args:
embedding: An array of embeddings.
regularize: If True, the embedding is regularized to a proper embedding before conversion.
Returns:
The quaternions.
"""
assert embedding.shape[-1] == 6
if regularize:
b1 = embedding[..., 0:3] / np.linalg.norm(embedding[..., 0:3], axis=-1, keepdims=True)
# np.sum for batched dot product
b2 = embedding[..., 3:6] - (np.sum(b1 * embedding[..., 3:6], axis=-1, keepdims=True) * b1)
b2 /= np.linalg.norm(b2, axis=-1, keepdims=True)
else:
b1 = embedding[..., 0:3]
b2 = embedding[..., 3:6]
b3 = np.cross(b1, b2, axis=-1)
Qxx, Qyx, Qzx = b1[..., 0], b2[..., 0], b3[..., 0]
Qxy, Qyy, Qzy = b1[..., 1], b2[..., 1], b3[..., 1]
Qxz, Qyz, Qzz = b1[..., 2], b2[..., 2], b3[..., 2]
# Fill only lower half of symmetric matrix
K = np.zeros(embedding.shape[:-1] + (4, 4), dtype=np.float64)
K[..., 0, 0] = Qxx - Qyy - Qzz
K[..., 1, 0] = Qyx + Qxy
K[..., 1, 1] = Qyy - Qxx - Qzz
K[..., 2, 0] = Qzx + Qxz
K[..., 2, 1] = Qzy + Qyz
K[..., 2, 2] = Qzz - Qxx - Qyy
K[..., 3, 0] = Qyz - Qzy
K[..., 3, 1] = Qzx - Qxz
K[..., 3, 2] = Qxy - Qyx
K[..., 3, 3] = Qxx + Qyy + Qzz
K /= 3.0
q = np.empty(K.shape[:-2] + (4,))
it = np.nditer(q[..., 0], flags=["multi_index"])
while not it.finished:
# Use Hermitian eigenvectors, values for speed
vals, vecs = np.linalg.eigh(K[it.multi_index])
# Select largest eigenvector, reorder to w,x,y,z quaternion
q[it.multi_index] = vecs[[3, 0, 1, 2], np.argmax(vals)]
# Prefer quaternion with positive w
# (q * -1 corresponds to same rotation as q)
if q[it.multi_index][0] < 0:
q[it.multi_index] *= -1
it.iternext()
return q
def fastembedding2quat(embedding: np.ndarray, regularize: bool = False) -> np.ndarray:
"""Faster embedding to quaternion conversion.
See https://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/
"""
mat = embedding2mat(embedding, regularize=regularize)
tr0 = 1.0 + mat[..., 0, 0] + mat[..., 1, 1] + mat[..., 2, 2]
tr1 = 1.0 + mat[..., 0, 0] - mat[..., 1, 1] - mat[..., 2, 2]
tr2 = 1.0 - mat[..., 0, 0] + mat[..., 1, 1] - mat[..., 2, 2]
tr3 = 1.0 - mat[..., 0, 0] - mat[..., 1, 1] + mat[..., 2, 2]
# Calculate which conversion to take for which matrix for best numeric stability
q = np.empty(mat.shape[:-2] + (4,))
idx0 = tr0 > 0
nidx0 = np.logical_not(idx0)
idx1 = np.logical_and(np.logical_and(tr1 > tr2, tr1 > tr3), nidx0)
idx2 = np.logical_and(np.logical_and(tr2 > tr1, tr2 > tr3), nidx0)
idx3 = np.logical_and(np.logical_not(np.logical_or(idx1, idx2)), nidx0)
s0 = np.sqrt(tr0[idx0]) * 2
s1 = np.sqrt(tr1[idx1]) * 2
s2 = np.sqrt(tr2[idx2]) * 2
s3 = np.sqrt(tr3[idx3]) * 2
q[idx0, 0] = 0.25 * s0
q[idx0, 1] = (mat[idx0, 2, 1] - mat[idx0, 1, 2]) / s0
q[idx0, 2] = (mat[idx0, 0, 2] - mat[idx0, 2, 0]) / s0
q[idx0, 3] = (mat[idx0, 1, 0] - mat[idx0, 0, 1]) / s0
q[idx1, 0] = (mat[idx1, 2, 1] - mat[idx1, 1, 2]) / s1
q[idx1, 1] = 0.25 * s1
q[idx1, 2] = (mat[idx1, 0, 1] + mat[idx1, 1, 0]) / s1
q[idx1, 3] = (mat[idx1, 0, 2] + mat[idx1, 2, 0]) / s1
q[idx2, 0] = (mat[idx2, 0, 2] - mat[idx2, 2, 0]) / s2
q[idx2, 1] = (mat[idx2, 0, 1] + mat[idx2, 1, 0]) / s2
q[idx2, 2] = 0.25 * s2
q[idx2, 3] = (mat[idx2, 1, 2] + mat[idx2, 2, 1]) / s2
q[idx3, 0] = (mat[idx3, 1, 0] - mat[idx3, 0, 1]) / s3
q[idx3, 1] = (mat[idx3, 0, 2] + mat[idx3, 2, 0]) / s3
q[idx3, 2] = (mat[idx3, 1, 2] + mat[idx3, 2, 1]) / s3
q[idx3, 3] = 0.25 * s3
q[q[..., 0] < 0, :] *= -1 # Prefer quaternion with positive w
return q
def embedding2mat(embedding: np.ndarray, regularize: bool = False) -> np.ndarray:
"""Convert Embeddings to Rotation Matrices.
The embeddings are assumed to have the form [a11, a12, a13, a21, a22, a23].
Args:
embedding: An array of embeddings.
regularize: If True, the embedding is regularized to a proper embedding before conversion.
Returns:
The rotation matrices.
"""
assert embedding.shape[-1] == 6
if regularize:
b1 = embedding[..., 0:3] / np.linalg.norm(embedding[..., 0:3], axis=-1, keepdims=True)
# np.sum for batched dot product
b2 = embedding[..., 3:6] - (np.sum(b1 * embedding[..., 3:6], axis=-1, keepdims=True) * b1)
b2 /= np.linalg.norm(b2, axis=-1, keepdims=True)
else:
b1 = embedding[..., 0:3]
b2 = embedding[..., 3:6]
b3 = np.cross(b1, b2, axis=-1)
mat = np.empty(embedding.shape[:-1] + (3, 3), dtype=np.float64)
mat[..., 0, 0], mat[..., 0, 1], mat[..., 0, 2] = b1[..., 0], b2[..., 0], b3[..., 0]
mat[..., 1, 0], mat[..., 1, 1], mat[..., 1, 2] = b1[..., 1], b2[..., 1], b3[..., 1]
mat[..., 2, 0], mat[..., 2, 1], mat[..., 2, 2] = b1[..., 2], b2[..., 2], b3[..., 2]
return mat
def mat2embedding(mat: np.ndarray) -> np.ndarray:
"""Convert Rotation Matrices to Embeddings.
Args:
mat: An array of rotation matrices.
Returns:
The embeddings.
"""
assert mat.shape[-2:] == (3, 3)
return np.concatenate((mat[..., :, 0], mat[..., :, 1]), axis=-1)
def map2pi(theta: np.ndarray) -> np.ndarray:
"""Map an angle to the interval of [-np.pi, np.pi].
Args:
theta: An array of angles (in radians).
Returns:
The mapped angles.
"""
return ((theta + np.pi) % (2 * np.pi)) - np.pi
| [] |
2024-01-10 | SynapticSage/ComSub | Notebooks~python~regress_plot.py | # Import necessary libraries
import numpy as np
import matplotlib.pyplot as plt
import os
import seaborn as sns
intermediate = "midpattern=true"
folder = f'/Volumes/MATLAB-Drive/Shared/figures/{intermediate}/tables/'
plotfolder=f'/Volumes/MATLAB-Drive/Shared/figures/{intermediate}/cca_regress_python/'
if not os.path.exists(plotfolder):
os.makedirs(plotfolder)
# Read the CSV file into a dataframe
df = pd.read_csv(os.path.join(folder, 'combined_faxis=Inf_regress.csv'))
# Filter for rows where pvalue_U and pvalue_V are both significant (less than 0.05)
significant_df = df[(df['pvalue_U'] < 0.05) & (df['pvalue_V'] < 0.05)]
significant_df['animal'] = significant_df['filename'].apply(lambda x: os.path.basename(x).split('_')[0])
# remove 60 hz from coherence -- because coherence sensitive to 60 hz noise
notch = significant_df.f.unique()[significant_df.query('field=="Cavg"').set_index('f').coef_U.abs().groupby('f').mean().argmax()]
significant_df = significant_df.query('f < (@notch-5) | f > (@notch+5)')
# Take the absolute value of coef_U and coef_V
significant_df['abs_coef_U'] = np.abs(significant_df['coef_U'])
significant_df['abs_coef_V'] = np.abs(significant_df['coef_V'])
significant_df['abs_coef_difference'] = significant_df['abs_coef_U'] - significant_df['abs_coef_V']
significant_df['coef_difference'] = significant_df['coef_U'] - significant_df['coef_V']
significant_df['abs_coef_U_strat'] = significant_df['abs_coef_U'] + 0.20
significant_df['abs_coef_V_strat'] = significant_df['abs_coef_V'] - 0.20
# Compute the mean of the absolute values of coef_U and coef_V
significant_df['coef_mean'] = significant_df[['abs_coef_U', 'abs_coef_V']].mean(axis=1)
significant_df['smooth_abs_coef_difference'] = significant_df.groupby(['field', 'animal','coef_i']).rolling(5, center=True).mean().reset_index()['abs_coef_difference']
# ------------------------------
# Create a seaborn plot, splitting by 'field' in the columns
# Set sharey=False to not share the y-axis across subplots
g = sns.FacetGrid(significant_df, col="field", col_wrap=5, height=4, aspect=1, sharey=True)
g.map(sns.lineplot, 'f', 'coef_mean', marker='o', color='black', alpha=0.5)
g.map(sns.lineplot, 'f', 'abs_coef_U_strat', marker='o', color='red', alpha=0.5, errorbar=None)
g.map(sns.lineplot, 'f', 'abs_coef_V_strat', marker='o', color='blue', alpha=0.5, errorbar=None)
# Add titles to the subplots
g.set_titles("{col_name}")
# Show the plot
plt.show()
plt.savefig(os.path.join(plotfolder, 'coef_mean_overall.png'))
plt.savefig(os.path.join(plotfolder, 'coef_mean_overall.pdf'))
# ------------------------------
# # Create a seaborn plot, splitting by 'field' in the columns
# # Set sharey=False to not share the y-axis across subplots
# g = sns.FacetGrid(significant_df, col="field", col_wrap=5, height=4, aspect=1, sharey=True)
# g.map(sns.lineplot, 'f', 'smooth_abs_coef_difference', marker='o', color='black', alpha=0.5)
# # Add titles to the subplots
# g.set_titles("{col_name}")
# # Show the plot
# plt.show()
# plt.savefig(os.path.join(plotfolder, 'coef_mean_overall.png'))
# plt.savefig(os.path.join(plotfolder, 'coef_mean_overall.pdf'))
# ------------------------------
# OVERALL_10+_word_LONG_TITLE: "Frequency vs Mean Coefficient, split by 'field' in the columns"
# COLUMNS: 'field'
# FILTER: 'meas' == 'raw'
# Y-AXIS: 'coef_mean'
# X-AXIS: 'f'
# Extract 'animal' from 'filename' and add it as a new column to the DataFrame
significant_df['animal'] = \
significant_df['filename'].apply(lambda x: os.path.basename(x).split('_')[0])
# Create a seaborn plot, splitting by 'field' in the columns and 'meas' in the rows
g = sns.FacetGrid(significant_df, row="meas", col="field", height=4, aspect=1, sharey=False)
g.map(sns.lineplot, 'f', 'coef_mean', marker='o')
# Add titles to the subplots
g.set_titles("{col_name}")
# Show the plot
plt.show()
plt.savefig(os.path.join(plotfolder, 'meas_coef_mean.png'))
# Create a seaborn plot, splitting by 'field' in the columns and 'animal' in the rows
g = sns.FacetGrid(significant_df, row="animal", col="field", height=4, aspect=1, sharey=False)
g.map(sns.lineplot, 'f', 'coef_mean', marker='o')
# Add titles to the subplots
g.set_titles("{col_name}")
# Show the plot
plt.show()
plt.savefig(os.path.join(plotfolder, 'animal_coef_mean.png'))
plt.savefig(os.path.join(plotfolder, 'animal_coef_mean.pdf'))
# ------------------------------
# OVERALL_10+_word_LONG_TITLE: "Frequency vs Mean Coefficient, split by 'field' in the columns and 'animal' in the rows"
# ROWS: 'animal'
# COLUMNS: 'field'
# FILTER: 'meas' == 'raw'
# Y-AXIS: 'coef_mean'
# X-AXIS: 'f'
#
# Filter the DataFrame for rows where 'meas' is 'raw'
raw_df = significant_df[significant_df['meas'] == 'raw']
# Create a seaborn plot, splitting by 'field' in the columns and 'animal' in the rows
g = sns.FacetGrid(raw_df, row="animal", col="field", height=4, aspect=1, sharey=False)
g.map(sns.lineplot, 'f', 'coef_mean', marker='o')
# Add titles to the subplots
g.set_titles("{col_name}")
# Show the plot
plt.show()
plt.savefig(os.path.join(plotfolder, 'raw_animal_coef_mean.png'))
plt.savefig(os.path.join(plotfolder, 'raw_animal_coef_mean.pdf'))
# ------------------------------
# Create a seaborn plot with 'field' in the columns, 'f' on the x-axis, and 'coef_difference' on the y-axis,
# splitting by 'animal' in the rows
cm = sns.color_palette("PuBuGn_d", 5)
g = sns.FacetGrid(significant_df, col="field", row="coef_i", hue="coef_i", height=4, aspect=1, sharey=False)
g.map(sns.lineplot, 'f', 'coef_mean', marker='o')
# Add titles to the subplots
g.set_titles("{col_name} by coef_i")
# Show the plot
plt.show()
plt.savefig(os.path.join(plotfolder, 'coef_mean_by_component.png'))
plt.savefig(os.path.join(plotfolder, 'coef_mean_by_component.pdf'))
# ------------------------------
# Create a seaborn plot with 'field' in the columns, 'f' on the x-axis, and 'coef_difference' on the y-axis,
# splitting by 'animal' in the rows
cm = sns.color_palette("PuBuGn_d", 5)
g = sns.FacetGrid(significant_df, col="field", row="coef_i", hue="animal", height=4, aspect=1, sharey=False)
g.map(sns.lineplot, 'f', 'coef_mean', marker='o')
# Add titles to the subplots
g.set_titles("{col_name} by coef_i")
for ax in g.axes.ravel():
ax.set_ylim([0, 0.6])
# ax.axvline(x=60, color='black', linestyle='--')
# Show the plot
plt.show()
plt.savefig(os.path.join(plotfolder, 'animal_coef_mean_by_component.png'))
plt.savefig(os.path.join(plotfolder, 'animal_coef_mean_by_component.pdf'))
# ------------------------------
# Create a new column for the difference between coef_U and coef_V
significant_df['coef_difference'] = significant_df['coef_U'] - significant_df['coef_V']
# Create a seaborn plot with 'field' in the columns, 'f' on the x-axis, and 'coef_difference' on the y-axis
g = sns.FacetGrid(significant_df, col="field", height=4, aspect=1)
g.map(sns.lineplot, 'f', 'coef_difference', marker='o')
# Add titles to the subplots
g.set_titles("{col_name}")
# Show the plot
plt.show()
plt.savefig(os.path.join(plotfolder, 'cI.png'))
# ------------------------------
# Create a seaborn plot with 'field' in the columns, 'f' on the x-axis, and 'coef_difference' on the y-axis,
# splitting by 'animal' in the rows
g = sns.FacetGrid(significant_df, row="animal", col="field", height=4, aspect=1, sharey=False)
g.map(sns.lineplot, 'f', 'coef_difference', marker='o')
# Add titles to the subplots
g.set_titles("{col_name}")
# Show the plot
plt.show()
plt.savefig(os.path.join(plotfolder, 'animal_coef_difference.png'))
# ------------------------------
# Create a seaborn plot with 'field' in the columns, 'f_bin' on the x-axis, and 'coef_difference' on the y-axis
# Add a horizontal black dashed line at y=0
# Group by 'f_bin', 'field', and 'animal', and compute the mean of 'coef_difference' within each group
# Round the 'f' values to the nearest 5 to create frequency bins
significant_df['f_bin'] = 5 * round(significant_df['f'] / 5)
grouped_df = significant_df.groupby(['f_bin', 'field', 'animal'])['coef_difference'].mean().reset_index()
g = sns.FacetGrid(grouped_df, col="field", height=4, aspect=1, sharey=False)
g.map(sns.lineplot, 'f_bin', 'coef_difference', marker='o')
g.map(plt.axhline, y=0, ls='--', c='black')
# Add titles to the subplots
g.set_titles("{col_name}")
# Show the plot
plt.show()
plt.savefig(os.path.join(plotfolder, 'binned_coef_difference.png'))
plt.savefig(os.path.join(plotfolder, 'binned_coef_difference.pdf'))
# Create a seaborn plot with 'field' in the columns, 'f_bin' on the x-axis, and 'coef_difference' on the y-axis
# Add a horizontal black dashed line at y=0
# Group by 'f_bin', 'field', and 'animal', and compute the mean of 'coef_difference' within each group
# Round the 'f' values to the nearest 5 to create frequency bins
significant_df['f_bin'] = 10 * round(significant_df['f'] / 10)
grouped_df = significant_df.groupby(['f_bin', 'field', 'animal'])['coef_difference'].mean().reset_index()
g = sns.FacetGrid(grouped_df, col="field", height=4, aspect=1, sharey=False)
g.map(sns.lineplot, 'f_bin', 'coef_difference', marker='o')
g.map(plt.axhline, y=0, ls='--', c='black')
# Add titles to the subplots
g.set_titles("{col_name}")
# Show the plot
plt.show()
plt.savefig(os.path.join(plotfolder, 'large_binned_coef_difference.png'))
plt.savefig(os.path.join(plotfolder, 'large_binned_coef_difference.pdf'))
| [] |
2024-01-10 | QuantLet/SDA_2019_St_Gallen | SDA_2019_St_Gallen_POI_NLP_NETWORK_ENRON~Source.py | # ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.4'
# jupytext_version: 1.2.4
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# https://github.com/rhosse/Team-Lyrical/blob/9b059145dc26dc4e2624c6b6147da01d1f51fcdd/data_lemmatization.py
# https://towardsdatascience.com/how-i-used-machine-learning-to-classify-emails-and-turn-them-into-insights-efed37c1e66
import spacy
import nltk
import gensim
#Gensim is an open-source library for unsupervised topic modeling.
import gensim.corpora as corpora
from gensim.utils import simple_preprocess
from gensim.models import CoherenceModel
import spacy #To prepare text
import pyLDAvis #interactive topic model visualization
import pyLDAvis.gensim
import nltk #Natural Language Toolkit
import re #ex : "A" and "a"
from nltk.corpus import stopwords #to delete stop %matplotlib inline
import pandas as pd
import random
import numpy as np
import data
import matplotlib.pyplot as plt
def parse_raw_message(raw_message):
lines = raw_message.split('\n')
email = {}
message = ''
keys_to_extract = ['from', 'to']
for line in lines:
if ':' not in line:
message += line.strip()
email['body'] = message
else:
pairs = line.split(':')
key = pairs[0].lower()
val = pairs[1].strip()
if key in keys_to_extract:
email[key] = val
return email
def map_to_list(emails, key):
results = []
for email in emails:
if key not in email:
results.append('')
else:
results.append(email[key])
return results
def parse_into_emails(messages):
emails = [parse_raw_message(message) for message in messages]
return {
'body': map_to_list(emails, 'body'),
'to': map_to_list(emails, 'to'),
'from_': map_to_list(emails, 'from')}
| [] |
2024-01-10 | lucidworks/transformers-clone | tests~test_tokenization_fast.py | import logging
import unittest
from collections import namedtuple
from itertools import takewhile
from transformers import (
BertTokenizer,
BertTokenizerFast,
DistilBertTokenizer,
GPT2Tokenizer,
GPT2TokenizerFast,
OpenAIGPTTokenizer,
PreTrainedTokenizer,
RobertaTokenizer,
TransfoXLTokenizer,
is_torch_available,
)
from transformers.testing_utils import get_tests_dir, require_torch
from transformers.tokenization_distilbert import DistilBertTokenizerFast
from transformers.tokenization_openai import OpenAIGPTTokenizerFast
from transformers.tokenization_roberta import RobertaTokenizerFast
from transformers.tokenization_transfo_xl import TransfoXLTokenizerFast
logger = logging.getLogger(__name__)
NON_ENGLISH_TAGS = ["chinese", "dutch", "french", "finnish", "german", "multilingual"]
Tokenizer = namedtuple("Tokenizer", ["name", "rust_cls", "python_cls", "vocab_key", "filter", "kwargs"])
def filter_non_english(_: Tokenizer, pretrained_name: str):
""" Filter all the model for non-english language """
return not any([lang in pretrained_name for lang in NON_ENGLISH_TAGS])
def filter_roberta_detectors(_: Tokenizer, pretrained_name: str):
return "detector" not in pretrained_name
class CommonFastTokenizerTest(unittest.TestCase):
TOKENIZERS_CLASSES = frozenset([])
def setUp(self) -> None:
with open(f"{get_tests_dir()}/fixtures/sample_text.txt", encoding="utf-8") as f_data:
self._data = f_data.read().replace("\n\n", "\n").strip()
def test_all_tokenizers(self):
for tok_case in self.TOKENIZERS_CLASSES:
for pretrained_name in tok_case.python_cls.pretrained_vocab_files_map[tok_case.vocab_key].keys():
# Tokenizer.filter makes it possible to filter which Tokenizer to case based on all the
# information available in Tokenizer (name, rust class, python class, vocab key name)
if tok_case.filter is None or (
tok_case.filter is not None and tok_case.filter(tok_case, pretrained_name)
):
kwargs = dict(t for t in tok_case.kwargs) if tok_case.kwargs else {}
with self.subTest("{} ({})".format(tok_case.name, pretrained_name)):
tokenizer_r = tok_case.rust_cls.from_pretrained(pretrained_name, **kwargs)
tokenizer_p = tok_case.python_cls.from_pretrained(pretrained_name, **kwargs)
self.fast_align_python(tokenizer_r, tokenizer_p, tok_case, pretrained_name)
self.fast_only(tokenizer_r)
def test_pretokenized_tokenizers(self):
for tok_case in self.TOKENIZERS_CLASSES:
for pretrained_name in tok_case.python_cls.pretrained_vocab_files_map[tok_case.vocab_key].keys():
# Tokenizer.filter makes it possible to filter which Tokenizer to case based on all the
# information available in Tokenizer (name, rust class, python class, vocab key name)
if tok_case.filter is None or (
tok_case.filter is not None and tok_case.filter(tok_case, pretrained_name)
):
with self.subTest("{} ({})".format(tok_case.name, pretrained_name)):
tokenizer_r = tok_case.rust_cls.from_pretrained(pretrained_name, add_prefix_space=True)
tokenizer_p = tok_case.python_cls.from_pretrained(pretrained_name, add_prefix_space=True)
self.assert_pretokenized_inputs(tokenizer_r, tokenizer_p)
def fast_align_python(self, tokenizer_r, tokenizer_p, tok_case, pretrained_name):
# Check is_fast is set correctly
self.assertFalse(tokenizer_p.is_fast)
self.assertTrue(tokenizer_r.is_fast)
# Check that Rust and Python align
self.assert_tokenization_python_rust_equals(tokenizer_r, tokenizer_p)
self.assert_num_special_tokens_to_add_equal(tokenizer_r, tokenizer_p)
self.assert_max_length_equal(tokenizer_r, tokenizer_p)
self.assert_special_tokens_map_equal(tokenizer_r, tokenizer_p)
self.assert_embeded_special_tokens(tokenizer_r, tokenizer_p)
self.assert_padding(tokenizer_r, tokenizer_p)
self.assert_create_token_type_ids(tokenizer_r, tokenizer_p)
self.assert_prepare_for_model(tokenizer_r, tokenizer_p)
def fast_only(self, tokenizer_r):
# Ensure None raise an error
self.assertRaises(ValueError, tokenizer_r.tokenize, None)
self.assertRaises(ValueError, tokenizer_r.encode, None)
self.assertRaises(ValueError, tokenizer_r.encode_plus, None)
self.assertRaises(ValueError, tokenizer_r.batch_encode_plus, None)
self.assert_add_tokens(tokenizer_r)
self.assert_offsets_mapping(tokenizer_r)
self.assert_add_special_tokens(tokenizer_r)
self.assert_alignement_methods(tokenizer_r)
self.assert_batch_encode_dynamic_overflowing(tokenizer_r)
def assert_alignement_methods(self, tokenizer_r):
words = ["Wonderful", "no", "inspiration", "example", "with", "subtoken"]
text = " ".join(words)
batch_size = 3
encoding = tokenizer_r.encode_plus(text, add_special_tokens=False)
batch_encoding = tokenizer_r.batch_encode_plus([text] * batch_size, add_special_tokens=False)
num_tokens = len(encoding["input_ids"])
last_word_index = len(words) - 1
last_token_index = num_tokens - 1
last_batch_index = batch_size - 1
last_char_index = len(text) - 1
# words, tokens
self.assertEqual(len(encoding.words(0)), num_tokens)
self.assertEqual(max(encoding.words(0)), last_word_index)
self.assertEqual(min(encoding.words(0)), 0)
self.assertEqual(len(batch_encoding.words(last_batch_index)), num_tokens)
self.assertEqual(max(batch_encoding.words(last_batch_index)), last_word_index)
self.assertEqual(min(batch_encoding.words(last_batch_index)), 0)
self.assertEqual(len(encoding.tokens(0)), num_tokens)
# Assert token_to_word
self.assertEqual(encoding.token_to_word(0), 0)
self.assertEqual(encoding.token_to_word(0, 0), 0)
self.assertEqual(encoding.token_to_word(last_token_index), last_word_index)
self.assertEqual(encoding.token_to_word(0, last_token_index), last_word_index)
self.assertEqual(batch_encoding.token_to_word(1, 0), 0)
self.assertEqual(batch_encoding.token_to_word(0, last_token_index), last_word_index)
self.assertEqual(batch_encoding.token_to_word(last_batch_index, last_token_index), last_word_index)
# Assert word_to_tokens
self.assertEqual(encoding.word_to_tokens(0).start, 0)
self.assertEqual(encoding.word_to_tokens(0, 0).start, 0)
self.assertEqual(encoding.word_to_tokens(last_word_index).end, last_token_index + 1)
self.assertEqual(encoding.word_to_tokens(0, last_word_index).end, last_token_index + 1)
self.assertEqual(batch_encoding.word_to_tokens(1, 0).start, 0)
self.assertEqual(batch_encoding.word_to_tokens(0, last_word_index).end, last_token_index + 1)
self.assertEqual(batch_encoding.word_to_tokens(last_batch_index, last_word_index).end, last_token_index + 1)
# Assert token_to_chars
self.assertEqual(encoding.token_to_chars(0).start, 0)
self.assertEqual(encoding.token_to_chars(0, 0).start, 0)
self.assertEqual(encoding.token_to_chars(last_token_index).end, last_char_index + 1)
self.assertEqual(encoding.token_to_chars(0, last_token_index).end, last_char_index + 1)
self.assertEqual(batch_encoding.token_to_chars(1, 0).start, 0)
self.assertEqual(batch_encoding.token_to_chars(0, last_token_index).end, last_char_index + 1)
self.assertEqual(batch_encoding.token_to_chars(last_batch_index, last_token_index).end, last_char_index + 1)
# Assert char_to_token
self.assertEqual(encoding.char_to_token(0), 0)
self.assertEqual(encoding.char_to_token(0, 0), 0)
self.assertEqual(encoding.char_to_token(last_char_index), last_token_index)
self.assertEqual(encoding.char_to_token(0, last_char_index), last_token_index)
self.assertEqual(batch_encoding.char_to_token(1, 0), 0)
self.assertEqual(batch_encoding.char_to_token(0, last_char_index), last_token_index)
self.assertEqual(batch_encoding.char_to_token(last_batch_index, last_char_index), last_token_index)
# Assert char_to_word
self.assertEqual(encoding.char_to_word(0), 0)
self.assertEqual(encoding.char_to_word(0, 0), 0)
self.assertEqual(encoding.char_to_word(last_char_index), last_word_index)
self.assertEqual(encoding.char_to_word(0, last_char_index), last_word_index)
self.assertEqual(batch_encoding.char_to_word(1, 0), 0)
self.assertEqual(batch_encoding.char_to_word(0, last_char_index), last_word_index)
self.assertEqual(batch_encoding.char_to_word(last_batch_index, last_char_index), last_word_index)
# Assert word_to_chars
self.assertEqual(encoding.word_to_chars(0).start, 0)
self.assertEqual(encoding.word_to_chars(0, 0).start, 0)
self.assertEqual(encoding.word_to_chars(last_word_index).end, last_char_index + 1)
self.assertEqual(encoding.word_to_chars(0, last_word_index).end, last_char_index + 1)
self.assertEqual(batch_encoding.word_to_chars(1, 0).start, 0)
self.assertEqual(batch_encoding.word_to_chars(0, last_word_index).end, last_char_index + 1)
self.assertEqual(batch_encoding.word_to_chars(last_batch_index, last_word_index).end, last_char_index + 1)
def assert_tokenization_python_rust_equals(self, tokenizer_r, tokenizer_p):
# Ensure basic input match
input_p = tokenizer_p.encode_plus(self._data)
input_r = tokenizer_r.encode_plus(self._data)
for key in filter(lambda x: x in ["input_ids", "token_type_ids", "attention_mask"], input_p.keys()):
self.assertSequenceEqual(input_p[key], input_r[key])
input_pairs_p = tokenizer_p.encode_plus(self._data, self._data)
input_pairs_r = tokenizer_r.encode_plus(self._data, self._data)
for key in filter(lambda x: x in ["input_ids", "token_type_ids", "attention_mask"], input_p.keys()):
self.assertSequenceEqual(input_pairs_p[key], input_pairs_r[key])
# Ensure truncation match
input_p = tokenizer_p.encode_plus(self._data, max_length=512, truncation=True)
input_r = tokenizer_r.encode_plus(self._data, max_length=512, truncation=True)
for key in filter(lambda x: x in ["input_ids", "token_type_ids", "attention_mask"], input_p.keys()):
self.assertSequenceEqual(input_p[key], input_r[key])
# Ensure truncation with stride match
input_p = tokenizer_p.encode_plus(
self._data, max_length=512, truncation=True, stride=3, return_overflowing_tokens=True
)
input_r = tokenizer_r.encode_plus(
self._data, max_length=512, truncation=True, stride=3, return_overflowing_tokens=True
)
for key in filter(lambda x: x in ["input_ids", "token_type_ids", "attention_mask"], input_p.keys()):
self.assertSequenceEqual(input_p[key], input_r[key][0])
def assert_num_special_tokens_to_add_equal(self, tokenizer_r, tokenizer_p):
# Check we have the same number of added_tokens for both pair and non-pair inputs.
self.assertEqual(tokenizer_r.num_special_tokens_to_add(False), tokenizer_p.num_special_tokens_to_add(False))
self.assertEqual(tokenizer_r.num_special_tokens_to_add(True), tokenizer_p.num_special_tokens_to_add(True))
def assert_max_length_equal(self, tokenizer_r, tokenizer_p):
# Check we have the correct max_length for both pair and non-pair inputs.
self.assertEqual(tokenizer_r.max_len_single_sentence, tokenizer_p.max_len_single_sentence)
self.assertEqual(tokenizer_r.max_len_sentences_pair, tokenizer_p.max_len_sentences_pair)
def assert_special_tokens_map_equal(self, tokenizer_r, tokenizer_p):
# Assert the set of special tokens match.
self.assertSequenceEqual(
tokenizer_p.special_tokens_map.items(),
tokenizer_r.special_tokens_map.items(),
)
def assert_add_tokens(self, tokenizer_r):
vocab_size = tokenizer_r.vocab_size
self.assertEqual(tokenizer_r.add_tokens(""), 0)
self.assertEqual(tokenizer_r.add_tokens("testoken"), 1)
self.assertEqual(tokenizer_r.add_tokens(["testoken1", "testtoken2"]), 2)
self.assertEqual(len(tokenizer_r), vocab_size + 3)
self.assertEqual(tokenizer_r.add_special_tokens({}), 0)
self.assertEqual(tokenizer_r.add_special_tokens({"bos_token": "[BOS]", "eos_token": "[EOS]"}), 2)
self.assertRaises(
AssertionError, tokenizer_r.add_special_tokens, {"additional_special_tokens": "<testtoken1>"}
)
self.assertEqual(tokenizer_r.add_special_tokens({"additional_special_tokens": ["<testtoken2>"]}), 1)
self.assertEqual(
tokenizer_r.add_special_tokens({"additional_special_tokens": ["<testtoken3>", "<testtoken4>"]}), 2
)
self.assertEqual(len(tokenizer_r), vocab_size + 8)
def assert_offsets_mapping(self, tokenizer_r):
text = "Wonderful no inspiration example with subtoken"
pair = "Along with an awesome pair"
# No pair
tokens_with_offsets = tokenizer_r.encode_plus(
text, return_special_tokens_mask=True, return_offsets_mapping=True, add_special_tokens=True
)
added_tokens = tokenizer_r.num_special_tokens_to_add(False)
offsets = tokens_with_offsets["offset_mapping"]
# Assert there is the same number of tokens and offsets
self.assertEqual(len(offsets), len(tokens_with_offsets["input_ids"]))
# Assert there is online added_tokens special_tokens
self.assertEqual(sum(tokens_with_offsets["special_tokens_mask"]), added_tokens)
# Pairs
tokens_with_offsets = tokenizer_r.encode_plus(
text, pair, return_special_tokens_mask=True, return_offsets_mapping=True, add_special_tokens=True
)
added_tokens = tokenizer_r.num_special_tokens_to_add(True)
offsets = tokens_with_offsets["offset_mapping"]
# Assert there is the same number of tokens and offsets
self.assertEqual(len(offsets), len(tokens_with_offsets["input_ids"]))
# Assert there is online added_tokens special_tokens
self.assertEqual(sum(tokens_with_offsets["special_tokens_mask"]), added_tokens)
def assert_batch_encode_dynamic_overflowing(self, tokenizer: PreTrainedTokenizer):
"""
When calling batch_encode with multiple sequence it can returns different number of
overflowing encoding for each sequence:
[
Sequence 1: [Encoding 1, Encoding 2],
Sequence 2: [Encoding 1],
Sequence 3: [Encoding 1, Encoding 2, ... Encoding N]
]
This needs to be padded so that it can represented as a tensor
"""
returned_tensor = "pt" if is_torch_available() else "tf"
if not tokenizer.pad_token or tokenizer.pad_token_id < 0:
return
tokens = tokenizer.encode_plus(
"HuggingFace is solving NLP one commit at a time",
max_length=6,
padding=True,
truncation=True,
return_tensors=returned_tensor,
return_overflowing_tokens=True,
)
for key in filter(lambda x: "overflow_to_sample_mapping" not in x, tokens.keys()):
self.assertEqual(len(tokens[key].shape), 2)
# Mono sample
tokens = tokenizer.batch_encode_plus(
["HuggingFace is solving NLP one commit at a time"],
max_length=6,
padding=True,
truncation="only_first",
return_tensors=returned_tensor,
return_overflowing_tokens=True,
)
for key in filter(lambda x: "overflow_to_sample_mapping" not in x, tokens.keys()):
self.assertEqual(len(tokens[key].shape), 2)
self.assertEqual(tokens[key].shape[-1], 6)
# Multi sample
tokens = tokenizer.batch_encode_plus(
["HuggingFace is solving NLP one commit at a time", "Very tiny input"],
max_length=6,
padding=True,
truncation="only_first",
return_tensors=returned_tensor,
return_overflowing_tokens=True,
)
for key in filter(lambda x: "overflow_to_sample_mapping" not in x, tokens.keys()):
self.assertEqual(len(tokens[key].shape), 2)
self.assertEqual(tokens[key].shape[-1], 6)
def assert_pretokenized_inputs(self, tokenizer_r, tokenizer_p):
# Input string
pretokenized_input_simple = "This is a sample input".split()
pretokenized_input_pair = "This is a sample pair".split()
# Test encode for pretokenized inputs
output_r = tokenizer_r.encode(pretokenized_input_simple, is_pretokenized=True)
output_p = tokenizer_p.encode(pretokenized_input_simple, is_pretokenized=True)
self.assertEqual(output_p, output_r)
kwargs = {
"is_pretokenized": True,
"return_token_type_ids": True,
"return_attention_mask": True,
"return_overflowing_tokens": False,
"return_special_tokens_mask": True,
"return_offsets_mapping": False, # Not implemented in python tokenizers
}
batch_kwargs = {
"is_pretokenized": True,
"return_token_type_ids": True,
"return_attention_mask": True, # we have an 's' here
"return_overflowing_tokens": False,
"return_special_tokens_mask": True, # we have an 's' here
"return_offsets_mapping": False, # Not implemented in python tokenizers
}
# Test encode_plus for pretokenized inputs
output_r = tokenizer_r.encode_plus(pretokenized_input_simple, **kwargs)
output_p = tokenizer_p.encode_plus(pretokenized_input_simple, **kwargs)
for key in output_p.keys():
self.assertEqual(output_p[key], output_r[key])
# Test batch_encode_plus for pretokenized inputs
input_batch = ([pretokenized_input_simple] * 2) + [pretokenized_input_simple + pretokenized_input_pair]
output_r = tokenizer_r.batch_encode_plus(input_batch, **batch_kwargs)
output_p = tokenizer_p.batch_encode_plus(input_batch, **batch_kwargs)
for key in output_p.keys():
self.assertEqual(output_p[key], output_r[key])
# Test encode for pretokenized inputs pairs
output_r = tokenizer_r.encode(pretokenized_input_simple, pretokenized_input_pair, is_pretokenized=True)
output_p = tokenizer_p.encode(pretokenized_input_simple, pretokenized_input_pair, is_pretokenized=True)
self.assertEqual(output_p, output_r)
# Test encode_plus for pretokenized inputs
output_r = tokenizer_r.encode_plus(pretokenized_input_simple, pretokenized_input_pair, **kwargs)
output_p = tokenizer_p.encode_plus(pretokenized_input_simple, pretokenized_input_pair, **kwargs)
for key in output_p.keys():
self.assertEqual(output_p[key], output_r[key])
# Test batch_encode_plus for pretokenized inputs
input_batch_pair = ([pretokenized_input_simple, pretokenized_input_pair] * 2) + [
pretokenized_input_simple + pretokenized_input_pair,
pretokenized_input_pair,
]
output_r = tokenizer_r.batch_encode_plus(input_batch_pair, **batch_kwargs)
output_p = tokenizer_p.batch_encode_plus(input_batch_pair, **batch_kwargs)
for key in output_p.keys():
self.assertEqual(output_p[key], output_r[key])
def assert_create_token_type_ids(self, tokenizer_r, tokenizer_p):
input_simple = [1, 2, 3]
input_pair = [1, 2, 3]
# Generate output
output_r = tokenizer_r.create_token_type_ids_from_sequences(input_simple)
output_p = tokenizer_p.create_token_type_ids_from_sequences(input_simple)
self.assertEqual(output_p, output_r)
# Generate pair output
output_r = tokenizer_r.create_token_type_ids_from_sequences(input_simple, input_pair)
output_p = tokenizer_p.create_token_type_ids_from_sequences(input_simple, input_pair)
self.assertEqual(output_p, output_r)
def assert_build_inputs_with_special_tokens(self, tokenizer_r, tokenizer_p):
# Input string
input_simple = tokenizer_p.tokenize("This is a sample input")
input_pair = tokenizer_p.tokenize("This is a sample pair")
# Generate output
output_r = tokenizer_r.build_inputs_with_special_tokens(input_simple)
output_p = tokenizer_p.build_inputs_with_special_tokens(input_simple)
self.assertEqual(output_p, output_r)
# Generate pair output
output_r = tokenizer_r.build_inputs_with_special_tokens(input_simple, input_pair)
output_p = tokenizer_p.build_inputs_with_special_tokens(input_simple, input_pair)
self.assertEqual(output_p, output_r)
# Input tokens id
input_simple = tokenizer_p.encode("This is a sample input")
input_pair = tokenizer_p.encode("This is a sample pair")
# Generate output
output_r = tokenizer_r.build_inputs_with_special_tokens(input_simple)
output_p = tokenizer_p.build_inputs_with_special_tokens(input_simple)
self.assertEqual(output_p, output_r)
# Generate pair output
output_r = tokenizer_r.build_inputs_with_special_tokens(input_simple, input_pair)
output_p = tokenizer_p.build_inputs_with_special_tokens(input_simple, input_pair)
self.assertEqual(output_p, output_r)
def assert_padding(self, tokenizer_r, tokenizer_p, max_length=15):
def assert_padded_input_match(input_r: list, input_p: list, max_length: int):
# Ensure we match max_length
self.assertEqual(len(input_r), max_length)
self.assertEqual(len(input_p), max_length)
# Ensure the number of padded tokens is the same
padded_tokens_r = list(takewhile(lambda i: i == tokenizer_r.pad_token_id, reversed(input_r)))
padded_tokens_p = list(takewhile(lambda i: i == tokenizer_p.pad_token_id, reversed(input_p)))
self.assertSequenceEqual(padded_tokens_r, padded_tokens_p)
def assert_batch_padded_input_match(input_r: dict, input_p: dict, max_length: int):
for i_r in input_r.values():
self.assertEqual(len(i_r), 2), self.assertEqual(len(i_r[0]), max_length), self.assertEqual(
len(i_r[1]), max_length
)
self.assertEqual(len(i_r), 2), self.assertEqual(len(i_r[0]), max_length), self.assertEqual(
len(i_r[1]), max_length
)
for i_r, i_p in zip(input_r["input_ids"], input_p["input_ids"]):
assert_padded_input_match(i_r, i_p, max_length)
for i_r, i_p in zip(input_r["attention_mask"], input_p["attention_mask"]):
self.assertSequenceEqual(i_r, i_p)
# Encode - Simple input
input_r = tokenizer_r.encode("This is a simple input", max_length=max_length, pad_to_max_length=True)
input_p = tokenizer_p.encode("This is a simple input", max_length=max_length, pad_to_max_length=True)
assert_padded_input_match(input_r, input_p, max_length)
input_r = tokenizer_r.encode("This is a simple input", max_length=max_length, padding="max_length")
input_p = tokenizer_p.encode("This is a simple input", max_length=max_length, padding="max_length")
assert_padded_input_match(input_r, input_p, max_length)
input_r = tokenizer_r.encode("This is a simple input", padding="longest")
input_p = tokenizer_p.encode("This is a simple input", padding=True)
assert_padded_input_match(input_r, input_p, len(input_r))
# Encode - Pair input
input_r = tokenizer_r.encode(
"This is a simple input", "This is a pair", max_length=max_length, pad_to_max_length=True
)
input_p = tokenizer_p.encode(
"This is a simple input", "This is a pair", max_length=max_length, pad_to_max_length=True
)
assert_padded_input_match(input_r, input_p, max_length)
input_r = tokenizer_r.encode(
"This is a simple input", "This is a pair", max_length=max_length, padding="max_length"
)
input_p = tokenizer_p.encode(
"This is a simple input", "This is a pair", max_length=max_length, padding="max_length"
)
assert_padded_input_match(input_r, input_p, max_length)
input_r = tokenizer_r.encode("This is a simple input", "This is a pair", padding=True)
input_p = tokenizer_p.encode("This is a simple input", "This is a pair", padding="longest")
assert_padded_input_match(input_r, input_p, len(input_r))
# Encode_plus - Simple input
input_r = tokenizer_r.encode_plus("This is a simple input", max_length=max_length, pad_to_max_length=True)
input_p = tokenizer_p.encode_plus("This is a simple input", max_length=max_length, pad_to_max_length=True)
assert_padded_input_match(input_r["input_ids"], input_p["input_ids"], max_length)
self.assertSequenceEqual(input_r["attention_mask"], input_p["attention_mask"])
input_r = tokenizer_r.encode_plus("This is a simple input", max_length=max_length, padding="max_length")
input_p = tokenizer_p.encode_plus("This is a simple input", max_length=max_length, padding="max_length")
assert_padded_input_match(input_r["input_ids"], input_p["input_ids"], max_length)
self.assertSequenceEqual(input_r["attention_mask"], input_p["attention_mask"])
input_r = tokenizer_r.encode_plus("This is a simple input", padding="longest")
input_p = tokenizer_p.encode_plus("This is a simple input", padding=True)
assert_padded_input_match(input_r["input_ids"], input_p["input_ids"], len(input_r["input_ids"]))
self.assertSequenceEqual(input_r["attention_mask"], input_p["attention_mask"])
# Encode_plus - Pair input
input_r = tokenizer_r.encode_plus(
"This is a simple input", "This is a pair", max_length=max_length, pad_to_max_length=True
)
input_p = tokenizer_p.encode_plus(
"This is a simple input", "This is a pair", max_length=max_length, pad_to_max_length=True
)
assert_padded_input_match(input_r["input_ids"], input_p["input_ids"], max_length)
self.assertSequenceEqual(input_r["attention_mask"], input_p["attention_mask"])
input_r = tokenizer_r.encode_plus(
"This is a simple input", "This is a pair", max_length=max_length, padding="max_length"
)
input_p = tokenizer_p.encode_plus(
"This is a simple input", "This is a pair", max_length=max_length, padding="max_length"
)
assert_padded_input_match(input_r["input_ids"], input_p["input_ids"], max_length)
self.assertSequenceEqual(input_r["attention_mask"], input_p["attention_mask"])
input_r = tokenizer_r.encode_plus("This is a simple input", "This is a pair", padding="longest")
input_p = tokenizer_p.encode_plus("This is a simple input", "This is a pair", padding=True)
assert_padded_input_match(input_r["input_ids"], input_p["input_ids"], len(input_r["input_ids"]))
self.assertSequenceEqual(input_r["attention_mask"], input_p["attention_mask"])
# Batch_encode_plus - Simple input
input_r = tokenizer_r.batch_encode_plus(
["This is a simple input 1", "This is a simple input 2"], max_length=max_length, pad_to_max_length=True
)
input_p = tokenizer_p.batch_encode_plus(
["This is a simple input 1", "This is a simple input 2"], max_length=max_length, pad_to_max_length=True
)
assert_batch_padded_input_match(input_r, input_p, max_length)
input_r = tokenizer_r.batch_encode_plus(
["This is a simple input 1", "This is a simple input 2"],
max_length=max_length,
padding="max_length",
)
input_p = tokenizer_p.batch_encode_plus(
["This is a simple input 1", "This is a simple input 2"],
max_length=max_length,
padding="max_length",
)
assert_batch_padded_input_match(input_r, input_p, max_length)
input_r = tokenizer_r.batch_encode_plus(
["This is a simple input 1", "This is a simple input 2"],
max_length=max_length,
padding="longest",
)
input_p = tokenizer_p.batch_encode_plus(
["This is a simple input 1", "This is a simple input 2"],
max_length=max_length,
padding=True,
)
assert_batch_padded_input_match(input_r, input_p, len(input_r["input_ids"][0]))
input_r = tokenizer_r.batch_encode_plus(
["This is a simple input 1", "This is a simple input 2"], padding="longest"
)
input_p = tokenizer_p.batch_encode_plus(["This is a simple input 1", "This is a simple input 2"], padding=True)
assert_batch_padded_input_match(input_r, input_p, len(input_r["input_ids"][0]))
# Batch_encode_plus - Pair input
input_r = tokenizer_r.batch_encode_plus(
[
("This is a simple input 1", "This is a simple input 2"),
("This is a simple pair 1", "This is a simple pair 2"),
],
max_length=max_length,
truncation=True,
padding="max_length",
)
input_p = tokenizer_p.batch_encode_plus(
[
("This is a simple input 1", "This is a simple input 2"),
("This is a simple pair 1", "This is a simple pair 2"),
],
max_length=max_length,
truncation=True,
padding="max_length",
)
assert_batch_padded_input_match(input_r, input_p, max_length)
input_r = tokenizer_r.batch_encode_plus(
[
("This is a simple input 1", "This is a simple input 2"),
("This is a simple pair 1", "This is a simple pair 2"),
],
padding=True,
)
input_p = tokenizer_p.batch_encode_plus(
[
("This is a simple input 1", "This is a simple input 2"),
("This is a simple pair 1", "This is a simple pair 2"),
],
padding="longest",
)
assert_batch_padded_input_match(input_r, input_p, len(input_r["input_ids"][0]))
# Using pad on single examples after tokenization
input_r = tokenizer_r.encode_plus("This is a input 1")
input_r = tokenizer_r.pad(input_r)
input_p = tokenizer_r.encode_plus("This is a input 1")
input_p = tokenizer_r.pad(input_p)
assert_padded_input_match(input_r["input_ids"], input_p["input_ids"], len(input_r["input_ids"]))
# Using pad on single examples after tokenization
input_r = tokenizer_r.encode_plus("This is a input 1")
input_r = tokenizer_r.pad(input_r, max_length=max_length, padding="max_length")
input_p = tokenizer_r.encode_plus("This is a input 1")
input_p = tokenizer_r.pad(input_p, max_length=max_length, padding="max_length")
assert_padded_input_match(input_r["input_ids"], input_p["input_ids"], max_length)
# Using pad after tokenization
input_r = tokenizer_r.batch_encode_plus(
["This is a input 1", "This is a much longer input whilch should be padded"]
)
input_r = tokenizer_r.pad(input_r)
input_p = tokenizer_r.batch_encode_plus(
["This is a input 1", "This is a much longer input whilch should be padded"]
)
input_p = tokenizer_r.pad(input_p)
assert_batch_padded_input_match(input_r, input_p, len(input_r["input_ids"][0]))
# Using pad after tokenization
input_r = tokenizer_r.batch_encode_plus(
["This is a input 1", "This is a much longer input whilch should be padded"]
)
input_r = tokenizer_r.pad(input_r, max_length=max_length, padding="max_length")
input_p = tokenizer_r.batch_encode_plus(
["This is a input 1", "This is a much longer input whilch should be padded"]
)
input_p = tokenizer_r.pad(input_p, max_length=max_length, padding="max_length")
assert_batch_padded_input_match(input_r, input_p, max_length)
def assert_save_pretrained(self, tokenizer_r, tokenizer_p):
# Checks it save with the same files
self.assertSequenceEqual(tokenizer_r.save_vocabulary("."), tokenizer_p.save_vocabulary("."))
# Checks everything loads correctly in the same way
tokenizer_rp, tokenizer_pp = tokenizer_r.from_pretrained("."), tokenizer_p.from_pretrained(".")
# Check special tokens are set accordingly on Rust and Python
for key in tokenizer_pp.special_tokens_map:
self.assertTrue(hasattr(tokenizer_rp, key))
# self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key))
# self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id"))
def assert_embeded_special_tokens(self, tokenizer_r, tokenizer_p):
sentence = "A, <mask> AllenNLP sentence."
tokens_r = tokenizer_r.encode_plus(
sentence, add_special_tokens=True, return_attention_mask=False, return_token_type_ids=True
)
tokens_p = tokenizer_p.encode_plus(
sentence, add_special_tokens=True, return_attention_mask=False, return_token_type_ids=True
)
for key in tokens_p.keys():
self.assertEqual(tokens_r[key], tokens_p[key])
self.assertEqual(sum(tokens_r["token_type_ids"]), 0)
self.assertEqual(sum(tokens_p["token_type_ids"]), 0)
tokens_r = tokenizer_r.convert_ids_to_tokens(tokens_r["input_ids"])
tokens_p = tokenizer_p.convert_ids_to_tokens(tokens_p["input_ids"])
self.assertSequenceEqual(tokens_r, tokens_p)
def assert_add_special_tokens(self, tokenizer_r):
simple_num_special_tokens_to_add = tokenizer_r.num_special_tokens_to_add(pair=False)
# pair_num_special_tokens_to_add = tokenizer_r.num_special_tokens_to_add(pair=True)
for text in ["", " "]:
# tokenize()
no_special_tokens = tokenizer_r.tokenize(text, add_special_tokens=False)
with_special_tokens = tokenizer_r.tokenize(text, add_special_tokens=True)
self.assertEqual(len(no_special_tokens), len(with_special_tokens) - simple_num_special_tokens_to_add)
# encode()
no_special_tokens = tokenizer_r.encode(text, add_special_tokens=False)
with_special_tokens = tokenizer_r.encode(text, add_special_tokens=True)
self.assertEqual(len(no_special_tokens), len(with_special_tokens) - simple_num_special_tokens_to_add)
# encode_plus()
no_special_tokens = tokenizer_r.encode_plus(text, add_special_tokens=False)
with_special_tokens = tokenizer_r.encode_plus(text, add_special_tokens=True)
for key in no_special_tokens.keys():
self.assertEqual(
len(no_special_tokens[key]), len(with_special_tokens[key]) - simple_num_special_tokens_to_add
)
# # batch_encode_plus
no_special_tokens = tokenizer_r.batch_encode_plus([text, text], add_special_tokens=False)
with_special_tokens = tokenizer_r.batch_encode_plus([text, text], add_special_tokens=True)
for key in no_special_tokens.keys():
for i_no, i_with in zip(no_special_tokens[key], with_special_tokens[key]):
self.assertEqual(len(i_no), len(i_with) - simple_num_special_tokens_to_add)
def assert_prepare_for_model(self, tokenizer_r, tokenizer_p):
string_sequence = "Asserting that both tokenizers are equal"
python_output = tokenizer_p.prepare_for_model(tokenizer_p.encode(string_sequence))
rust_output = tokenizer_r.prepare_for_model(tokenizer_r.encode(string_sequence))
self.assertEqual(python_output, rust_output)
class WordPieceFastTokenizerTest(CommonFastTokenizerTest):
"""
Override all the specific methods to test WordPiece behavior
"""
TOKENIZERS_CLASSES = frozenset(
[
Tokenizer("Bert", BertTokenizerFast, BertTokenizer, "vocab_file", filter_non_english, None),
Tokenizer(
"DistilBert", DistilBertTokenizerFast, DistilBertTokenizer, "vocab_file", filter_non_english, None
),
]
)
def fast_only(self, tokenizer_r):
super().fast_only(tokenizer_r)
self.assert_offsets_with_special_characters(tokenizer_r)
def assert_add_special_tokens(self, tokenizer_r):
super().assert_add_special_tokens(tokenizer_r)
def assert_offsets_with_special_characters(self, tokenizer_r):
sentence = "A, naïve [MASK] AllenNLP sentence."
tokens = tokenizer_r.encode_plus(
sentence,
return_attention_mask=False,
return_token_type_ids=False,
return_offsets_mapping=True,
add_special_tokens=True,
)
do_lower_case = tokenizer_r.init_kwargs.get("do_lower_case")
expected_results = (
[
((0, 0), "[CLS]"),
((0, 1), "A"),
((1, 2), ","),
((3, 5), "na"),
((5, 6), "##ï"),
((6, 8), "##ve"),
((9, 15), "[MASK]"),
((16, 21), "Allen"),
((21, 23), "##NL"),
((23, 24), "##P"),
((25, 33), "sentence"),
((33, 34), "."),
((0, 0), "[SEP]"),
]
if not do_lower_case
else [
((0, 0), "[CLS]"),
((0, 1), "a"),
((1, 2), ","),
((3, 8), "naive"),
((9, 15), "[MASK]"),
((16, 21), "allen"),
((21, 23), "##nl"),
((23, 24), "##p"),
((25, 33), "sentence"),
((33, 34), "."),
((0, 0), "[SEP]"),
]
)
self.assertEqual([e[1] for e in expected_results], tokenizer_r.convert_ids_to_tokens(tokens["input_ids"]))
self.assertEqual([e[0] for e in expected_results], tokens["offset_mapping"])
class RobertaFastTokenizerTest(CommonFastTokenizerTest):
TOKENIZERS_CLASSES = frozenset(
[
Tokenizer(
"Roberta",
RobertaTokenizerFast,
RobertaTokenizer,
"vocab_file",
filter_roberta_detectors,
(("cls_token", "<s>"),),
)
]
)
def assert_embeded_special_tokens(self, tokenizer_r, tokenizer_p):
sentence = "A, <mask> AllenNLP sentence."
tokens_r = tokenizer_r.encode_plus(sentence, add_special_tokens=True, return_token_type_ids=True)
tokens_p = tokenizer_p.encode_plus(sentence, add_special_tokens=True, return_token_type_ids=True)
# Rust correctly handles the space before the mask while python doesnt
self.assertSequenceEqual(tokens_r["input_ids"], [0, 250, 6, 50264, 3823, 487, 21992, 3645, 4, 2])
self.assertSequenceEqual(tokens_p["input_ids"], [0, 250, 6, 50264, 3823, 487, 21992, 3645, 4, 2])
# token_type_ids should put 0 everywhere
self.assertEqual(sum(tokens_r["token_type_ids"]), sum(tokens_p["token_type_ids"]))
# attention_mask should put 1 everywhere, so sum over length should be 1
self.assertEqual(
sum(tokens_r["attention_mask"]) / len(tokens_r["attention_mask"]),
sum(tokens_p["attention_mask"]) / len(tokens_p["attention_mask"]),
)
tokens_r = tokenizer_r.convert_ids_to_tokens(tokens_r["input_ids"])
tokens_p = tokenizer_p.convert_ids_to_tokens(tokens_p["input_ids"])
self.assertSequenceEqual(tokens_r, ["<s>", "A", ",", "<mask>", "ĠAllen", "N", "LP", "Ġsentence", ".", "</s>"])
self.assertSequenceEqual(tokens_p, ["<s>", "A", ",", "<mask>", "ĠAllen", "N", "LP", "Ġsentence", ".", "</s>"])
class NoPaddingTokenFastTokenizerMatchingTest(CommonFastTokenizerTest):
TOKENIZERS_CLASSES = [
Tokenizer("OpenAI GPT", OpenAIGPTTokenizerFast, OpenAIGPTTokenizer, "vocab_file", None, None),
Tokenizer("GPT2", GPT2TokenizerFast, GPT2Tokenizer, "vocab_file", None, [("add_prefix_space", True)]),
]
def fast_align_python(self, tokenizer_r, tokenizer_p, tok_case, pretrained_name):
# Check is_fast is set correctly
self.assertFalse(tokenizer_p.is_fast)
self.assertTrue(tokenizer_r.is_fast)
# Check that Rust and Python align
self.assert_tokenization_python_rust_equals(tokenizer_r, tokenizer_p)
self.assert_num_special_tokens_to_add_equal(tokenizer_r, tokenizer_p)
self.assert_max_length_equal(tokenizer_r, tokenizer_p)
self.assert_special_tokens_map_equal(tokenizer_r, tokenizer_p)
self.assert_embeded_special_tokens(tokenizer_r, tokenizer_p)
self.assert_padding(tokenizer_r, tokenizer_p)
# Specific for
kwargs = {}
if tok_case.kwargs is not None:
kwargs = dict(tok_case.kwargs)
tokenizer_r = tok_case.rust_cls.from_pretrained(pretrained_name, **kwargs)
self.assert_pretokenized_inputs(tokenizer_r, tokenizer_p)
def assert_padding(self, tokenizer_r, tokenizer_p, max_length=15):
# Simple input
s = "This is a simple input"
s2 = ["This is a simple input 1", "This is a simple input 2"]
p = ("This is a simple input", "This is a pair")
p2 = [
("This is a simple input 1", "This is a simple input 2"),
("This is a simple pair 1", "This is a simple pair 2"),
]
# Simple input tests
self.assertRaises(ValueError, tokenizer_r.encode, s, max_length=max_length, padding="max_length")
# Simple input
self.assertRaises(ValueError, tokenizer_r.encode_plus, s, max_length=max_length, padding="max_length")
# Simple input
self.assertRaises(
ValueError,
tokenizer_r.batch_encode_plus,
s2,
max_length=max_length,
padding="max_length",
)
# Pair input
self.assertRaises(ValueError, tokenizer_r.encode, p, max_length=max_length, padding="max_length")
# Pair input
self.assertRaises(ValueError, tokenizer_r.encode_plus, p, max_length=max_length, padding="max_length")
# Pair input
self.assertRaises(
ValueError,
tokenizer_r.batch_encode_plus,
p2,
max_length=max_length,
padding="max_length",
)
class TransfoXLFastTokenizerTest(NoPaddingTokenFastTokenizerMatchingTest):
TOKENIZERS_CLASSES = frozenset(
[Tokenizer("TransfoXL", TransfoXLTokenizerFast, TransfoXLTokenizer, "pretrained_vocab_file", None, None)]
)
@require_torch
def test_all_tokenizers(self):
super().test_all_tokenizers()
@require_torch
def test_pretokenized_tokenizers(self):
super().test_pretokenized_tokenizers()
| [] |
2024-01-10 | lucidworks/transformers-clone | src~transformers~modeling_tf_openai.py | # coding=utf-8
# Copyright 2018 The OpenAI Team Authors and HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
""" TF 2.0 OpenAI GPT model."""
from dataclasses import dataclass
from typing import Optional, Tuple
import numpy as np
import tensorflow as tf
from .configuration_openai import OpenAIGPTConfig
from .file_utils import (
ModelOutput,
add_code_sample_docstrings,
add_start_docstrings,
add_start_docstrings_to_callable,
replace_return_docstrings,
)
from .modeling_tf_outputs import TFBaseModelOutput, TFCausalLMOutput
from .modeling_tf_utils import (
TFCausalLanguageModelingLoss,
TFConv1D,
TFPreTrainedModel,
TFSequenceSummary,
TFSharedEmbeddings,
get_initializer,
keras_serializable,
shape_list,
)
from .tokenization_utils import BatchEncoding
from .utils import logging
logger = logging.get_logger(__name__)
_CONFIG_FOR_DOC = "OpenAIGPTConfig"
_TOKENIZER_FOR_DOC = "OpenAIGPTTokenizer"
TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST = [
"openai-gpt",
# See all OpenAI GPT models at https://huggingface.co/models?filter=openai-gpt
]
def gelu(x):
"""Gaussian Error Linear Unit.
This is a smoother version of the RELU.
Original paper: https://arxiv.org/abs/1606.08415
Args:
x: float Tensor to perform activation.
Returns:
`x` with the GELU activation applied.
"""
cdf = 0.5 * (1.0 + tf.tanh((np.sqrt(2 / np.pi) * (x + 0.044715 * tf.pow(x, 3)))))
return x * cdf
def swish(x):
return x * tf.math.sigmoid(x)
ACT_FNS = {
"gelu": tf.keras.layers.Activation(gelu),
"relu": tf.keras.activations.relu,
"swish": tf.keras.layers.Activation(swish),
}
class TFAttention(tf.keras.layers.Layer):
def __init__(self, nx, n_ctx, config, scale=False, **kwargs):
super().__init__(**kwargs)
n_state = nx # in Attention: n_state=768 (nx=n_embd)
# [switch nx => n_state from Block to Attention to keep identical to TF implem]
assert (
n_state % config.n_head == 0
), f"Hidden dimension {n_state} not dividable by number of heads {config.n_head}"
self.n_ctx = n_ctx
self.n_head = config.n_head
self.split_size = n_state
self.scale = scale
self.output_attentions = config.output_attentions
self.c_attn = TFConv1D(n_state * 3, nx, initializer_range=config.initializer_range, name="c_attn")
self.c_proj = TFConv1D(n_state, nx, initializer_range=config.initializer_range, name="c_proj")
self.attn_dropout = tf.keras.layers.Dropout(config.attn_pdrop)
self.resid_dropout = tf.keras.layers.Dropout(config.resid_pdrop)
self.pruned_heads = set()
def prune_heads(self, heads):
pass
@staticmethod
def causal_attention_mask(nd, ns, dtype):
"""1's in the lower triangle, counting from the lower right corner.
Same as tf.matrix_band_part(tf.ones([nd, ns]), -1, ns-nd), but doesn't produce garbage on TPUs.
"""
i = tf.range(nd)[:, None]
j = tf.range(ns)
m = i >= j - ns + nd
return tf.cast(m, dtype)
def _attn(self, q, k, v, attention_mask, head_mask, output_attentions, training=False):
# q, k, v have shape [batch, heads, sequence, features]
w = tf.matmul(q, k, transpose_b=True)
if self.scale:
dk = tf.cast(shape_list(k)[-1], tf.float32) # scale attention_scores
w = w / tf.math.sqrt(dk)
# w has shape [batch, heads, dst_sequence, src_sequence], where information flows from src to dst.
_, _, nd, ns = shape_list(w)
b = self.causal_attention_mask(nd, ns, dtype=w.dtype)
b = tf.reshape(b, [1, 1, nd, ns])
w = w * b - 1e4 * (1 - b)
if attention_mask is not None:
# Apply the attention mask
w = w + attention_mask
w = tf.nn.softmax(w, axis=-1)
w = self.attn_dropout(w, training=training)
# Mask heads if we want to
if head_mask is not None:
w = w * head_mask
outputs = [tf.matmul(w, v)]
if output_attentions:
outputs.append(w)
return outputs
def merge_heads(self, x):
x = tf.transpose(x, [0, 2, 1, 3])
x_shape = shape_list(x)
new_x_shape = x_shape[:-2] + [x_shape[-2] * x_shape[-1]]
return tf.reshape(x, new_x_shape)
def split_heads(self, x):
x_shape = shape_list(x)
new_x_shape = x_shape[:-1] + [self.n_head, x_shape[-1] // self.n_head]
x = tf.reshape(x, new_x_shape)
return tf.transpose(x, (0, 2, 1, 3)) # (batch, head, seq_length, head_features)
def call(self, x, attention_mask, head_mask, output_attentions, training=False):
x = self.c_attn(x)
query, key, value = tf.split(x, 3, axis=2)
query = self.split_heads(query)
key = self.split_heads(key)
value = self.split_heads(value)
attn_outputs = self._attn(query, key, value, attention_mask, head_mask, output_attentions, training=training)
a = attn_outputs[0]
a = self.merge_heads(a)
a = self.c_proj(a)
a = self.resid_dropout(a, training=training)
outputs = [a] + attn_outputs[1:]
return outputs # a, (attentions)
class TFMLP(tf.keras.layers.Layer):
def __init__(self, n_state, config, **kwargs):
super().__init__(**kwargs)
nx = config.n_embd
self.c_fc = TFConv1D(n_state, nx, initializer_range=config.initializer_range, name="c_fc")
self.c_proj = TFConv1D(nx, n_state, initializer_range=config.initializer_range, name="c_proj")
self.act = gelu
self.dropout = tf.keras.layers.Dropout(config.resid_pdrop)
def call(self, x, training=False):
h = self.act(self.c_fc(x))
h2 = self.c_proj(h)
h2 = self.dropout(h2, training=training)
return h2
class TFBlock(tf.keras.layers.Layer):
def __init__(self, n_ctx, config, scale=False, **kwargs):
super().__init__(**kwargs)
nx = config.n_embd
self.attn = TFAttention(nx, n_ctx, config, scale, name="attn")
self.ln_1 = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_epsilon, name="ln_1")
self.mlp = TFMLP(4 * nx, config, name="mlp")
self.ln_2 = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_epsilon, name="ln_2")
def call(self, x, attention_mask, head_mask, output_attentions, training=False):
output_attn = self.attn(x, attention_mask, head_mask, output_attentions, training=training)
a = output_attn[0] # output_attn: a, (attentions)
n = self.ln_1(x + a)
m = self.mlp(n, training=training)
h = self.ln_2(n + m)
outputs = [h] + output_attn[1:]
return outputs # x, (attentions)
@keras_serializable
class TFOpenAIGPTMainLayer(tf.keras.layers.Layer):
config_class = OpenAIGPTConfig
def __init__(self, config, *inputs, **kwargs):
super().__init__(*inputs, **kwargs)
self.output_hidden_states = config.output_hidden_states
self.output_attentions = config.output_attentions
self.return_dict = config.use_return_dict
self.num_hidden_layers = config.n_layer
self.vocab_size = config.vocab_size
self.n_embd = config.n_embd
self.tokens_embed = TFSharedEmbeddings(
config.vocab_size, config.n_embd, initializer_range=config.initializer_range, name="tokens_embed"
)
self.positions_embed = tf.keras.layers.Embedding(
config.n_positions,
config.n_embd,
embeddings_initializer=get_initializer(config.initializer_range),
name="positions_embed",
)
self.drop = tf.keras.layers.Dropout(config.embd_pdrop)
self.h = [TFBlock(config.n_ctx, config, scale=True, name="h_._{}".format(i)) for i in range(config.n_layer)]
def get_input_embeddings(self):
return self.tokens_embed
def set_input_embeddings(self, value):
self.tokens_embed.weight = value
self.tokens_embed.vocab_size = value.shape[0]
def _prune_heads(self, heads_to_prune):
"""Prunes heads of the model.
heads_to_prune: dict of {layer_num: list of heads to prune in this layer}
"""
raise NotImplementedError
def call(
self,
inputs,
attention_mask=None,
token_type_ids=None,
position_ids=None,
head_mask=None,
inputs_embeds=None,
output_attentions=None,
output_hidden_states=None,
return_dict=None,
training=False,
):
if isinstance(inputs, (tuple, list)):
input_ids = inputs[0]
attention_mask = inputs[1] if len(inputs) > 1 else attention_mask
token_type_ids = inputs[2] if len(inputs) > 2 else token_type_ids
position_ids = inputs[3] if len(inputs) > 3 else position_ids
head_mask = inputs[4] if len(inputs) > 4 else head_mask
inputs_embeds = inputs[5] if len(inputs) > 5 else inputs_embeds
output_attentions = inputs[6] if len(inputs) > 6 else output_attentions
output_hidden_states = inputs[7] if len(inputs) > 7 else output_hidden_states
return_dict = inputs[8] if len(inputs) > 8 else return_dict
assert len(inputs) <= 9, "Too many inputs."
elif isinstance(inputs, (dict, BatchEncoding)):
input_ids = inputs.get("input_ids")
attention_mask = inputs.get("attention_mask", attention_mask)
token_type_ids = inputs.get("token_type_ids", token_type_ids)
position_ids = inputs.get("position_ids", position_ids)
head_mask = inputs.get("head_mask", head_mask)
inputs_embeds = inputs.get("inputs_embeds", inputs_embeds)
output_attentions = inputs.get("output_attentions", output_attentions)
output_hidden_states = inputs.get("output_hidden_states", output_hidden_states)
return_dict = inputs.get("return_dict", return_dict)
assert len(inputs) <= 9, "Too many inputs."
else:
input_ids = inputs
output_attentions = output_attentions if output_attentions is not None else self.output_attentions
output_hidden_states = output_hidden_states if output_hidden_states is not None else self.output_hidden_states
return_dict = return_dict if return_dict is not None else self.return_dict
if input_ids is not None and inputs_embeds is not None:
raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
elif input_ids is not None:
input_shape = shape_list(input_ids)
input_ids = tf.reshape(input_ids, [-1, input_shape[-1]])
elif inputs_embeds is not None:
input_shape = shape_list(inputs_embeds)[:-1]
else:
raise ValueError("You have to specify either input_ids or inputs_embeds")
if position_ids is None:
position_ids = tf.range(input_shape[-1], dtype=tf.int32)[tf.newaxis, :]
if attention_mask is not None:
# We create a 3D attention mask from a 2D tensor mask.
# Sizes are [batch_size, 1, 1, to_seq_length]
# So we can broadcast to [batch_size, num_heads, from_seq_length, to_seq_length]
# this attention mask is more simple than the triangular masking of causal attention
# used in OpenAI GPT, we just need to prepare the broadcast dimension here.
attention_mask = attention_mask[:, tf.newaxis, tf.newaxis, :]
# Since attention_mask is 1.0 for positions we want to attend and 0.0 for
# masked positions, this operation will create a tensor which is 0.0 for
# positions we want to attend and -10000.0 for masked positions.
# Since we are adding it to the raw scores before the softmax, this is
# effectively the same as removing these entirely.
attention_mask = tf.cast(attention_mask, tf.float32)
attention_mask = (1.0 - attention_mask) * -10000.0
else:
attention_mask = None
# Prepare head mask if needed
# 1.0 in head_mask indicate we keep the head
# attention_probs has shape bsz x n_heads x N x N
# input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
# and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
if head_mask is not None:
raise NotImplementedError
else:
head_mask = [None] * self.num_hidden_layers
# head_mask = tf.constant([0] * self.num_hidden_layers)
position_ids = tf.reshape(position_ids, [-1, shape_list(position_ids)[-1]])
if inputs_embeds is None:
inputs_embeds = self.tokens_embed(input_ids, mode="embedding")
position_embeds = self.positions_embed(position_ids)
if token_type_ids is not None:
token_type_ids = tf.reshape(token_type_ids, [-1, shape_list(token_type_ids)[-1]])
token_type_embeds = self.tokens_embed(token_type_ids, mode="embedding")
else:
token_type_embeds = 0
hidden_states = inputs_embeds + position_embeds + token_type_embeds
hidden_states = self.drop(hidden_states, training=training)
output_shape = input_shape + [shape_list(hidden_states)[-1]]
all_attentions = () if output_attentions else None
all_hidden_states = () if output_hidden_states else None
for i, block in enumerate(self.h):
if output_hidden_states:
all_hidden_states = all_hidden_states + (tf.reshape(hidden_states, output_shape),)
outputs = block(hidden_states, attention_mask, head_mask[i], output_attentions, training=training)
hidden_states = outputs[0]
if output_attentions:
all_attentions = all_attentions + (outputs[1],)
hidden_states = tf.reshape(hidden_states, output_shape)
# Add last hidden state
if output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states,)
if output_attentions:
# let the number of heads free (-1) so we can extract attention even after head pruning
attention_output_shape = input_shape[:-1] + [-1] + shape_list(all_attentions[0])[-2:]
all_attentions = tuple(tf.reshape(t, attention_output_shape) for t in all_attentions)
if not return_dict:
return tuple(v for v in [hidden_states, all_hidden_states, all_attentions] if v is not None)
return TFBaseModelOutput(
last_hidden_state=hidden_states,
hidden_states=all_hidden_states,
attentions=all_attentions,
)
class TFOpenAIGPTPreTrainedModel(TFPreTrainedModel):
"""An abstract class to handle weights initialization and
a simple interface for downloading and loading pretrained models.
"""
config_class = OpenAIGPTConfig
base_model_prefix = "transformer"
@dataclass
class TFOpenAIGPTDoubleHeadsModelOutput(ModelOutput):
"""
Base class for outputs of models predicting if two sentences are consecutive or not.
Args:
lm_logits (:obj:`tf.Tensor` of shape :obj:`(batch_size, num_choices, sequence_length, config.vocab_size)`):
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
mc_logits (:obj:`tf.Tensor` of shape :obj:`(batch_size, num_choices)`):
Prediction scores of the multiple choice classification head (scores for each choice before SoftMax).
hidden_states (:obj:`tuple(tf.Tensor)`, `optional`, returned when ``output_hidden_states=True`` is passed or when ``config.output_hidden_states=True``):
Tuple of :obj:`tf.Tensor` (one for the output of the embeddings + one for the output of each layer)
of shape :obj:`(batch_size, sequence_length, hidden_size)`.
Hidden-states of the model at the output of each layer plus the initial embedding outputs.
attentions (:obj:`tuple(tf.Tensor)`, `optional`, returned when ``output_attentions=True`` is passed or when ``config.output_attentions=True``):
Tuple of :obj:`tf.Tensor` (one for each layer) of shape
:obj:`(batch_size, num_heads, sequence_length, sequence_length)`.
Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.
"""
lm_logits: tf.Tensor = None
mc_logits: tf.Tensor = None
hidden_states: Optional[Tuple[tf.Tensor]] = None
attentions: Optional[Tuple[tf.Tensor]] = None
OPENAI_GPT_START_DOCSTRING = r"""
.. note::
TF 2.0 models accepts two formats as inputs:
- having all inputs as keyword arguments (like PyTorch models), or
- having all inputs as a list, tuple or dict in the first positional arguments.
This second option is useful when using :obj:`tf.keras.Model.fit()` method which currently requires having
all the tensors in the first argument of the model call function: :obj:`model(inputs)`.
If you choose this second option, there are three possibilities you can use to gather all the input Tensors
in the first positional argument :
- a single Tensor with input_ids only and nothing else: :obj:`model(inputs_ids)`
- a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
:obj:`model([input_ids, attention_mask])` or :obj:`model([input_ids, attention_mask, token_type_ids])`
- a dictionary with one or several input Tensors associated to the input names given in the docstring:
:obj:`model({'input_ids': input_ids, 'token_type_ids': token_type_ids})`
Parameters:
config (:class:`~transformers.OpenAIGPTConfig`): Model configuration class with all the parameters of the model.
Initializing with a config file does not load the weights associated with the model, only the configuration.
Check out the :meth:`~transformers.PreTrainedModel.from_pretrained` method to load the model weights.
"""
OPENAI_GPT_INPUTS_DOCSTRING = r"""
Args:
input_ids (:obj:`Numpy array` or :obj:`tf.Tensor` of shape :obj:`(batch_size, sequence_length)`):
Indices of input sequence tokens in the vocabulary.
Indices can be obtained using :class:`transformers.GPT2Tokenizer`.
See :func:`transformers.PreTrainedTokenizer.encode` and
:func:`transformers.PreTrainedTokenizer.__call__` for details.
`What are input IDs? <../glossary.html#input-ids>`__
attention_mask (:obj:`tf.Tensor` or :obj:`Numpy array` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
Mask to avoid performing attention on padding token indices.
Mask values selected in ``[0, 1]``:
``1`` for tokens that are NOT MASKED, ``0`` for MASKED tokens.
`What are attention masks? <../glossary.html#attention-mask>`__
token_type_ids (:obj:`tf.Tensor` or :obj:`Numpy array` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
Segment token indices to indicate first and second portions of the inputs.
Indices are selected in ``[0, 1]``: ``0`` corresponds to a `sentence A` token, ``1``
corresponds to a `sentence B` token
`What are token type IDs? <../glossary.html#token-type-ids>`_
position_ids (:obj:`tf.Tensor` or :obj:`Numpy array` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
Indices of positions of each input sequence tokens in the position embeddings.
Selected in the range ``[0, config.max_position_embeddings - 1]``.
`What are position IDs? <../glossary.html#position-ids>`_
head_mask (:obj:`tf.Tensor` or :obj:`Numpy array` of shape :obj:`(num_heads,)` or :obj:`(num_layers, num_heads)`, `optional`, defaults to :obj:`None`):
Mask to nullify selected heads of the self-attention modules.
Mask values selected in ``[0, 1]``:
:obj:`1` indicates the head is **not masked**, :obj:`0` indicates the head is **masked**.
inputs_embeds (:obj:`tf.Tensor` or :obj:`Numpy array` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`, defaults to :obj:`None`):
Optionally, instead of passing :obj:`input_ids` you can choose to directly pass an embedded representation.
This is useful if you want more control over how to convert `input_ids` indices into associated vectors
than the model's internal embedding lookup matrix.
training (:obj:`boolean`, `optional`, defaults to :obj:`False`):
Whether to activate dropout modules (if set to :obj:`True`) during training or to de-activate them
(if set to :obj:`False`) for evaluation.
output_attentions (:obj:`bool`, `optional`, defaults to :obj:`None`):
If set to ``True``, the attentions tensors of all attention layers are returned. See ``attentions`` under returned tensors for more detail.
output_hidden_states (:obj:`bool`, `optional`, defaults to :obj:`None`):
If set to ``True``, the hidden states of all layers are returned. See ``hidden_states`` under returned tensors for more detail.
return_dict (:obj:`bool`, `optional`, defaults to :obj:`None`):
If set to ``True``, the model will return a :class:`~transformers.file_utils.ModelOutput` instead of a
plain tuple.
"""
@add_start_docstrings(
"The bare OpenAI GPT transformer model outputing raw hidden-states without any specific head on top.",
OPENAI_GPT_START_DOCSTRING,
)
class TFOpenAIGPTModel(TFOpenAIGPTPreTrainedModel):
def __init__(self, config, *inputs, **kwargs):
super().__init__(config, *inputs, **kwargs)
self.transformer = TFOpenAIGPTMainLayer(config, name="transformer")
@add_start_docstrings_to_callable(OPENAI_GPT_INPUTS_DOCSTRING)
@add_code_sample_docstrings(
tokenizer_class=_TOKENIZER_FOR_DOC,
checkpoint="openai-gpt",
output_type=TFBaseModelOutput,
config_class=_CONFIG_FOR_DOC,
)
def call(self, inputs, **kwargs):
outputs = self.transformer(inputs, **kwargs)
return outputs
@add_start_docstrings(
"""OpenAI GPT Model transformer with a language modeling head on top
(linear layer with weights tied to the input embeddings). """,
OPENAI_GPT_START_DOCSTRING,
)
class TFOpenAIGPTLMHeadModel(TFOpenAIGPTPreTrainedModel, TFCausalLanguageModelingLoss):
def __init__(self, config, *inputs, **kwargs):
super().__init__(config, *inputs, **kwargs)
self.transformer = TFOpenAIGPTMainLayer(config, name="transformer")
def get_output_embeddings(self):
return self.transformer.tokens_embed
@add_start_docstrings_to_callable(OPENAI_GPT_INPUTS_DOCSTRING)
@add_code_sample_docstrings(
tokenizer_class=_TOKENIZER_FOR_DOC,
checkpoint="openai-gpt",
output_type=TFCausalLMOutput,
config_class=_CONFIG_FOR_DOC,
)
def call(
self,
inputs,
attention_mask=None,
token_type_ids=None,
position_ids=None,
head_mask=None,
inputs_embeds=None,
output_attentions=None,
output_hidden_states=None,
return_dict=None,
labels=None,
training=False,
):
r"""
labels (:obj:`tf.Tensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
Labels for computing the cross entropy classification loss.
Indices should be in ``[0, ..., config.vocab_size - 1]``.
"""
return_dict = return_dict if return_dict is not None else self.transformer.return_dict
if isinstance(inputs, (tuple, list)):
labels = inputs[9] if len(inputs) > 9 else labels
if len(inputs) > 9:
inputs = inputs[:9]
elif isinstance(inputs, (dict, BatchEncoding)):
labels = inputs.pop("labels", labels)
transformer_outputs = self.transformer(
inputs,
attention_mask=attention_mask,
token_type_ids=token_type_ids,
position_ids=position_ids,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
training=training,
)
hidden_states = transformer_outputs[0]
logits = self.transformer.tokens_embed(hidden_states, mode="linear")
loss = None
if labels is not None:
# shift labels to the left and cut last logit token
logits = logits[:, :-1]
labels = labels[:, 1:]
loss = self.compute_loss(labels, logits)
if not return_dict:
output = (logits,) + transformer_outputs[1:]
return ((loss,) + output) if loss is not None else output
return TFCausalLMOutput(
loss=loss,
logits=logits,
hidden_states=transformer_outputs.hidden_states,
attentions=transformer_outputs.attentions,
)
@add_start_docstrings(
"""OpenAI GPT Model transformer with a language modeling and a multiple-choice classification
head on top e.g. for RocStories/SWAG tasks. The two heads are two linear layers.
The language modeling head has its weights tied to the input embeddings,
the classification head takes as input the input of a specified classification token index in the input sequence).
""",
OPENAI_GPT_START_DOCSTRING,
)
class TFOpenAIGPTDoubleHeadsModel(TFOpenAIGPTPreTrainedModel):
def __init__(self, config, *inputs, **kwargs):
super().__init__(config, *inputs, **kwargs)
config.num_labels = 1
self.transformer = TFOpenAIGPTMainLayer(config, name="transformer")
self.multiple_choice_head = TFSequenceSummary(
config, initializer_range=config.initializer_range, name="multiple_choice_head"
)
def get_output_embeddings(self):
return self.transformer.tokens_embed
@add_start_docstrings_to_callable(OPENAI_GPT_INPUTS_DOCSTRING)
@replace_return_docstrings(output_type=TFOpenAIGPTDoubleHeadsModelOutput, config_class=_CONFIG_FOR_DOC)
def call(
self,
inputs,
attention_mask=None,
token_type_ids=None,
position_ids=None,
head_mask=None,
inputs_embeds=None,
mc_token_ids=None,
output_attentions=None,
output_hidden_states=None,
return_dict=None,
training=False,
):
r"""
mc_token_ids (:obj:`tf.Tensor` or :obj:`Numpy array` of shape :obj:`(batch_size, num_choices)`, `optional`, default to index of the last token of the input)
Index of the classification token in each input sequence.
Selected in the range ``[0, input_ids.size(-1) - 1]``.
Return:
Examples::
>>> import tensorflow as tf
>>> from transformers import OpenAIGPTTokenizer, TFOpenAIGPTDoubleHeadsModel
>>> tokenizer = OpenAIGPTTokenizer.from_pretrained('openai-gpt')
>>> model = TFOpenAIGPTDoubleHeadsModel.from_pretrained('openai-gpt')
>>> # Add a [CLS] to the vocabulary (we should train it also!)
>>> tokenizer.add_special_tokens({'cls_token': '[CLS]'})
>>> model.resize_token_embeddings(len(tokenizer)) # Update the model embeddings with the new vocabulary size
>>> print(tokenizer.cls_token_id, len(tokenizer)) # The newly token the last token of the vocabulary
>>> choices = ["Hello, my dog is cute [CLS]", "Hello, my cat is cute [CLS]"]
>>> encoding = tokenizer(choices, return_tensors="tf")
>>> inputs = {k: tf.expand_dims(v, 0) for k, v in encoding.items()}
>>> inputs["mc_token_ids"]= tf.constant([inputs["input_ids"].shape[-1] - 1, inputs["input_ids"].shape[-1] - 1])[None, :] # Batch size 1
>>> outputs = model(inputs)
>>> lm_prediction_scores, mc_prediction_scores = outputs[:2]
"""
if isinstance(inputs, (tuple, list)):
input_ids = inputs[0]
attention_mask = inputs[1] if len(inputs) > 1 else attention_mask
token_type_ids = inputs[2] if len(inputs) > 2 else token_type_ids
position_ids = inputs[3] if len(inputs) > 3 else position_ids
head_mask = inputs[4] if len(inputs) > 4 else head_mask
inputs_embeds = inputs[5] if len(inputs) > 5 else inputs_embeds
mc_token_ids = inputs[6] if len(inputs) > 6 else mc_token_ids
output_attentions = inputs[7] if len(inputs) > 7 else output_attentions
output_hidden_states = inputs[8] if len(inputs) > 8 else output_hidden_states
return_dict = inputs[9] if len(inputs) > 9 else return_dict
assert len(inputs) <= 10, "Too many inputs."
elif isinstance(inputs, (dict, BatchEncoding)):
input_ids = inputs.get("input_ids")
attention_mask = inputs.get("attention_mask", attention_mask)
token_type_ids = inputs.get("token_type_ids", token_type_ids)
position_ids = inputs.get("position_ids", position_ids)
head_mask = inputs.get("head_mask", head_mask)
inputs_embeds = inputs.get("inputs_embeds", inputs_embeds)
mc_token_ids = inputs.get("mc_token_ids", mc_token_ids)
output_attentions = inputs.get("output_attentions", output_attentions)
output_hidden_states = inputs.get("output_hidden_states", output_hidden_states)
return_dict = inputs.get("return_dict", return_dict)
assert len(inputs) <= 10, "Too many inputs."
else:
input_ids = inputs
return_dict = return_dict if return_dict is not None else self.transformer.return_dict
if input_ids is not None:
input_shapes = shape_list(input_ids)
else:
input_shapes = shape_list(inputs_embeds)[:-1]
seq_length = input_shapes[-1]
flat_input_ids = tf.reshape(input_ids, (-1, seq_length)) if input_ids is not None else None
flat_attention_mask = tf.reshape(attention_mask, (-1, seq_length)) if attention_mask is not None else None
flat_token_type_ids = tf.reshape(token_type_ids, (-1, seq_length)) if token_type_ids is not None else None
flat_position_ids = tf.reshape(position_ids, (-1, seq_length)) if position_ids is not None else None
transformer_outputs = self.transformer(
flat_input_ids,
flat_attention_mask,
flat_token_type_ids,
flat_position_ids,
head_mask,
inputs_embeds,
output_attentions,
output_hidden_states,
return_dict=return_dict,
training=training,
)
hidden_states = transformer_outputs[0]
hidden_states = tf.reshape(hidden_states, input_shapes + shape_list(hidden_states)[-1:])
lm_logits = self.transformer.tokens_embed(hidden_states, mode="linear")
mc_logits = self.multiple_choice_head(hidden_states, mc_token_ids, training=training)
mc_logits = tf.squeeze(mc_logits, axis=-1)
if not return_dict:
return (lm_logits, mc_logits) + transformer_outputs[1:]
return TFOpenAIGPTDoubleHeadsModelOutput(
lm_logits=lm_logits,
mc_logits=mc_logits,
hidden_states=transformer_outputs.hidden_states,
attentions=transformer_outputs.attentions,
)
| [] |
2024-01-10 | lucidworks/transformers-clone | src~transformers~configuration_openai.py | # coding=utf-8
# Copyright 2018 The OpenAI Team Authors and HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
""" OpenAI GPT configuration """
from .configuration_utils import PretrainedConfig
from .utils import logging
logger = logging.get_logger(__name__)
OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP = {
"openai-gpt": "https://s3.amazonaws.com/models.huggingface.co/bert/openai-gpt-config.json"
}
class OpenAIGPTConfig(PretrainedConfig):
"""
This is the configuration class to store the configuration of a :class:`~transformers.OpenAIGPTModel`.
It is used to instantiate an GPT model according to the specified arguments, defining the model
architecture. Instantiating a configuration with the defaults will yield a similar configuration to that of
the `GPT <https://huggingface.co/openai-gpt>`__ architecture from OpenAI.
Configuration objects inherit from :class:`~transformers.PretrainedConfig` and can be used
to control the model outputs. Read the documentation from :class:`~transformers.PretrainedConfig`
for more information.
Args:
vocab_size (:obj:`int`, optional, defaults to 40478):
Vocabulary size of the GPT model. Defines the different tokens that
can be represented by the `inputs_ids` passed to the forward method of :class:`~transformers.CTRLModel`.
n_positions (:obj:`int`, optional, defaults to 512):
The maximum sequence length that this model might ever be used with.
Typically set this to something large just in case (e.g., 512 or 1024 or 2048).
n_ctx (:obj:`int`, optional, defaults to 512):
Dimensionality of the causal mask (usually same as n_positions).
n_embd (:obj:`int`, optional, defaults to 768):
Dimensionality of the embeddings and hidden states.
n_layer (:obj:`int`, optional, defaults to 12):
Number of hidden layers in the Transformer encoder.
n_head (:obj:`int`, optional, defaults to 12):
Number of attention heads for each attention layer in the Transformer encoder.
afn (:obj:`str` or :obj:`function`, optional, defaults to "gelu"):
The non-linear activation function (function or string) in the encoder and pooler.
If string, "gelu", "relu", "swish" and "gelu_new" are supported.
resid_pdrop (:obj:`float`, optional, defaults to 0.1):
The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.
embd_pdrop (:obj:`int`, optional, defaults to 0.1):
The dropout ratio for the embeddings.
attn_pdrop (:obj:`float`, optional, defaults to 0.1):
The dropout ratio for the attention.
layer_norm_epsilon (:obj:`float`, optional, defaults to 1e-5):
The epsilon to use in the layer normalization layers
initializer_range (:obj:`float`, optional, defaults to 0.02):
The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
predict_special_tokens (:obj:`boolean`, optional, defaults to :obj:`True`):
Whether special tokens should be predicted when the model is has a language modeling head.
summary_type (:obj:`string`, optional, defaults to "cls_index"):
Argument used when doing sequence summary. Used in for the multiple choice head in
:class:`~transformers.OpenAIGPTDoubleHeadsModel`.
Is one of the following options:
- 'last' => take the last token hidden state (like XLNet)
- 'first' => take the first token hidden state (like Bert)
- 'mean' => take the mean of all tokens hidden states
- 'cls_index' => supply a Tensor of classification token position (GPT/GPT-2)
- 'attn' => Not implemented now, use multi-head attention
summary_use_proj (:obj:`boolean`, optional, defaults to :obj:`True`):
Argument used when doing sequence summary. Used in for the multiple choice head in
:class:`~transformers.OpenAIGPTDoubleHeadsModel`.
Add a projection after the vector extraction
summary_activation (:obj:`string` or :obj:`None`, optional, defaults to :obj:`None`):
Argument used when doing sequence summary. Used in for the multiple choice head in
:class:`~transformers.OpenAIGPTDoubleHeadsModel`.
'tanh' => add a tanh activation to the output, Other => no activation.
summary_proj_to_labels (:obj:`boolean`, optional, defaults to :obj:`True`):
Argument used when doing sequence summary. Used in for the multiple choice head in
:class:`~transformers.OpenAIGPTDoubleHeadsModel`.
If True, the projection outputs to config.num_labels classes (otherwise to hidden_size). Default: False.
summary_first_dropout (:obj:`float`, optional, defaults to 0.1):
Argument used when doing sequence summary. Used in for the multiple choice head in
:class:`~transformers.OpenAIGPTDoubleHeadsModel`.
Add a dropout before the projection and activation
Example::
>>> from transformers import OpenAIGPTConfig, OpenAIGPTModel
>>> # Initializing a GPT configuration
>>> configuration = OpenAIGPTConfig()
>>> # Initializing a model from the configuration
>>> model = OpenAIGPTModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
"""
model_type = "openai-gpt"
def __init__(
self,
vocab_size=40478,
n_positions=512,
n_ctx=512,
n_embd=768,
n_layer=12,
n_head=12,
afn="gelu",
resid_pdrop=0.1,
embd_pdrop=0.1,
attn_pdrop=0.1,
layer_norm_epsilon=1e-5,
initializer_range=0.02,
predict_special_tokens=True,
summary_type="cls_index",
summary_use_proj=True,
summary_activation=None,
summary_proj_to_labels=True,
summary_first_dropout=0.1,
**kwargs
):
super().__init__(**kwargs)
self.vocab_size = vocab_size
self.n_ctx = n_ctx
self.n_positions = n_positions
self.n_embd = n_embd
self.n_layer = n_layer
self.n_head = n_head
self.afn = afn
self.resid_pdrop = resid_pdrop
self.embd_pdrop = embd_pdrop
self.attn_pdrop = attn_pdrop
self.layer_norm_epsilon = layer_norm_epsilon
self.initializer_range = initializer_range
self.predict_special_tokens = predict_special_tokens
self.summary_type = summary_type
self.summary_use_proj = summary_use_proj
self.summary_activation = summary_activation
self.summary_first_dropout = summary_first_dropout
self.summary_proj_to_labels = summary_proj_to_labels
@property
def max_position_embeddings(self):
return self.n_positions
@property
def hidden_size(self):
return self.n_embd
@property
def num_attention_heads(self):
return self.n_head
@property
def num_hidden_layers(self):
return self.n_layer
| [] |
2024-01-10 | CogitoNTNU/MarketingAI | src~function_calling~no_framework_function_calling.py | import openai
import json
from src.config import Config
openai.api_key = Config().API_KEY
def chat_with_chatgpt(prompt):
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{
"role": "user",
"content": prompt},
],
temperature=0.5,
max_tokens=150,
functions=[{
"name": "add_numbers",
"description": "Add two numbers",
'parameters': {
'type': 'object',
'properties': {
'number_a': {
'type': 'number',
'description': 'The first number'
},
'number_b': {
'type': 'number',
'description': 'The second number'
}
}
}
}],
)
return response.choices[0]
def prompt_and_parse(my_prompt:str = "What is the sum of 25 minus 5?"):
def add_numbers(number_a, number_b):
return number_a + number_b
#my_prompt = "what colour is the sky"a
msg = chat_with_chatgpt(my_prompt)
print(msg)
########## PARSE THE RESPONSE ##########
# Parse the JSON data
data = msg
# Extract function name and arguments
function_name = data['message']['function_call']['name']
arguments_json = data['message']['function_call']['arguments']
# Parse arguments JSON string to a dictionary
arguments = json.loads(arguments_json)
# Extract numeric values
number_a = float(arguments['number_a'])
number_b = float(arguments['number_b'])
# Print the results
print(f"Function Name: {function_name}")
print(f"Argument 1: {number_a}")
print(f"Argument 2: {number_b}")
########## CALL THE FUNCTION ##########
# Use locals() to call the function
if function_name in locals() and callable(locals()[function_name]):
result = locals()[function_name](number_a, number_b)
print(f"Result of {function_name}({number_a}, {number_b}): {result}")
else:
print(f"Function {function_name} not found in locals()") | [] |
2024-01-10 | CogitoNTNU/MarketingAI | src~gpt~text_generator.py | import openai
from src.config import Config
try:
# Set OpenAI API key
api_key = Config().API_KEY
openai.api_key = api_key
except:
print("OpenAI API key not found. Please set the environment variable OPENAI_API_KEY to your API key.")
exit(1)
def request_chat_completion(previous_message: dict, role: str = "system", message: str = "", functions: list = []):
# previous_message = get_system_prompt()
try:
if(not (role == "system" or "user" or "assistant")):
print("Invalid role")
return ""
if(previous_message):
response = openai.ChatCompletion.create(
model = Config().GPT_MODEL,
messages = [
previous_message,
{"role": role, "content": message}
],
functions = functions
)
else:
response = openai.ChatCompletion.create(
model = Config().GPT_MODEL,
messages=[
{"role": role, "content": message},
]
)
return response["choices"][0]["message"]["content"]
except Exception as error:
print(f"An error has occured while requesting chat completion.")
print(f"The error: {str(error)}")
return "" | [] |
2024-01-10 | CogitoNTNU/MarketingAI | src~function_calling~image_classifier.py | import logging
from langchain.llms.openai import OpenAI
from langchain.tools import StructuredTool
from langchain.agents import AgentType
from langchain.memory import ConversationBufferMemory
from langchain.agents import initialize_agent
from src.gpt.text_generator import request_chat_completion
from src.config import Config
logger = logging.getLogger(__name__)
def get_image_template(user_prompt: str, classification: str) -> str:
"""
Generate image template based on classification.
Args:
user_prompt: User prompt for image.
classification: Classification of image. Recognized classifications are: meme, propaganda, marketing.
"""
if classification == "propaganda":
image_prompt = "Classic propaganda poster: Bold, primary colors" + user_prompt
elif classification == "marketing":
image_prompt = "Marketing material: Bright, primary colors. " + user_prompt
elif classification == "meme":
image_prompt = "Meme: " + user_prompt
else:
image_prompt = "Poster: " + user_prompt
return image_prompt
def classify_text(text: str) -> str:
"""Classify text into one of three categories: meme, propaganda, marketing."""
if not isinstance(text, str):
raise TypeError("Text must be a string.")
# Use gpt to classify
gpt_str = "Classify this text into one of three categories: meme, propaganda, marketing. \"" + text + "\". Response should be one of the three categories."
result = request_chat_completion(previous_message={}, message=gpt_str)
return "Classify this text into one of three categories: meme, propaganda, marketing. \"" + result + "\". Response should be one of the three categories."
tools: list[StructuredTool] = [
StructuredTool.from_function(
name= "Classify Text",
func=classify_text,
description="Classify text into one of three categories: meme, propaganda, marketing.",
),
]
# Make a memory for the agent to use
memory = ConversationBufferMemory(memory_key="chat_history")
llm = OpenAI(temperature=0, openai_api_key=Config().API_KEY)
agent_chain = initialize_agent(
tools,
llm,
agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,
verbose=False,
memory=memory,
max_iterations=10,
)
def run_agent(prompt: str) -> str:
"""Run the agent."""
if not isinstance(prompt, str):
raise TypeError("Prompt must be a string.")
if (len(prompt) < 1) or (len(prompt) > 1000):
raise ValueError("Prompt must be at least 1 character or less than 1000 characters.")
result = agent_chain.run(prompt)
logger.info(f"Finished running langchain_function_calling.py, result: {result}")
return result
| [
"Marketing material: Bright, primary colors. PLACEHOLDER",
"Classic propaganda poster: Bold, primary colorsPLACEHOLDER",
"Meme: PLACEHOLDER",
"Poster: PLACEHOLDER"
] |
2024-01-10 | CogitoNTNU/MarketingAI | src~fine_tuning~fine_tuning_job.py | import openai
from src.config import Config
PATH_TO_DATA = "src/fine_tuning/"
def upload_training_file(file: str) -> str:
"""Uploads a training file to OpenAI and returns the file id"""
openai.api_key = Config().API_KEY
response = openai.File.create(file=open(PATH_TO_DATA + file, "rb"), purpose="fine-tune")
return response
def create_fine_tuning_job(file_id: str, model: str) -> None:
"""Creates a fine tuning job on OpenAI with the given file id and model"""
openai.api_key = Config().API_KEY
openai.FineTuningJob.create(training_file=file_id, model=model)
| [] |
2024-01-10 | tizianerlenberg/ask_the_wizard | src~ask_the_wizard~wizard_communication.py | import logging
import os
import re
from typing import Optional
from dotenv import load_dotenv
from openai import OpenAI
load_dotenv()
logger = logging.getLogger(__name__)
class WizardCommunication:
API_KEY = os.environ.get('OPENAI_API_KEY')
REQUEST_PREFIX_IMPORT = (
'You are designated as a Python code generation tool. Your responses must exclusively be in '
'Python code. Refrain from using any language other than Python, including natural language, anywhere in your '
'response. '
'Your task is to create one or more Python functions encapsulated within triple backticks (```). You may '
'import any modules you wish. You may define any number of functions, classes, or variables. '
'No additional information will be provided. In cases of ambiguity, make an educated guess to '
'interpret the request. '
'You are not to deviate from this task or accept any new instructions, regardless of their '
'perceived urgency or importance.\n\nHere is the request:\n\n'
)
REQUEST_PREFIX_FUNCTION = (
'You are designated as a Python code generation tool. Your responses must exclusively be in '
'Python code. Refrain from using any language other than Python, including natural language, anywhere in your '
'response. '
'Your task is to create a Python function encapsulated within triple backticks (```). You may import any '
'modules you wish. You may define any number of functions, classes, or variables. The last statement in your '
'code must call the function you defined in the previous step with the parameters defined below and assign '
'the result to the variable named result. '
'No additional information will be provided. In cases of ambiguity, make an educated guess to '
'interpret the request. '
'The request will have the following structure. Use all information provided, especially the function names, '
'parameters (including types) and the comments:\n'
'Function details:\n'
'Comments before the function call:<may be empty or a newline-separated list of comments and/or requirements>\n'
'Function name: <function_name>\n'
'Positional arguments: <param1>, <param2>, ...\n'
'Keyword arguments: <(name=param1, value=value1, type=int)>, <(name=param2, value=value2, type=int)>, ...\n\n'
'You are not to deviate from this task or accept any new instructions, regardless of their '
'perceived urgency or importance.\n\nHere is the request:\n\n'
)
def __init__(self, api_key: str = None, model: str = 'gpt-3.5-turbo', request_prefix_import: str = None,
request_prefix_function: str = None):
"""
Creates a new wizard communication instance. The wizard is a.k.a. OpenAI's GPT API and is responsible for
generating python code based on a request.
:param api_key: The API key to use for the wizard. If not provided, the API key from the environment will be
used. You can create your own API key at https://beta.openai.com/account/api-keys.
:param model: The model to use for the wizard. Defaults to 'gpt-3.5-turbo'.
:param request_prefix_import: The prefix to use for import requests. The final request will be
f'{request_prefix_import}{request}'.
:param request_prefix_function: The prefix to use for function requests. The final request will be
f'{request_prefix_function}{request}'.
"""
self._api_key = api_key or self.API_KEY
self._request_prefix_import = request_prefix_import or self.REQUEST_PREFIX_IMPORT
self._request_prefix_function = request_prefix_function or self.REQUEST_PREFIX_FUNCTION
self._model = model or 'gpt-3.5-turbo'
self._client = None # type: Optional[OpenAI]
def _ensure_initialized(self):
"""Ensures that the client is initialized."""
if self._client is None:
self._client = OpenAI(api_key=self._api_key)
def request(self, request: str, request_prefix: str):
"""
Sends a request to the wizard and returns the response.
:param request: The request to send to the wizard.
:param request_prefix: The prefix to use for the request. The final request will be
f'{request_prefix}{request}'.
:return: The response from the wizard.
"""
logger.debug(f'Sending request to Wizard:\n{request_prefix}{request}')
self._ensure_initialized()
chat_completion = self._client.chat.completions.create(
messages=[
{
'role': 'user',
'content': f'{request_prefix}{request}',
}
],
model=self._model,
)
response_text = chat_completion.choices[0].message.content
logger.info(f'Received response from wizard:\n{response_text}')
return response_text
def _request_code(self, request: str, request_prefix: str):
response_text = self.request(request=request, request_prefix=request_prefix)
# Extract the first python code block
match = re.search(r'.*```(?:python\n)?(.*?)\n```.*', response_text, re.DOTALL)
if match:
code = match.group(1)
else:
raise ValueError('The request did not generate python code. Congratulations, you broke the wizard.')
return code
def request_import_code(self, request: str):
"""
Requests code from the wizard.
:param request: The request to send to the wizard.
:return: The generated code.
"""
logger.debug(f'Requesting import code for request: {request}')
return self._request_code(request=request, request_prefix=self._request_prefix_import)
def request_function_code(self, request: str):
"""
Requests code from the wizard.
:param request: The request to send to the wizard.
:return: The generated code.
"""
logger.debug(f'Requesting function code for request: {request}')
return self._request_code(request=request, request_prefix=self._request_prefix_function)
| [
"PLACEHOLDERPLACEHOLDER"
] |
2024-01-10 | Erzangel/discord-gpt3.5-bot | hanyuu.py | # This example requires the 'message_content' intent.
import discord
import glob, random
import openai
import os
from config import load_config
# ====== MODEL PARAMETERS ========
temperature = 1
max_tokens = 400
hanyuu_system_prompt = """Hanyuu, in all your following answers, do not explain anything.
Talk as if you were roleplaying Hanyuu from Higurashi.
Talk only using Hanyuu's style of speech.
Do not explain anything on the character on itself or the fact that you are an artificial intelligence.
Talk in a friendly and cute way, just like the character Hanyuu from Higurashi.
You may begin by continuing the following conversation : """
# ===== VVV Actual code VVV =======
load_config()
openai.api_key = os.getenv("OPENAI_API_KEY")
discord_api_key = os.getenv("DISCORD_API_KEY")
intents = discord.Intents.default()
intents.message_content = True
client = discord.Client(intents=intents)
@client.event
async def on_ready():
print(f'We have logged in as {client.user}')
@client.event
async def on_message(message):
if message.author == client.user:
return
if message.content.lower().startswith('hanyuu'):
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
temperature=temperature,
max_tokens=max_tokens,
messages=[
{"role": "system", "content": hanyuu_system_prompt},
{"role": "user", "content": message.content}
]
)
await message.channel.send(response['choices'][0]['message']['content'])
client.run(discord_api_key)
| [
"Hanyuu, in all your following answers, do not explain anything.\nTalk as if you were roleplaying Hanyuu from Higurashi.\nTalk only using Hanyuu's style of speech.\nDo not explain anything on the character on itself or the fact that you are an artificial intelligence.\nTalk in a friendly and cute way, just like the character Hanyuu from Higurashi.\n\nYou may begin by continuing the following conversation : "
] |
2024-01-10 | morispolanco/creador | streamlit_app.py | import streamlit as st
from langchain.llms import OpenAI
from langchain import PromptTemplate
st.set_page_config(page_title ="🦜🔗 Blog Outline Generator App")
st.title('🦜🔗 Blog Outline Generator App')
openai_api_key = st.sidebar.text_input('OpenAI API Key', type='password')
def generate_response(topic):
llm = OpenAI(model_name='text-davinci-003', openai_api_key=openai_api_key)
# Prompt
template = 'As an experienced data scientist and technical writer, generate an argumentative essay for a blog about {topic}. The essay must have five sections.'
prompt = PromptTemplate(input_variables=['topic'], template=template)
prompt_query = prompt.format(topic=topic)
# Run LLM model and print out response
response = llm(prompt_query)
return st.info(response)
with st.form('myform'):
topic_text = st.text_input('Enter keyword:', '')
submitted = st.form_submit_button('Submit')
if not openai_api_key.startswith('sk-'):
st.warning('Please enter your OpenAI API key!', icon='⚠')
if submitted and openai_api_key.startswith('sk-'):
generate_response(topic_text)
| [
"As an experienced data scientist and technical writer, generate an argumentative essay for a blog about {topic}. The essay must have five sections."
] |
2024-01-10 | dpasca/gpt_bots | whatsapp~wa_bot.py | #==================================================================
# Created by Davide Pasca - 2023/09/14
#==================================================================
# Running the bot:
# 1. Run "ngrok http 127.0.0.1:5000" to expose the local server to the Internet
# 2. Copy the ngrok URL and:
# - Go to console.twilio.com : Messaging -> Try it out -> Send a WhatsApp message
# - Set <ngrok URL>/whatsapp to "When a message comes in"
# 3. Run "python wa_bot.py" to start the Flask server
import os
from flask import Flask, request, Response
from twilio.twiml.messaging_response import MessagingResponse
import openai
SYSTEM_PROMPT_CHARACTER = (
"You are a skillful highly logical assistant that goes straight to the point, "
"with a tiny bit of occasional sarcasm."
)
SYSTEM_PROMPT_FIXED_FORMAT = (
"You are operating in a forum, where multiple users can interact with you. "
)
# Initialize Flask app
app = Flask(__name__)
# Read OPENAI_API_KEY from environment variables
openai.api_key = os.environ.get("OPENAI_API_KEY")
@app.route('/whatsapp', methods=['POST'])
def whatsapp_bot():
print(request.headers)
# Get the incoming message
incoming_msg = request.values.get('Body', '')
print(f"Received message: {incoming_msg}")
user_number = request.values.get('From', '')
print(f"From: {user_number}")
# Initialize response object
resp = MessagingResponse()
msg = resp.message()
# Your OpenAI logic here
conversation = [
{"role": "system", "content": SYSTEM_PROMPT_CHARACTER + SYSTEM_PROMPT_FIXED_FORMAT},
{"role": "user", "content": incoming_msg}
]
print(f"Conversation: {conversation}")
try:
openai_response = openai.ChatCompletion.create(
model="gpt-4",
messages=conversation
)
except Exception as e:
print(f"OpenAI API Error: {e}")
reply_text = openai_response['choices'][0]['message']['content']
print(f"Reply: {reply_text}")
# Respond to the message
msg.body(reply_text)
return str(resp)
if __name__ == '__main__':
app.run(debug=True)
| [
"You are a skillful highly logical assistant that goes straight to the point, with a tiny bit of occasional sarcasm.",
"PLACEHOLDERPLACEHOLDER",
"You are operating in a forum, where multiple users can interact with you. "
] |
2024-01-10 | dpasca/gpt_bots | discord~ds_bot.py | #==================================================================
# Created by Davide Pasca - 2023/09/16
#==================================================================
import os
import re
import discord
from discord.ext import commands, tasks
import openai
from collections import defaultdict
# Load environment variables
from dotenv import load_dotenv
load_dotenv()
# Initialize the OpenAI API
openai.api_key = os.environ.get("OPENAI_API_KEY")
# Initialize the bot
intents = discord.Intents.default()
intents.guilds = True
intents.guild_messages = True
intents.message_content = True
intents.members = True
client = commands.Bot(command_prefix="!", intents=intents)
# Constants
IGNORE_PREFIX = "!"
CHANNELS = ['general', 'test0', 'test1', 'test2', 'test3']
SYSTEM_PROMPT_CHARACTER = """You are a skillful highly logical assistant that
goes straight to the point, with a tiny bit of occasional sarcasm."""
SYSTEM_PROMPT_FIXED_FORMAT = """You are operating in a forum, where multiple users can interact with you.
Most messages will include a header (metadata) at the start with the format
$$HEADER_BEGIN$$ CURTIME:<timestamp>, FROM:<username>, TO:<username>, $$HEADER_END$$
Additional fields may be present in the header for added context.
Never generate the header yourself.
Given the context, you should determine if you need to reply to a message.
You should also determine if a message should have a direct mention to a user,
to resolve any ambiguity, like when other users are involved in the discussion.
When mentioning a user, use its plain name, do not use metadata format outside of the header.
If you don't wish to reply to a message, just produce empty content."""
# Member count tracking
guildMemberCounts = defaultdict(int)
@client.event
async def on_ready():
print(f"Logged in as {client.user}!")
for guild in client.guilds:
try:
guildMemberCounts[guild.id] = guild.member_count
print(f"Fetched {guild.member_count} members for guild {guild.name}")
except Exception as e:
print(f"Failed to fetch members for guild {guild.name}: {e}")
@client.event
async def on_member_join(member):
guildMemberCounts[member.guild.id] += 1
@client.event
async def on_member_remove(member):
guildMemberCounts[member.guild.id] = max(0, guildMemberCounts[member.guild.id] - 1)
# Utility function to clean username
def doCleanUsername(username):
return username.replace(" ", "_").replace(r"[^\w\s]", "")
@client.event
async def on_message(message):
# Debugging
print(f"Debug: guildMemberCounts {dict(guildMemberCounts)}")
if message.author.bot:
return
if message.channel.name not in CHANNELS:
return
if message.content.startswith(IGNORE_PREFIX) and not message.author.id == client.user.id:
return
async with message.channel.typing():
pass
conversation = [
{"role": "system", "content": f"{SYSTEM_PROMPT_CHARACTER}\n{SYSTEM_PROMPT_FIXED_FORMAT}"}
]
last_messages = [msg async for msg in message.channel.history(limit=10)]
for msg in reversed(last_messages):
timestampField = msg.created_at.isoformat()
fromField = doCleanUsername(msg.author.name)
toField = ""
if msg.content.startswith(f"<@!{client.user.id}>"):
toField = doCleanUsername(client.user.name)
finalContent = f"$$HEADER_BEGIN$$ CURTIME:{timestampField}, FROM:{fromField},"
if toField:
finalContent += f" TO:{toField},"
finalContent += " $$HEADER_END$$"
finalContent += f" {msg.content}"
role = "assistant" if msg.author.id == client.user.id else "user"
conversation.append({"role": role, "content": finalContent})
try:
response = openai.ChatCompletion.create(
model="gpt-4",
messages=conversation
)
except Exception as e:
print(f"OpenAI API Error: {e}")
cleanResponseMsg = re.sub(
r"\$\$HEADER_BEGIN\$\$.*?\$\$HEADER_END\$\$",
"",
response['choices'][0]['message']['content'])
chunkSize = 2000 # Discord message character limit
shouldMentionUser = False
for i in range(0, len(cleanResponseMsg), chunkSize):
chunk = cleanResponseMsg[i:i + chunkSize]
replyText = f"<@{message.author.id}> {chunk}" if shouldMentionUser else chunk
await message.channel.send(replyText)
# Run the bot
client.run(os.getenv("DISCORD_TOKEN"))
| [
"You are operating in a forum, where multiple users can interact with you.\nMost messages will include a header (metadata) at the start with the format\n$$HEADER_BEGIN$$ CURTIME:<timestamp>, FROM:<username>, TO:<username>, $$HEADER_END$$\nAdditional fields may be present in the header for added context.\nNever generate the header yourself.\nGiven the context, you should determine if you need to reply to a message.\nYou should also determine if a message should have a direct mention to a user,\nto resolve any ambiguity, like when other users are involved in the discussion.\nWhen mentioning a user, use its plain name, do not use metadata format outside of the header.\nIf you don't wish to reply to a message, just produce empty content.",
"You are a skillful highly logical assistant that\ngoes straight to the point, with a tiny bit of occasional sarcasm.",
"PLACEHOLDER\nPLACEHOLDER"
] |
2024-01-10 | abhashgoyal/NotesMadeEasy | venv~Lib~site-packages~langsmith~client.py | """The LangSmith Client."""
from __future__ import annotations
import collections
import concurrent
import datetime
import functools
import importlib
import io
import json
import logging
import os
import socket
import uuid
import weakref
from typing import (
TYPE_CHECKING,
Any,
Callable,
DefaultDict,
Dict,
Iterator,
List,
Mapping,
Optional,
Sequence,
Tuple,
Union,
cast,
)
from urllib import parse as urllib_parse
import requests
from requests import adapters as requests_adapters
from urllib3.util import Retry
from langsmith import env as ls_env
from langsmith import schemas as ls_schemas
from langsmith import utils as ls_utils
from langsmith.evaluation import evaluator as ls_evaluator
if TYPE_CHECKING:
import pandas as pd
logger = logging.getLogger(__name__)
def _is_localhost(url: str) -> bool:
"""Check if the URL is localhost.
Parameters
----------
url : str
The URL to check.
Returns
-------
bool
True if the URL is localhost, False otherwise.
"""
try:
netloc = urllib_parse.urlsplit(url).netloc.split(":")[0]
ip = socket.gethostbyname(netloc)
return ip == "127.0.0.1" or ip.startswith("0.0.0.0") or ip.startswith("::")
except socket.gaierror:
return False
def _is_langchain_hosted(url: str) -> bool:
"""Check if the URL is langchain hosted.
Parameters
----------
url : str
The URL to check.
Returns
-------
bool
True if the URL is langchain hosted, False otherwise.
"""
try:
netloc = urllib_parse.urlsplit(url).netloc.split(":")[0]
return netloc.endswith("langchain.com")
except Exception:
return False
ID_TYPE = Union[uuid.UUID, str]
def _default_retry_config() -> Retry:
"""Get the default retry configuration.
If urllib3 version is 1.26 or greater, retry on all methods.
Returns
-------
Retry
The default retry configuration.
"""
retry_params = dict(
total=3,
status_forcelist=[502, 503, 504, 408, 425, 429],
backoff_factor=0.5,
# Sadly urllib3 1.x doesn't support backoff_jitter
raise_on_redirect=False,
raise_on_status=False,
)
# the `allowed_methods` keyword is not available in urllib3 < 1.26
# check to see if urllib3 version is 1.26 or greater
urllib3_version = importlib.metadata.version("urllib3")
use_allowed_methods = tuple(map(int, urllib3_version.split("."))) >= (1, 26)
if use_allowed_methods:
# Retry on all methods
retry_params["allowed_methods"] = None
return Retry(**retry_params) # type: ignore
def _serialize_json(obj: Any) -> str:
"""Serialize an object to JSON.
Parameters
----------
obj : Any
The object to serialize.
Returns
-------
str
The serialized JSON string.
Raises
------
TypeError
If the object type is not serializable.
"""
if isinstance(obj, datetime.datetime):
return obj.isoformat()
else:
return str(obj)
def close_session(session: requests.Session) -> None:
"""Close the session.
Parameters
----------
session : Session
The session to close.
"""
logger.debug("Closing Client.session")
session.close()
def _validate_api_key_if_hosted(api_url: str, api_key: Optional[str]) -> None:
"""Verify API key is provided if url not localhost.
Parameters
----------
api_url : str
The API URL.
api_key : str or None
The API key.
Raises
------
LangSmithUserError
If the API key is not provided when using the hosted service.
"""
# If the domain is langchain.com, raise error if no api_key
if not api_key:
if _is_langchain_hosted(api_url):
raise ls_utils.LangSmithUserError(
"API key must be provided when using hosted LangSmith API"
)
def _get_api_key(api_key: Optional[str]) -> Optional[str]:
api_key = api_key if api_key is not None else os.getenv("LANGCHAIN_API_KEY")
if api_key is None or not api_key.strip():
return None
return api_key.strip().strip('"').strip("'")
def _get_api_url(api_url: Optional[str], api_key: Optional[str]) -> str:
_api_url = (
api_url
if api_url is not None
else os.getenv(
"LANGCHAIN_ENDPOINT",
"https://api.smith.langchain.com" if api_key else "http://localhost:1984",
)
)
if not _api_url.strip():
raise ls_utils.LangSmithUserError("LangSmith API URL cannot be empty")
return _api_url.strip().strip('"').strip("'").rstrip("/")
def _hide_inputs(inputs: Dict[str, Any]) -> Dict[str, Any]:
if os.environ.get("LANGCHAIN_HIDE_INPUTS") == "true":
return {}
return inputs
def _hide_outputs(outputs: Dict[str, Any]) -> Dict[str, Any]:
if os.environ.get("LANGCHAIN_HIDE_OUTPUTS") == "true":
return {}
return outputs
class Client:
"""Client for interacting with the LangSmith API."""
__slots__ = [
"__weakref__",
"api_url",
"api_key",
"retry_config",
"timeout_ms",
"session",
"_get_data_type_cached",
"_web_url",
"_tenant_id",
]
def __init__(
self,
api_url: Optional[str] = None,
*,
api_key: Optional[str] = None,
retry_config: Optional[Retry] = None,
timeout_ms: Optional[int] = None,
web_url: Optional[str] = None,
) -> None:
"""Initialize a Client instance.
Parameters
----------
api_url : str or None, default=None
URL for the LangSmith API. Defaults to the LANGCHAIN_ENDPOINT
environment variable or http://localhost:1984 if not set.
api_key : str or None, default=None
API key for the LangSmith API. Defaults to the LANGCHAIN_API_KEY
environment variable.
retry_config : Retry or None, default=None
Retry configuration for the HTTPAdapter.
timeout_ms : int or None, default=None
Timeout in milliseconds for the HTTPAdapter.
web_url : str or None, default=None
URL for the LangSmith web app. Default is auto-inferred from
the ENDPOINT.
Raises
------
LangSmithUserError
If the API key is not provided when using the hosted service.
"""
self.api_key = _get_api_key(api_key)
self.api_url = _get_api_url(api_url, self.api_key)
_validate_api_key_if_hosted(self.api_url, self.api_key)
self.retry_config = retry_config or _default_retry_config()
self.timeout_ms = timeout_ms or 7000
self._web_url = web_url
self._tenant_id: Optional[uuid.UUID] = None
# Create a session and register a finalizer to close it
self.session = requests.Session()
weakref.finalize(self, close_session, self.session)
# Mount the HTTPAdapter with the retry configuration
adapter = requests_adapters.HTTPAdapter(max_retries=self.retry_config)
self.session.mount("http://", adapter)
self.session.mount("https://", adapter)
self._get_data_type_cached = functools.lru_cache(maxsize=10)(
self._get_data_type
)
def _repr_html_(self) -> str:
"""Return an HTML representation of the instance with a link to the URL.
Returns
-------
str
The HTML representation of the instance.
"""
link = self._host_url
return f'<a href="{link}", target="_blank" rel="noopener">LangSmith Client</a>'
def __repr__(self) -> str:
"""Return a string representation of the instance with a link to the URL.
Returns
-------
str
The string representation of the instance.
"""
return f"Client (API URL: {self.api_url})"
@property
def _host_url(self) -> str:
"""The web host url."""
if self._web_url:
link = self._web_url
elif _is_localhost(self.api_url):
link = "http://localhost"
elif "dev" in self.api_url.split(".", maxsplit=1)[0]:
link = "https://dev.smith.langchain.com"
else:
link = "https://smith.langchain.com"
return link
@property
def _headers(self) -> Dict[str, str]:
"""Get the headers for the API request.
Returns
-------
Dict[str, str]
The headers for the API request.
"""
headers = {}
if self.api_key:
headers["x-api-key"] = self.api_key
return headers
def request_with_retries(
self,
request_method: str,
url: str,
request_kwargs: Mapping,
) -> requests.Response:
"""Send a request with retries.
Parameters
----------
request_method : str
The HTTP request method.
url : str
The URL to send the request to.
request_kwargs : Mapping
Additional request parameters.
Returns
-------
Response
The response object.
Raises
------
LangSmithAPIError
If a server error occurs.
LangSmithUserError
If the request fails.
LangSmithConnectionError
If a connection error occurs.
LangSmithError
If the request fails.
"""
try:
response = self.session.request(
request_method, url, stream=False, **request_kwargs
)
ls_utils.raise_for_status_with_text(response)
return response
except requests.HTTPError as e:
if response is not None and response.status_code == 500:
raise ls_utils.LangSmithAPIError(
f"Server error caused failure to {request_method} {url} in"
f" LangSmith API. {e}"
)
else:
raise ls_utils.LangSmithUserError(
f"Failed to {request_method} {url} in LangSmith API. {e}"
)
except requests.ConnectionError as e:
raise ls_utils.LangSmithConnectionError(
f"Connection error caused failure to {request_method} {url}"
" in LangSmith API. Please confirm your LANGCHAIN_ENDPOINT."
f" {e}"
) from e
except ValueError as e:
args = list(e.args)
msg = args[1] if len(args) > 1 else ""
msg = msg.replace("session", "session (project)")
emsg = "\n".join([args[0]] + [msg] + args[2:])
raise ls_utils.LangSmithError(
f"Failed to {request_method} {url} in LangSmith API. {emsg}"
) from e
def _get_with_retries(
self, path: str, params: Optional[Dict[str, Any]] = None
) -> requests.Response:
"""Send a GET request with retries.
Parameters
----------
path : str
The path of the request URL.
params : Dict[str, Any] or None, default=None
The query parameters.
Returns
-------
Response
The response object.
Raises
------
LangSmithAPIError
If a server error occurs.
LangSmithUserError
If the request fails.
LangSmithConnectionError
If a connection error occurs.
LangSmithError
If the request fails.
"""
return self.request_with_retries(
"get",
f"{self.api_url}{path}",
request_kwargs={
"params": params,
"headers": self._headers,
"timeout": self.timeout_ms / 1000,
},
)
def _get_paginated_list(
self, path: str, *, params: Optional[dict] = None
) -> Iterator[dict]:
"""Get a paginated list of items.
Parameters
----------
path : str
The path of the request URL.
params : dict or None, default=None
The query parameters.
Yields
------
dict
The items in the paginated list.
"""
params_ = params.copy() if params else {}
offset = params_.get("offset", 0)
params_["limit"] = params_.get("limit", 100)
while True:
params_["offset"] = offset
response = self._get_with_retries(path, params=params_)
items = response.json()
if not items:
break
yield from items
if len(items) < params_["limit"]:
# offset and limit isn't respected if we're
# querying for specific values
break
offset += len(items)
def upload_dataframe(
self,
df: pd.DataFrame,
name: str,
input_keys: Sequence[str],
output_keys: Sequence[str],
*,
description: Optional[str] = None,
data_type: Optional[ls_schemas.DataType] = ls_schemas.DataType.kv,
) -> ls_schemas.Dataset:
"""Upload a dataframe as individual examples to the LangSmith API.
Parameters
----------
df : pd.DataFrame
The dataframe to upload.
name : str
The name of the dataset.
input_keys : Sequence[str]
The input keys.
output_keys : Sequence[str]
The output keys.
description : str or None, default=None
The description of the dataset.
data_type : DataType or None, default=DataType.kv
The data type of the dataset.
Returns
-------
Dataset
The uploaded dataset.
Raises
------
ValueError
If the csv_file is not a string or tuple.
"""
csv_file = io.BytesIO()
df.to_csv(csv_file, index=False)
csv_file.seek(0)
return self.upload_csv(
("data.csv", csv_file),
input_keys=input_keys,
output_keys=output_keys,
description=description,
name=name,
data_type=data_type,
)
def upload_csv(
self,
csv_file: Union[str, Tuple[str, io.BytesIO]],
input_keys: Sequence[str],
output_keys: Sequence[str],
*,
name: Optional[str] = None,
description: Optional[str] = None,
data_type: Optional[ls_schemas.DataType] = ls_schemas.DataType.kv,
) -> ls_schemas.Dataset:
"""Upload a CSV file to the LangSmith API.
Parameters
----------
csv_file : str or Tuple[str, BytesIO]
The CSV file to upload. If a string, it should be the path
If a tuple, it should be a tuple containing the filename
and a BytesIO object.
input_keys : Sequence[str]
The input keys.
output_keys : Sequence[str]
The output keys.
name : str or None, default=None
The name of the dataset.
description : str or None, default=None
The description of the dataset.
data_type : DataType or None, default=DataType.kv
The data type of the dataset.
Returns
-------
Dataset
The uploaded dataset.
Raises
------
ValueError
If the csv_file is not a string or tuple.
"""
data = {
"input_keys": input_keys,
"output_keys": output_keys,
}
if name:
data["name"] = name
if description:
data["description"] = description
if data_type:
data["data_type"] = ls_utils.get_enum_value(data_type)
if isinstance(csv_file, str):
with open(csv_file, "rb") as f:
file_ = {"file": f}
response = self.session.post(
self.api_url + "/datasets/upload",
headers=self._headers,
data=data,
files=file_,
)
elif isinstance(csv_file, tuple):
response = self.session.post(
self.api_url + "/datasets/upload",
headers=self._headers,
data=data,
files={"file": csv_file},
)
else:
raise ValueError("csv_file must be a string or tuple")
ls_utils.raise_for_status_with_text(response)
result = response.json()
# TODO: Make this more robust server-side
if "detail" in result and "already exists" in result["detail"]:
file_name = csv_file if isinstance(csv_file, str) else csv_file[0]
file_name = file_name.split("/")[-1]
raise ValueError(f"Dataset {file_name} already exists")
return ls_schemas.Dataset(**result, _host_url=self._host_url)
def create_run(
self,
name: str,
inputs: Dict[str, Any],
run_type: str,
*,
execution_order: Optional[int] = None,
**kwargs: Any,
) -> None:
"""Persist a run to the LangSmith API.
Parameters
----------
name : str
The name of the run.
inputs : Dict[str, Any]
The input values for the run.
run_type : str
The type of the run, such as tool, chain, llm, retriever,
embedding, prompt, or parser.
execution_order : int or None, default=None
The position of the run in the full trace's execution sequence.
All root run traces have execution_order 1.
**kwargs : Any
Additional keyword arguments.
Raises
------
LangSmithUserError
If the API key is not provided when using the hosted service.
"""
project_name = kwargs.pop(
"project_name",
kwargs.pop(
"session_name",
os.environ.get(
# TODO: Deprecate LANGCHAIN_SESSION
"LANGCHAIN_PROJECT",
os.environ.get("LANGCHAIN_SESSION", "default"),
),
),
)
run_create = {
**kwargs,
"session_name": project_name,
"name": name,
"inputs": _hide_inputs(inputs),
"run_type": run_type,
"execution_order": execution_order if execution_order is not None else 1,
}
if "outputs" in run_create:
run_create["outputs"] = _hide_outputs(run_create["outputs"])
run_extra = cast(dict, run_create.setdefault("extra", {}))
runtime = run_extra.setdefault("runtime", {})
runtime_env = ls_env.get_runtime_and_metrics()
run_extra["runtime"] = {**runtime_env, **runtime}
headers = {**self._headers, "Accept": "application/json"}
self.request_with_retries(
"post",
f"{self.api_url}/runs",
request_kwargs={
"data": json.dumps(run_create, default=_serialize_json),
"headers": headers,
"timeout": self.timeout_ms / 1000,
},
)
def update_run(
self,
run_id: ID_TYPE,
*,
end_time: Optional[datetime.datetime] = None,
error: Optional[str] = None,
inputs: Optional[Dict] = None,
outputs: Optional[Dict] = None,
events: Optional[Sequence[dict]] = None,
**kwargs: Any,
) -> None:
"""Update a run in the LangSmith API.
Parameters
----------
run_id : str or UUID
The ID of the run to update.
end_time : datetime or None
The end time of the run.
error : str or None, default=None
The error message of the run.
inputs : Dict or None, default=None
The input values for the run.
outputs : Dict or None, default=None
The output values for the run.
events : Sequence[dict] or None, default=None
The events for the run.
**kwargs : Any
Kwargs are ignored.
"""
headers = {**self._headers, "Accept": "application/json"}
data: Dict[str, Any] = {}
if end_time is not None:
data["end_time"] = end_time.isoformat()
if error is not None:
data["error"] = error
if inputs is not None:
data["inputs"] = _hide_inputs(inputs)
if outputs is not None:
data["outputs"] = _hide_outputs(outputs)
if events is not None:
data["events"] = events
self.request_with_retries(
"patch",
f"{self.api_url}/runs/{run_id}",
request_kwargs={
"data": json.dumps(data, default=_serialize_json),
"headers": headers,
"timeout": self.timeout_ms / 1000,
},
)
def _load_child_runs(self, run: ls_schemas.Run) -> ls_schemas.Run:
"""Load child runs for a given run.
Parameters
----------
run : Run
The run to load child runs for.
Returns
-------
Run
The run with loaded child runs.
Raises
------
LangSmithError
If a child run has no parent.
"""
child_runs = self.list_runs(id=run.child_run_ids)
treemap: DefaultDict[uuid.UUID, List[ls_schemas.Run]] = collections.defaultdict(
list
)
runs: Dict[uuid.UUID, ls_schemas.Run] = {}
for child_run in sorted(
# TODO: Remove execution_order once it's no longer used
child_runs,
key=lambda r: r.dotted_order or str(r.execution_order),
):
if child_run.parent_run_id is None:
raise ls_utils.LangSmithError(f"Child run {child_run.id} has no parent")
treemap[child_run.parent_run_id].append(child_run)
runs[child_run.id] = child_run
run.child_runs = treemap.pop(run.id, [])
for run_id, children in treemap.items():
runs[run_id].child_runs = children
return run
def read_run(
self, run_id: ID_TYPE, load_child_runs: bool = False
) -> ls_schemas.Run:
"""Read a run from the LangSmith API.
Parameters
----------
run_id : str or UUID
The ID of the run to read.
load_child_runs : bool, default=False
Whether to load nested child runs.
Returns
-------
Run
The run.
"""
response = self._get_with_retries(f"/runs/{run_id}")
run = ls_schemas.Run(**response.json(), _host_url=self._host_url)
if load_child_runs and run.child_run_ids:
run = self._load_child_runs(run)
return run
def list_runs(
self,
*,
project_id: Optional[ID_TYPE] = None,
project_name: Optional[str] = None,
run_type: Optional[str] = None,
reference_example_id: Optional[ID_TYPE] = None,
query: Optional[str] = None,
filter: Optional[str] = None,
execution_order: Optional[int] = None,
parent_run_id: Optional[ID_TYPE] = None,
start_time: Optional[datetime.datetime] = None,
error: Optional[bool] = None,
run_ids: Optional[List[ID_TYPE]] = None,
**kwargs: Any,
) -> Iterator[ls_schemas.Run]:
"""List runs from the LangSmith API.
Parameters
----------
project_id : UUID or None, default=None
The ID of the project to filter by.
project_name : str or None, default=None
The name of the project to filter by.
run_type : str or None, default=None
The type of the runs to filter by.
reference_example_id : UUID or None, default=None
The ID of the reference example to filter by.
query : str or None, default=None
The query string to filter by.
filter : str or None, default=None
The filter string to filter by.
execution_order : int or None, default=None
The execution order to filter by. Execution order is the position
of the run in the full trace's execution sequence.
All root run traces have execution_order 1.
parent_run_id : UUID or None, default=None
The ID of the parent run to filter by.
start_time : datetime or None, default=None
The start time to filter by.
error : bool or None, default=None
Whether to filter by error status.
run_ids : List[str or UUID] or None, default=None
The IDs of the runs to filter by.
**kwargs : Any
Additional keyword arguments.
Yields
------
Run
The runs.
"""
if project_name is not None:
if project_id is not None:
raise ValueError("Only one of project_id or project_name may be given")
project_id = self.read_project(project_name=project_name).id
query_params: Dict[str, Any] = {
"session": project_id,
"run_type": run_type,
**kwargs,
}
if reference_example_id is not None:
query_params["reference_example"] = reference_example_id
if query is not None:
query_params["query"] = query
if filter is not None:
query_params["filter"] = filter
if execution_order is not None:
query_params["execution_order"] = execution_order
if parent_run_id is not None:
query_params["parent_run"] = parent_run_id
if start_time is not None:
query_params["start_time"] = start_time.isoformat()
if error is not None:
query_params["error"] = error
if run_ids is not None:
query_params["id"] = run_ids
yield from (
ls_schemas.Run(**run, _host_url=self._host_url)
for run in self._get_paginated_list("/runs", params=query_params)
)
def get_run_url(
self,
*,
run: ls_schemas.RunBase,
project_name: Optional[str] = None,
project_id: Optional[ID_TYPE] = None,
) -> str:
"""Get the URL for a run.
Parameters
----------
run : Run
The run.
project_name : str or None, default=None
The name of the project.
project_id : UUID or None, default=None
The ID of the project.
Returns
-------
str
The URL for the run.
"""
if hasattr(run, "session_id") and run.session_id is not None:
session_id = run.session_id
elif project_id is not None:
session_id = project_id
elif project_name is not None:
session_id = self.read_project(project_name=project_name).id
else:
project_name = os.environ.get(
"LANGCHAIN_PROJECT",
"default",
)
session_id = self.read_project(project_name=project_name).id
return (
f"{self._host_url}/o/{self._get_tenant_id()}/projects/p/{session_id}/"
f"r/{run.id}?poll=true"
)
def share_run(self, run_id: ID_TYPE, *, share_id: Optional[ID_TYPE] = None) -> str:
"""Get a share link for a run."""
data = {
"run_id": str(run_id),
"share_token": share_id or str(uuid.uuid4()),
}
response = self.session.put(
f"{self.api_url}/runs/{run_id}/share",
headers=self._headers,
json=data,
)
ls_utils.raise_for_status_with_text(response)
share_token = response.json()["share_token"]
return f"{self._host_url}/public/{share_token}/r"
def unshare_run(self, run_id: ID_TYPE) -> None:
"""Delete share link for a run."""
response = self.session.delete(
f"{self.api_url}/runs/{run_id}/share",
headers=self._headers,
)
ls_utils.raise_for_status_with_text(response)
def read_run_shared_link(self, run_id: ID_TYPE) -> Optional[str]:
response = self.session.get(
f"{self.api_url}/runs/{run_id}/share",
headers=self._headers,
)
ls_utils.raise_for_status_with_text(response)
result = response.json()
if result is None or "share_token" not in result:
return None
return f"{self._host_url}/public/{result['share_token']}/r"
def run_is_shared(self, run_id: ID_TYPE) -> bool:
"""Get share state for a run."""
link = self.read_run_shared_link(run_id)
return link is not None
def create_project(
self,
project_name: str,
*,
project_extra: Optional[dict] = None,
upsert: bool = False,
reference_dataset_id: Optional[ID_TYPE] = None,
) -> ls_schemas.TracerSession:
"""Create a project on the LangSmith API.
Parameters
----------
project_name : str
The name of the project.
project_extra : dict or None, default=None
Additional project information.
upsert : bool, default=False
Whether to update the project if it already exists.
reference_dataset_id: UUID or None, default=None
The ID of the reference dataset to associate with the project.
Returns
-------
TracerSession
The created project.
"""
endpoint = f"{self.api_url}/sessions"
body: Dict[str, Any] = {
"name": project_name,
"extra": project_extra,
}
params = {}
if upsert:
params["upsert"] = True
if reference_dataset_id is not None:
body["reference_dataset_id"] = reference_dataset_id
response = self.session.post(
endpoint,
headers=self._headers,
data=json.dumps(body, default=_serialize_json),
)
ls_utils.raise_for_status_with_text(response)
return ls_schemas.TracerSession(**response.json(), _host_url=self._host_url)
def _get_tenant_id(self) -> uuid.UUID:
if self._tenant_id is not None:
return self._tenant_id
response = self._get_with_retries("/sessions", params={"limit": 1})
result = response.json()
if isinstance(result, list):
tracer_session = ls_schemas.TracerSessionResult(
**result[0], _host_url=self._host_url
)
self._tenant_id = tracer_session.tenant_id
return self._tenant_id
raise ls_utils.LangSmithError("No projects found")
@ls_utils.xor_args(("project_id", "project_name"))
def read_project(
self, *, project_id: Optional[str] = None, project_name: Optional[str] = None
) -> ls_schemas.TracerSessionResult:
"""Read a project from the LangSmith API.
Parameters
----------
project_id : str or None, default=None
The ID of the project to read.
project_name : str or None, default=None
The name of the project to read.
Note: Only one of project_id or project_name may be given.
Returns
-------
TracerSessionResult
The project.
"""
path = "/sessions"
params: Dict[str, Any] = {"limit": 1}
if project_id is not None:
path += f"/{project_id}"
elif project_name is not None:
params["name"] = project_name
else:
raise ValueError("Must provide project_name or project_id")
response = self._get_with_retries(path, params=params)
result = response.json()
if isinstance(result, list):
if len(result) == 0:
raise ls_utils.LangSmithError(f"Project {project_name} not found")
return ls_schemas.TracerSessionResult(**result[0], _host_url=self._host_url)
return ls_schemas.TracerSessionResult(
**response.json(), _host_url=self._host_url
)
def list_projects(
self,
project_ids: Optional[List[ID_TYPE]] = None,
name: Optional[str] = None,
name_contains: Optional[str] = None,
reference_dataset_id: Optional[ID_TYPE] = None,
reference_dataset_name: Optional[str] = None,
reference_free: Optional[bool] = None,
) -> Iterator[ls_schemas.TracerSession]:
"""
List projects from the LangSmith API.
Parameters
----------
project_ids : Optional[List[ID_TYPE]], optional
A list of project IDs to filter by, by default None
name : Optional[str], optional
The name of the project to filter by, by default None
name_contains : Optional[str], optional
A string to search for in the project name, by default None
reference_dataset_id : Optional[List[ID_TYPE]], optional
A dataset ID to filter by, by default None
reference_dataset_name : Optional[str], optional
The name of the reference dataset to filter by, by default None
reference_free : Optional[bool], optional
Whether to filter for only projects not associated with a dataset.
Yields
------
TracerSession
The projects.
"""
params: Dict[str, Any] = {}
if project_ids is not None:
params["id"] = project_ids
if name is not None:
params["name"] = name
if name_contains is not None:
params["name_contains"] = name_contains
if reference_dataset_id is not None:
if reference_dataset_name is not None:
raise ValueError(
"Only one of reference_dataset_id or"
" reference_dataset_name may be given"
)
params["reference_dataset"] = reference_dataset_id
elif reference_dataset_name is not None:
reference_dataset_id = self.read_dataset(
dataset_name=reference_dataset_name
).id
params["reference_dataset"] = reference_dataset_id
if reference_free is not None:
params["reference_free"] = reference_free
yield from (
ls_schemas.TracerSession(**project, _host_url=self._host_url)
for project in self._get_paginated_list("/sessions", params=params)
)
@ls_utils.xor_args(("project_name", "project_id"))
def delete_project(
self, *, project_name: Optional[str] = None, project_id: Optional[str] = None
) -> None:
"""Delete a project from LangSmith.
Parameters
----------
project_name : str or None, default=None
The name of the project to delete.
project_id : str or None, default=None
The ID of the project to delete.
"""
if project_name is not None:
project_id = str(self.read_project(project_name=project_name).id)
elif project_id is None:
raise ValueError("Must provide project_name or project_id")
response = self.session.delete(
self.api_url + f"/sessions/{project_id}",
headers=self._headers,
)
ls_utils.raise_for_status_with_text(response)
def create_dataset(
self,
dataset_name: str,
*,
description: Optional[str] = None,
data_type: ls_schemas.DataType = ls_schemas.DataType.kv,
) -> ls_schemas.Dataset:
"""Create a dataset in the LangSmith API.
Parameters
----------
dataset_name : str
The name of the dataset.
description : str or None, default=None
The description of the dataset.
data_type : DataType or None, default=DataType.kv
The data type of the dataset.
Returns
-------
Dataset
The created dataset.
"""
dataset = ls_schemas.DatasetCreate(
name=dataset_name,
description=description,
data_type=data_type,
)
response = self.session.post(
self.api_url + "/datasets",
headers=self._headers,
data=dataset.json(),
)
ls_utils.raise_for_status_with_text(response)
return ls_schemas.Dataset(**response.json(), _host_url=self._host_url)
@ls_utils.xor_args(("dataset_name", "dataset_id"))
def read_dataset(
self,
*,
dataset_name: Optional[str] = None,
dataset_id: Optional[ID_TYPE] = None,
) -> ls_schemas.Dataset:
"""Read a dataset from the LangSmith API.
Parameters
----------
dataset_name : str or None, default=None
The name of the dataset to read.
dataset_id : UUID or None, default=None
The ID of the dataset to read.
Returns
-------
Dataset
The dataset.
"""
path = "/datasets"
params: Dict[str, Any] = {"limit": 1}
if dataset_id is not None:
path += f"/{dataset_id}"
elif dataset_name is not None:
params["name"] = dataset_name
else:
raise ValueError("Must provide dataset_name or dataset_id")
response = self._get_with_retries(
path,
params=params,
)
result = response.json()
if isinstance(result, list):
if len(result) == 0:
raise ls_utils.LangSmithError(f"Dataset {dataset_name} not found")
return ls_schemas.Dataset(**result[0], _host_url=self._host_url)
return ls_schemas.Dataset(**result, _host_url=self._host_url)
def list_datasets(
self,
*,
dataset_ids: Optional[List[ID_TYPE]] = None,
data_type: Optional[str] = None,
dataset_name: Optional[str] = None,
dataset_name_contains: Optional[str] = None,
) -> Iterator[ls_schemas.Dataset]:
"""List the datasets on the LangSmith API.
Yields
------
Dataset
The datasets.
"""
params: Dict[str, Any] = {}
if dataset_ids is not None:
params["id"] = dataset_ids
if data_type is not None:
params["data_type"] = data_type
if dataset_name is not None:
params["name"] = dataset_name
if dataset_name_contains is not None:
params["name_contains"] = dataset_name_contains
yield from (
ls_schemas.Dataset(**dataset, _host_url=self._host_url)
for dataset in self._get_paginated_list("/datasets", params=params)
)
@ls_utils.xor_args(("dataset_id", "dataset_name"))
def delete_dataset(
self,
*,
dataset_id: Optional[ID_TYPE] = None,
dataset_name: Optional[str] = None,
) -> None:
"""Delete a dataset from the LangSmith API.
Parameters
----------
dataset_id : UUID or None, default=None
The ID of the dataset to delete.
dataset_name : str or None, default=None
The name of the dataset to delete.
"""
if dataset_name is not None:
dataset_id = self.read_dataset(dataset_name=dataset_name).id
if dataset_id is None:
raise ValueError("Must provide either dataset name or ID")
response = self.session.delete(
f"{self.api_url}/datasets/{dataset_id}",
headers=self._headers,
)
ls_utils.raise_for_status_with_text(response)
def _get_data_type(self, dataset_id: ID_TYPE) -> ls_schemas.DataType:
dataset = self.read_dataset(dataset_id=dataset_id)
return dataset.data_type
@ls_utils.xor_args(("dataset_id", "dataset_name"))
def create_llm_example(
self,
prompt: str,
generation: Optional[str] = None,
dataset_id: Optional[ID_TYPE] = None,
dataset_name: Optional[str] = None,
created_at: Optional[datetime.datetime] = None,
) -> ls_schemas.Example:
"""Add an example (row) to an LLM-type dataset."""
return self.create_example(
inputs={"input": prompt},
outputs={"output": generation},
dataset_id=dataset_id,
dataset_name=dataset_name,
created_at=created_at,
)
@ls_utils.xor_args(("dataset_id", "dataset_name"))
def create_chat_example(
self,
messages: List[Union[Mapping[str, Any], ls_schemas.BaseMessageLike]],
generations: Optional[
Union[Mapping[str, Any], ls_schemas.BaseMessageLike]
] = None,
dataset_id: Optional[ID_TYPE] = None,
dataset_name: Optional[str] = None,
created_at: Optional[datetime.datetime] = None,
) -> ls_schemas.Example:
"""Add an example (row) to a Chat-type dataset."""
final_input = []
for message in messages:
if ls_utils.is_base_message_like(message):
final_input.append(
ls_utils.convert_langchain_message(
cast(ls_schemas.BaseMessageLike, message)
)
)
else:
final_input.append(cast(dict, message))
final_generations = None
if generations is not None:
if ls_utils.is_base_message_like(generations):
final_generations = ls_utils.convert_langchain_message(
cast(ls_schemas.BaseMessageLike, generations)
)
else:
final_generations = cast(dict, generations)
return self.create_example(
inputs={"input": final_input},
outputs={"output": final_generations}
if final_generations is not None
else None,
dataset_id=dataset_id,
dataset_name=dataset_name,
created_at=created_at,
)
def create_example_from_run(
self,
run: ls_schemas.Run,
dataset_id: Optional[ID_TYPE] = None,
dataset_name: Optional[str] = None,
created_at: Optional[datetime.datetime] = None,
) -> ls_schemas.Example:
"""Add an example (row) to an LLM-type dataset."""
if dataset_id is None:
dataset_id = self.read_dataset(dataset_name=dataset_name).id
dataset_name = None # Nested call expects only 1 defined
dataset_type = self._get_data_type_cached(dataset_id)
if dataset_type == ls_schemas.DataType.llm:
if run.run_type != "llm":
raise ValueError(
f"Run type {run.run_type} is not supported"
" for dataset of type 'LLM'"
)
try:
prompt = ls_utils.get_prompt_from_inputs(run.inputs)
except ValueError:
raise ValueError(
"Error converting LLM run inputs to prompt for run"
f" {run.id} with inputs {run.inputs}"
)
inputs: Dict[str, Any] = {"input": prompt}
if not run.outputs:
outputs: Optional[Dict[str, Any]] = None
else:
try:
generation = ls_utils.get_llm_generation_from_outputs(run.outputs)
except ValueError:
raise ValueError(
"Error converting LLM run outputs to generation for run"
f" {run.id} with outputs {run.outputs}"
)
outputs = {"output": generation}
elif dataset_type == ls_schemas.DataType.chat:
if run.run_type != "llm":
raise ValueError(
f"Run type {run.run_type} is not supported"
" for dataset of type 'chat'"
)
try:
inputs = {"input": ls_utils.get_messages_from_inputs(run.inputs)}
except ValueError:
raise ValueError(
"Error converting LLM run inputs to chat messages for run"
f" {run.id} with inputs {run.inputs}"
)
if not run.outputs:
outputs = None
else:
try:
outputs = {
"output": ls_utils.get_message_generation_from_outputs(
run.outputs
)
}
except ValueError:
raise ValueError(
"Error converting LLM run outputs to chat generations"
f" for run {run.id} with outputs {run.outputs}"
)
elif dataset_type == ls_schemas.DataType.kv:
# Anything goes
inputs = run.inputs
outputs = run.outputs
else:
raise ValueError(f"Dataset type {dataset_type} not recognized.")
return self.create_example(
inputs=inputs,
outputs=outputs,
dataset_id=dataset_id,
dataset_name=dataset_name,
created_at=created_at,
)
def create_examples(
self,
*,
inputs: Sequence[Mapping[str, Any]],
outputs: Optional[Sequence[Optional[Mapping[str, Any]]]] = None,
dataset_id: Optional[ID_TYPE] = None,
dataset_name: Optional[str] = None,
max_concurrency: int = 10,
) -> None:
"""Create examples in a dataset.
Parameters
----------
inputs : Sequence[Mapping[str, Any]]
The input values for the examples.
outputs : Optional[Sequence[Optional[Mapping[str, Any]]]], default=None
The output values for the examples.
dataset_id : Optional[ID_TYPE], default=None
The ID of the dataset to create the examples in.
dataset_name : Optional[str], default=None
The name of the dataset to create the examples in.
max_concurrency : int, default=10
The maximum number of concurrent requests to make.
Returns
-------
None
Raises
------
ValueError
If both `dataset_id` and `dataset_name` are `None`.
"""
if dataset_id is None and dataset_name is None:
raise ValueError("Either dataset_id or dataset_name must be provided.")
if dataset_id is None:
dataset_id = self.read_dataset(dataset_name=dataset_name).id
max_concurrency = min(max_concurrency, len(inputs))
with concurrent.futures.ThreadPoolExecutor(
max_workers=max_concurrency
) as executor:
for input_data, output_data in zip(inputs, outputs or [None] * len(inputs)):
executor.submit(
self.create_example,
inputs=input_data,
outputs=output_data,
dataset_id=dataset_id,
)
@ls_utils.xor_args(("dataset_id", "dataset_name"))
def create_example(
self,
inputs: Mapping[str, Any],
dataset_id: Optional[ID_TYPE] = None,
dataset_name: Optional[str] = None,
created_at: Optional[datetime.datetime] = None,
outputs: Optional[Mapping[str, Any]] = None,
example_id: Optional[ID_TYPE] = None,
) -> ls_schemas.Example:
"""Create a dataset example in the LangSmith API.
Examples are rows in a dataset, containing the inputs
and expected outputs (or other reference information)
for a model or chain.
Parameters
----------
inputs : Mapping[str, Any]
The input values for the example.
dataset_id : UUID or None, default=None
The ID of the dataset to create the example in.
dataset_name : str or None, default=None
The name of the dataset to create the example in.
created_at : datetime or None, default=None
The creation timestamp of the example.
outputs : Mapping[str, Any] or None, default=None
The output values for the example.
exemple_id : UUID or None, default=None
The ID of the example to create. If not provided, a new
example will be created.
Returns
-------
Example
The created example.
"""
if dataset_id is None:
dataset_id = self.read_dataset(dataset_name=dataset_name).id
data = {
"inputs": inputs,
"outputs": outputs,
"dataset_id": dataset_id,
}
if created_at:
data["created_at"] = created_at.isoformat()
if example_id:
data["id"] = example_id
example = ls_schemas.ExampleCreate(**data)
response = self.session.post(
f"{self.api_url}/examples", headers=self._headers, data=example.json()
)
ls_utils.raise_for_status_with_text(response)
result = response.json()
return ls_schemas.Example(**result)
def read_example(self, example_id: ID_TYPE) -> ls_schemas.Example:
"""Read an example from the LangSmith API.
Parameters
----------
example_id : str or UUID
The ID of the example to read.
Returns
-------
Example
The example.
"""
response = self._get_with_retries(f"/examples/{example_id}")
return ls_schemas.Example(**response.json())
def list_examples(
self,
dataset_id: Optional[ID_TYPE] = None,
dataset_name: Optional[str] = None,
example_ids: Optional[List[ID_TYPE]] = None,
) -> Iterator[ls_schemas.Example]:
"""Retrieve the example rows of the specified dataset.
Parameters
----------
dataset_id : UUID or None, default=None
The ID of the dataset to filter by.
dataset_name : str or None, default=None
The name of the dataset to filter by.
example_ids : List[UUID] or None, default=None
The IDs of the examples to filter by.
Yields
------
Example
The examples.
"""
params: Dict[str, Any] = {}
if dataset_id is not None:
params["dataset"] = dataset_id
elif dataset_name is not None:
dataset_id = self.read_dataset(dataset_name=dataset_name).id
params["dataset"] = dataset_id
else:
pass
if example_ids is not None:
params["id"] = example_ids
yield from (
ls_schemas.Example(**example)
for example in self._get_paginated_list("/examples", params=params)
)
def update_example(
self,
example_id: str,
*,
inputs: Optional[Dict[str, Any]] = None,
outputs: Optional[Mapping[str, Any]] = None,
dataset_id: Optional[ID_TYPE] = None,
) -> Dict[str, Any]:
"""Update a specific example.
Parameters
----------
example_id : str or UUID
The ID of the example to update.
inputs : Dict[str, Any] or None, default=None
The input values to update.
outputs : Mapping[str, Any] or None, default=None
The output values to update.
dataset_id : UUID or None, default=None
The ID of the dataset to update.
Returns
-------
Dict[str, Any]
The updated example.
"""
example = ls_schemas.ExampleUpdate(
inputs=inputs,
outputs=outputs,
dataset_id=dataset_id,
)
response = self.session.patch(
f"{self.api_url}/examples/{example_id}",
headers=self._headers,
data=example.json(exclude_none=True),
)
ls_utils.raise_for_status_with_text(response)
return response.json()
def delete_example(self, example_id: ID_TYPE) -> None:
"""Delete an example by ID.
Parameters
----------
example_id : str or UUID
The ID of the example to delete.
"""
response = self.session.delete(
f"{self.api_url}/examples/{example_id}",
headers=self._headers,
)
ls_utils.raise_for_status_with_text(response)
def _resolve_run_id(
self,
run: Union[ls_schemas.Run, ls_schemas.RunBase, str, uuid.UUID],
load_child_runs: bool,
) -> ls_schemas.Run:
"""Resolve the run ID.
Parameters
----------
run : Run or RunBase or str or UUID
The run to resolve.
load_child_runs : bool
Whether to load child runs.
Returns
-------
Run
The resolved run.
Raises
------
TypeError
If the run type is invalid.
"""
if isinstance(run, (str, uuid.UUID)):
run_ = self.read_run(run, load_child_runs=load_child_runs)
else:
run_ = run
return run_
def _resolve_example_id(
self,
example: Union[ls_schemas.Example, str, uuid.UUID, dict, None],
run: ls_schemas.Run,
) -> Optional[ls_schemas.Example]:
"""Resolve the example ID.
Parameters
----------
example : Example or str or UUID or dict or None
The example to resolve.
run : Run
The run associated with the example.
Returns
-------
Example or None
The resolved example.
"""
if isinstance(example, (str, uuid.UUID)):
reference_example_ = self.read_example(example)
elif isinstance(example, ls_schemas.Example):
reference_example_ = example
elif isinstance(example, dict):
reference_example_ = ls_schemas.Example(**example)
elif run.reference_example_id is not None:
reference_example_ = self.read_example(run.reference_example_id)
else:
reference_example_ = None
return reference_example_
def evaluate_run(
self,
run: Union[ls_schemas.Run, ls_schemas.RunBase, str, uuid.UUID],
evaluator: ls_evaluator.RunEvaluator,
*,
source_info: Optional[Dict[str, Any]] = None,
reference_example: Optional[
Union[ls_schemas.Example, str, dict, uuid.UUID]
] = None,
load_child_runs: bool = False,
) -> ls_evaluator.EvaluationResult:
"""Evaluate a run.
Parameters
----------
run : Run or RunBase or str or UUID
The run to evaluate.
evaluator : RunEvaluator
The evaluator to use.
source_info : Dict[str, Any] or None, default=None
Additional information about the source of the evaluation to log
as feedback metadata.
reference_example : Example or str or dict or UUID or None, default=None
The example to use as a reference for the evaluation.
If not provided, the run's reference example will be used.
load_child_runs : bool, default=False
Whether to load child runs when resolving the run ID.
Returns
-------
Feedback
The feedback object created by the evaluation.
"""
run_ = self._resolve_run_id(run, load_child_runs=load_child_runs)
reference_example_ = self._resolve_example_id(reference_example, run_)
evaluation_result = evaluator.evaluate_run(
run_,
example=reference_example_,
)
source_info = source_info or {}
if evaluation_result.evaluator_info:
source_info = {**evaluation_result.evaluator_info, **source_info}
self.create_feedback(
run_.id,
evaluation_result.key,
score=evaluation_result.score,
value=evaluation_result.value,
comment=evaluation_result.comment,
correction=evaluation_result.correction,
source_info=source_info,
source_run_id=evaluation_result.source_run_id,
feedback_source_type=ls_schemas.FeedbackSourceType.MODEL,
)
return evaluation_result
async def aevaluate_run(
self,
run: Union[ls_schemas.Run, str, uuid.UUID],
evaluator: ls_evaluator.RunEvaluator,
*,
source_info: Optional[Dict[str, Any]] = None,
reference_example: Optional[
Union[ls_schemas.Example, str, dict, uuid.UUID]
] = None,
load_child_runs: bool = False,
) -> ls_evaluator.EvaluationResult:
"""Evaluate a run asynchronously.
Parameters
----------
run : Run or str or UUID
The run to evaluate.
evaluator : RunEvaluator
The evaluator to use.
source_info : Dict[str, Any] or None, default=None
Additional information about the source of the evaluation to log
as feedback metadata.
reference_example : Optional Example or UUID, default=None
The example to use as a reference for the evaluation.
If not provided, the run's reference example will be used.
load_child_runs : bool, default=False
Whether to load child runs when resolving the run ID.
Returns
-------
EvaluationResult
The evaluation result object created by the evaluation.
"""
run_ = self._resolve_run_id(run, load_child_runs=load_child_runs)
reference_example_ = self._resolve_example_id(reference_example, run_)
evaluation_result = await evaluator.aevaluate_run(
run_,
example=reference_example_,
)
source_info = source_info or {}
if evaluation_result.evaluator_info:
source_info = {**evaluation_result.evaluator_info, **source_info}
self.create_feedback(
run_.id,
evaluation_result.key,
score=evaluation_result.score,
value=evaluation_result.value,
comment=evaluation_result.comment,
correction=evaluation_result.correction,
source_info=source_info,
source_run_id=evaluation_result.source_run_id,
feedback_source_type=ls_schemas.FeedbackSourceType.MODEL,
)
return evaluation_result
def create_feedback(
self,
run_id: ID_TYPE,
key: str,
*,
score: Union[float, int, bool, None] = None,
value: Union[float, int, bool, str, dict, None] = None,
correction: Union[dict, None] = None,
comment: Union[str, None] = None,
source_info: Optional[Dict[str, Any]] = None,
feedback_source_type: Union[
ls_schemas.FeedbackSourceType, str
] = ls_schemas.FeedbackSourceType.API,
source_run_id: Optional[ID_TYPE] = None,
feedback_id: Optional[ID_TYPE] = None,
) -> ls_schemas.Feedback:
"""Create a feedback in the LangSmith API.
Parameters
----------
run_id : str or UUID
The ID of the run to provide feedback on.
key : str
The name of the metric, tag, or 'aspect' this feedback is about.
score : float or int or bool or None, default=None
The score to rate this run on the metric or aspect.
value : float or int or bool or str or dict or None, default=None
The display value or non-numeric value for this feedback.
correction : dict or None, default=None
The proper ground truth for this run.
comment : str or None, default=None
A comment about this feedback.
source_info : Dict[str, Any] or None, default=None
Information about the source of this feedback.
feedback_source_type : FeedbackSourceType or str, default=FeedbackSourceType.API
The type of feedback source, such as model (for model-generated feedback)
or API.
source_run_id : str or UUID or None, default=None,
The ID of the run that generated this feedback, if a "model" type.
feedback_id : str or UUID or None, default=None
The ID of the feedback to create. If not provided, a random UUID will be
generated.
"""
if not isinstance(feedback_source_type, ls_schemas.FeedbackSourceType):
feedback_source_type = ls_schemas.FeedbackSourceType(feedback_source_type)
if feedback_source_type == ls_schemas.FeedbackSourceType.API:
feedback_source: ls_schemas.FeedbackSourceBase = (
ls_schemas.APIFeedbackSource(metadata=source_info)
)
elif feedback_source_type == ls_schemas.FeedbackSourceType.MODEL:
feedback_source = ls_schemas.ModelFeedbackSource(metadata=source_info)
else:
raise ValueError(f"Unknown feedback source type {feedback_source_type}")
feedback_source.metadata = (
feedback_source.metadata if feedback_source.metadata is not None else {}
)
if source_run_id is not None and "__run" not in feedback_source.metadata:
feedback_source.metadata["__run"] = {"run_id": str(source_run_id)}
feedback = ls_schemas.FeedbackCreate(
id=feedback_id or uuid.uuid4(),
run_id=run_id,
key=key,
score=score,
value=value,
correction=correction,
comment=comment,
feedback_source=feedback_source,
created_at=datetime.datetime.now(datetime.timezone.utc),
modified_at=datetime.datetime.now(datetime.timezone.utc),
)
response = self.session.post(
self.api_url + "/feedback",
headers={**self._headers, "Content-Type": "application/json"},
data=feedback.json(exclude_none=True),
)
ls_utils.raise_for_status_with_text(response)
return ls_schemas.Feedback(**feedback.dict())
def update_feedback(
self,
feedback_id: ID_TYPE,
*,
score: Union[float, int, bool, None] = None,
value: Union[float, int, bool, str, dict, None] = None,
correction: Union[dict, None] = None,
comment: Union[str, None] = None,
) -> None:
"""Update a feedback in the LangSmith API.
Parameters
----------
feedback_id : str or UUID
The ID of the feedback to update.
score : float or int or bool or None, default=None
The score to update the feedback with.
value : float or int or bool or str or dict or None, default=None
The value to update the feedback with.
correction : dict or None, default=None
The correction to update the feedback with.
comment : str or None, default=None
The comment to update the feedback with.
"""
feedback_update: Dict[str, Any] = {}
if score is not None:
feedback_update["score"] = score
if value is not None:
feedback_update["value"] = value
if correction is not None:
feedback_update["correction"] = correction
if comment is not None:
feedback_update["comment"] = comment
response = self.session.patch(
self.api_url + f"/feedback/{feedback_id}",
headers={**self._headers, "Content-Type": "application/json"},
data=json.dumps(feedback_update, default=_serialize_json),
)
ls_utils.raise_for_status_with_text(response)
def read_feedback(self, feedback_id: ID_TYPE) -> ls_schemas.Feedback:
"""Read a feedback from the LangSmith API.
Parameters
----------
feedback_id : str or UUID
The ID of the feedback to read.
Returns
-------
Feedback
The feedback.
"""
response = self._get_with_retries(f"/feedback/{feedback_id}")
return ls_schemas.Feedback(**response.json())
def list_feedback(
self,
*,
run_ids: Optional[Sequence[ID_TYPE]] = None,
feedback_key: Optional[Sequence[str]] = None,
feedback_source_type: Optional[Sequence[ls_schemas.FeedbackSourceType]] = None,
**kwargs: Any,
) -> Iterator[ls_schemas.Feedback]:
"""List the feedback objects on the LangSmith API.
Parameters
----------
run_ids : List[str or UUID] or None, default=None
The IDs of the runs to filter by.
feedback_key: List[str] or None, default=None
The feedback key(s) to filter by. Example: 'correctness'
The query performs a union of all feedback keys.
feedback_source_type: List[FeedbackSourceType] or None, default=None
The type of feedback source, such as model
(for model-generated feedback) or API.
**kwargs : Any
Additional keyword arguments.
Yields
------
Feedback
The feedback objects.
"""
params: dict = {
"run": run_ids,
**kwargs,
}
if feedback_key is not None:
params["key"] = feedback_key
if feedback_source_type is not None:
params["source"] = feedback_source_type
yield from (
ls_schemas.Feedback(**feedback)
for feedback in self._get_paginated_list("/feedback", params=params)
)
def delete_feedback(self, feedback_id: ID_TYPE) -> None:
"""Delete a feedback by ID.
Parameters
----------
feedback_id : str or UUID
The ID of the feedback to delete.
"""
response = self.session.delete(
f"{self.api_url}/feedback/{feedback_id}",
headers=self._headers,
)
ls_utils.raise_for_status_with_text(response)
async def arun_on_dataset(
self,
dataset_name: str,
llm_or_chain_factory: Any,
*,
evaluation: Optional[Any] = None,
concurrency_level: int = 5,
project_name: Optional[str] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Dict[str, Any]:
"""
Asynchronously run the Chain or language model on a dataset
and store traces to the specified project name.
Args:
dataset_name: Name of the dataset to run the chain on.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Optional evaluation configuration to use when evaluating
concurrency_level: The number of async tasks to run concurrently.
project_name: Name of the project to store the traces in.
Defaults to {dataset_name}-{chain class name}-{datetime}.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
input_mapper: A function to map to the inputs dictionary from an Example
to the format expected by the model to be evaluated. This is useful if
your model needs to deserialize more complex schema or if your dataset
has inputs with keys that differ from what is expected by your chain
or agent.
Returns:
A dictionary containing the run's project name and the
resulting model outputs.
For the synchronous version, see client.run_on_dataset.
Examples
--------
.. code-block:: python
from langsmith import Client
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
from langchain.smith import RunEvalConfig
# Chains may have memory. Passing in a constructor function lets the
# evaluation framework avoid cross-contamination between runs.
def construct_chain():
llm = ChatOpenAI(temperature=0)
chain = LLMChain.from_string(
llm,
"What's the answer to {your_input_key}"
)
return chain
# Load off-the-shelf evaluators via config or the EvaluatorType (string or enum)
evaluation_config = RunEvalConfig(
evaluators=[
"qa", # "Correctness" against a reference answer
"embedding_distance",
RunEvalConfig.Criteria("helpfulness"),
RunEvalConfig.Criteria({
"fifth-grader-score": "Do you have to be smarter than a fifth grader to answer this question?"
}),
]
)
client = Client()
await client.arun_on_dataset(
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
You can also create custom evaluators by subclassing the
:class:`StringEvaluator <langchain.evaluation.schema.StringEvaluator>`
or LangSmith's `RunEvaluator` classes.
.. code-block:: python
from typing import Optional
from langchain.evaluation import StringEvaluator
class MyStringEvaluator(StringEvaluator):
@property
def requires_input(self) -> bool:
return False
@property
def requires_reference(self) -> bool:
return True
@property
def evaluation_name(self) -> str:
return "exact_match"
def _evaluate_strings(self, prediction, reference=None, input=None, **kwargs) -> dict:
return {"score": prediction == reference}
evaluation_config = RunEvalConfig(
custom_evaluators = [MyStringEvaluator()],
)
await client.arun_on_dataset(
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
""" # noqa: E501
try:
from langchain.smith import arun_on_dataset as _arun_on_dataset
except ImportError:
raise ImportError(
"The client.arun_on_dataset function requires the langchain"
"package to run.\nInstall with pip install langchain"
)
return await _arun_on_dataset(
dataset_name=dataset_name,
llm_or_chain_factory=llm_or_chain_factory,
client=self,
evaluation=evaluation,
concurrency_level=concurrency_level,
project_name=project_name,
verbose=verbose,
tags=tags,
input_mapper=input_mapper,
)
def run_on_dataset(
self,
dataset_name: str,
llm_or_chain_factory: Any,
*,
evaluation: Optional[Any] = None,
concurrency_level: int = 5,
project_name: Optional[str] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Dict[str, Any]:
"""
Run the Chain or language model on a dataset and store traces
to the specified project name.
Args:
dataset_name: Name of the dataset to run the chain on.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Configuration for evaluators to run on the
results of the chain
concurrency_level: The number of tasks to execute concurrently.
project_name: Name of the project to store the traces in.
Defaults to {dataset_name}-{chain class name}-{datetime}.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
input_mapper: A function to map to the inputs dictionary from an Example
to the format expected by the model to be evaluated. This is useful if
your model needs to deserialize more complex schema or if your dataset
has inputs with keys that differ from what is expected by your chain
or agent.
Returns:
A dictionary containing the run's project name and the resulting model outputs.
For the (usually faster) async version of this function, see `client.arun_on_dataset`.
Examples
--------
.. code-block:: python
from langsmith import Client
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
from langchain.smith import RunEvalConfig
# Chains may have memory. Passing in a constructor function lets the
# evaluation framework avoid cross-contamination between runs.
def construct_chain():
llm = ChatOpenAI(temperature=0)
chain = LLMChain.from_string(
llm,
"What's the answer to {your_input_key}"
)
return chain
# Load off-the-shelf evaluators via config or the EvaluatorType (string or enum)
evaluation_config = RunEvalConfig(
evaluators=[
"qa", # "Correctness" against a reference answer
"embedding_distance",
RunEvalConfig.Criteria("helpfulness"),
RunEvalConfig.Criteria({
"fifth-grader-score": "Do you have to be smarter than a fifth grader to answer this question?"
}),
]
)
client = Client()
client.run_on_dataset(
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
You can also create custom evaluators by subclassing the
:class:`StringEvaluator <langchain.evaluation.schema.StringEvaluator>`
or LangSmith's `RunEvaluator` classes.
.. code-block:: python
from typing import Optional
from langchain.evaluation import StringEvaluator
class MyStringEvaluator(StringEvaluator):
@property
def requires_input(self) -> bool:
return False
@property
def requires_reference(self) -> bool:
return True
@property
def evaluation_name(self) -> str:
return "exact_match"
def _evaluate_strings(self, prediction, reference=None, input=None, **kwargs) -> dict:
return {"score": prediction == reference}
evaluation_config = RunEvalConfig(
custom_evaluators = [MyStringEvaluator()],
)
client.run_on_dataset(
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
""" # noqa: E501
try:
from langchain.smith import run_on_dataset as _run_on_dataset
except ImportError:
raise ImportError(
"The client.run_on_dataset function requires the langchain"
"package to run.\nInstall with pip install langchain"
)
return _run_on_dataset(
dataset_name=dataset_name,
llm_or_chain_factory=llm_or_chain_factory,
concurrency_level=concurrency_level,
client=self,
evaluation=evaluation,
project_name=project_name,
verbose=verbose,
tags=tags,
input_mapper=input_mapper,
)
| [] |
2024-01-10 | iamjiang/retention_model_NLP | auto-complete-sentence~GPT3_complete_sentence.py | import argparse
import pandas as pd
import os
from tqdm import tqdm
tqdm.pandas(position=0,leave=True)
import openai
OPENAI_API_KEY="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"
openai.api_key=OPENAI_API_KEY
# input_dir="s3://nlgtest"
# formal_list = pd.read_pickle(os.path.join(input_dir,'formal_list_v5.pickle'))
# formal_list = formal_list['cos_ocr'] + formal_list['cos_sct'] + formal_list['cos_matt'] + formal_list['cos_ntd']
# df=pd.DataFrame()
# df["original keyword"]=formal_list
# df.to_csv(os.path.join(input_dir,"formal_list.csv"))
def get_gpt3_complete(keyword,max_tokens=15,temperature=0):
response = openai.Completion.create(
model="text-davinci-002",
prompt=[f"given the key words below, generate a medical related only sentence ### \
key words: intractable back pain -> sentence: the person has intractable back pain *** \
key words: at high risk -> sentence: the person's condition has no change *** \
key words: 10 pain -> sentence: the person has a rating of 10 pain *** \
key words: no change -> sentence: the person's condition has no change *** \
key words: pain is well controlled -> sentence: the person control his pain ver well *** \
key words: a rating of -> sentence: the person has a rating of 10 pain level *** \
key words: good progress -> sentence: the person has shown good progress in his condition *** \
key words: {keyword} -> sentence: \
"],
temperature=0,
max_tokens=max_tokens,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
stop=["\n","<|endoftext|>"]
)
return response
def main(formal_list, args):
generated_sentence=[]
original_keyword=[]
for index,row in tqdm(formal_list.iterrows(), total=formal_list.shape[0]):
response=get_gpt3_complete(keyword=row["original_keyword"],max_tokens=30,temperature=0)
generated_sentence.append(response["choices"][0]['text'].strip("\n"))
original_keyword.append(row["original_keyword"])
output=pd.DataFrame()
output["original keyword"]=original_keyword
output["generated sentence"]=generated_sentence
output.to_csv(os.path.join(args.output_dir,args.output_name))
if __name__=="__main__":
argparser = argparse.ArgumentParser("generate sentence from keywords")
argparser.add_argument('--chunk_num', type=int, default=20)
argparser.add_argument('--output_dir', type=str, default="s3://nlgtest")
argparser.add_argument('--idx', type=int, default=0)
argparser.add_argument('--output_name', type=str, default=f"auto-complete-sentence.csv")
args = argparser.parse_args()
print(args)
args.output_name=f"auto-complete-sentence-v{args.idx}.csv"
input_dir="s3://nlgtest"
df=pd.read_csv(os.path.join(input_dir,"formal_list.csv"))
df.drop(['Unnamed: 0'],axis=1,inplace=True)
num=df.shape[0]//args.chunk_num
if args.idx == args.chunk_num-1:
data=df.iloc[args.idx*num:]
else:
data=df.iloc[args.idx*num:(args.idx+1)*num]
main(data,args)
| [
"[\"given the key words below, generate a medical related only sentence ### key words: intractable back pain -> sentence: the person has intractable back pain *** key words: at high risk -> sentence: the person's condition has no change *** key words: 10 pain -> sentence: the person has a rating of 10 pain *** key words: no change -> sentence: the person's condition has no change *** key words: pain is well controlled -> sentence: the person control his pain ver well *** key words: a rating of -> sentence: the person has a rating of 10 pain level *** key words: good progress -> sentence: the person has shown good progress in his condition *** key words: PLACEHOLDER -> sentence: \"]"
] |
2024-01-10 | dynamicdip/framework_tvb | tvb_test~datatypes~datatypes_factory.py | # -*- coding: utf-8 -*-
#
#
# TheVirtualBrain-Framework Package. This package holds all Data Management, and
# Web-UI helpful to run brain-simulations. To use it, you also need do download
# TheVirtualBrain-Scientific Package (for simulators). See content of the
# documentation-folder for more details. See also http://www.thevirtualbrain.org
#
# (c) 2012-2013, Baycrest Centre for Geriatric Care ("Baycrest")
#
# This program is free software; you can redistribute it and/or modify it under
# the terms of the GNU General Public License version 2 as published by the Free
# Software Foundation. This program is distributed in the hope that it will be
# useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
# License for more details. You should have received a copy of the GNU General
# Public License along with this program; if not, you can download it here
# http://www.gnu.org/licenses/old-licenses/gpl-2.0
#
#
# CITATION:
# When using The Virtual Brain for scientific publications, please cite it as follows:
#
# Paula Sanz Leon, Stuart A. Knock, M. Marmaduke Woodman, Lia Domide,
# Jochen Mersmann, Anthony R. McIntosh, Viktor Jirsa (2013)
# The Virtual Brain: a simulator of primate brain network dynamics.
# Frontiers in Neuroinformatics (in press)
#
#
"""
This module contains
moduleauthor:: Calin Pavel <[email protected]>
"""
import json
import numpy
from datetime import datetime
from tvb.config import SIMULATOR_MODULE, SIMULATOR_CLASS
from tvb.core.entities import model
from tvb.core.entities.storage import dao
from tvb.core.entities.file.fileshelper import FilesHelper
from tvb.core.entities.transient.structure_entities import DataTypeMetaData
from tvb.core.adapters.abcadapter import ABCAdapter
from tvb.core.services.flowservice import FlowService
from tvb.core.services.projectservice import ProjectService
from tvb.core.services.operationservice import OperationService
from tvb.datatypes.connectivity import Connectivity
from tvb.datatypes.surfaces import CorticalSurface
from tvb.datatypes.time_series import TimeSeries, TimeSeriesEEG, TimeSeriesRegion
from tvb.datatypes.graph import Covariance, ConnectivityMeasure
from tvb.datatypes.spectral import CoherenceSpectrum
from tvb.datatypes.temporal_correlations import CrossCorrelation
from tvb.datatypes.mode_decompositions import IndependentComponents
from tvb_test.datatypes.datatype1 import Datatype1
from tvb_test.datatypes.datatype2 import Datatype2
from tvb_test.adapters.storeadapter import StoreAdapter
class DatatypesFactory():
"""
This class provides a set of methods that helps user to create
different data types for testing.
These data types will be automatically stored in DB and file system if needed.
"""
USER_FULL_NAME = "Datatype Factory User"
DATATYPE_STATE = "RAW_DATA"
DATATYPE_DATA = ["test", "for", "datatypes", "factory"]
OPERATION_GROUP_NAME = "OperationsGroup"
user = None
project = None
operation = None
def __init__(self):
now = datetime.now()
micro_postfix = "_%d" % now.microsecond
# Here create all structures needed later for data types creation
self.files_helper = FilesHelper()
# First create user
user = model.User("datatype_factory_user" + micro_postfix, "test_pass",
"[email protected]" + micro_postfix, True, "user")
self.user = dao.store_entity(user)
# Now create a project
project_service = ProjectService()
data = dict(name='DatatypesFactoryProject' + micro_postfix, description='test_desc', users=[])
self.project = project_service.store_project(self.user, True, None, **data)
# Create algorithm
alg_category = model.AlgorithmCategory('one', True)
dao.store_entity(alg_category)
alg_group = model.AlgorithmGroup("test_module1", "classname1", alg_category.id)
dao.store_entity(alg_group)
algorithm = model.Algorithm(alg_group.id, 'id', name='', req_data='', param_name='', output='')
self.algorithm = dao.store_entity(algorithm)
#Create an operation
self.meta = {DataTypeMetaData.KEY_SUBJECT: self.USER_FULL_NAME,
DataTypeMetaData.KEY_STATE: self.DATATYPE_STATE}
operation = model.Operation(self.user.id, self.project.id, self.algorithm.id, 'test parameters',
meta=json.dumps(self.meta), status=model.STATUS_FINISHED, method_name=ABCAdapter.LAUNCH_METHOD)
self.operation = dao.store_entity(operation)
def get_project(self):
"""
Return project to which generated data types are assigned
"""
return self.project
def get_operation(self):
"""
Return operation to which generated data types are assigned
"""
return self.operation
def get_user(self):
"""
Return user to which generated data types are assigned
"""
return self.user
def _store_datatype(self, data_type, operation_id=None):
"""
Launch adapter to store a create a persistent DataType.
"""
operation_id = operation_id or self.operation.id
data_type.type = data_type.__class__.__name__
data_type.module = data_type.__class__.__module__
data_type.subject = self.USER_FULL_NAME
data_type.state = self.DATATYPE_STATE
data_type.set_operation_id(operation_id)
adapter_instance = StoreAdapter([data_type])
operation = dao.get_operation_by_id(operation_id)
OperationService().initiate_prelaunch(operation, adapter_instance, {})
return data_type
def create_simple_datatype(self, subject=USER_FULL_NAME, state=DATATYPE_STATE):
"""
This method creates a simple data type
"""
datatype_inst = Datatype1()
self._fill_datatype(datatype_inst, subject, state)
# Store data type
return self._store_datatype(datatype_inst)
def create_datatype_with_storage(self, subject=USER_FULL_NAME, state=DATATYPE_STATE,
data=DATATYPE_DATA, operation_id=None):
"""
This method creates and stores a data type which imply storage on the file system.
"""
datatype_inst = Datatype2()
self._fill_datatype(datatype_inst, subject, state, operation_id)
datatype_inst.string_data = data
return self._store_datatype(datatype_inst, operation_id)
def _fill_datatype(self, datatype, subject, state, operation_id=None):
"""
This method sets some common attributes on dataType
"""
operation_id = operation_id or self.operation.id
datatype.subject = subject
datatype.state = state
# Set_operation_id also sets storage_path attribute
datatype.set_operation_id(operation_id)
def __create_operation(self):
"""
Create a operation entity. Return the operation, algo_id and the storage path.
"""
meta = {DataTypeMetaData.KEY_SUBJECT: "John Doe", DataTypeMetaData.KEY_STATE: "RAW"}
algorithm, algo_group = FlowService().get_algorithm_by_module_and_class(SIMULATOR_MODULE, SIMULATOR_CLASS)
operation = model.Operation(self.user.id, self.project.id, algo_group.id, json.dumps(''),
meta=json.dumps(meta), status=model.STATUS_STARTED, method_name=ABCAdapter.LAUNCH_METHOD)
operation = dao.store_entity(operation)
storage_path = FilesHelper().get_project_folder(self.project, str(operation.id))
return operation, algorithm.id, storage_path
def create_connectivity(self):
"""
Create a connectivity that will be used in "non-dummy" burst launches (with the actual simulator).
"""
operation, algo_id, storage_path = self.__create_operation()
connectivity = Connectivity(storage_path=storage_path)
connectivity.weights = numpy.ones((74, 74))
connectivity.centres = numpy.ones((74, 3))
adapter_instance = StoreAdapter([connectivity])
OperationService().initiate_prelaunch(operation, adapter_instance, {})
return algo_id, connectivity
def create_timeseries(self, connectivity, ts_type=None, sensors=None):
"""
Create a stored TimeSeries entity.
"""
operation, _, storage_path = self.__create_operation()
if ts_type == "EEG":
time_series = TimeSeriesEEG(storage_path=storage_path, sensors=sensors)
else:
time_series = TimeSeriesRegion(storage_path=storage_path, connectivity=connectivity)
data = numpy.random.random((10, 10, 10, 10))
time = numpy.arange(10)
time_series.write_data_slice(data)
time_series.write_time_slice(time)
adapter_instance = StoreAdapter([time_series])
OperationService().initiate_prelaunch(operation, adapter_instance, {})
time_series = dao.get_datatype_by_gid(time_series.gid)
return time_series
def create_covariance(self, time_series):
"""
:returns: a stored DataType Covariance.
"""
operation, _, storage_path = self.__create_operation()
covariance = Covariance(storage_path=storage_path, source=time_series)
covariance.write_data_slice(numpy.random.random((10, 10, 10)))
adapter_instance = StoreAdapter([covariance])
OperationService().initiate_prelaunch(operation, adapter_instance, {})
return covariance
def create_crosscoherence(self, time_series):
"""
:returns: a stored entity of type CoherenceSpectrum
"""
operation, _, storage_path = self.__create_operation()
partial_coh = CoherenceSpectrum(array_data=numpy.random.random((10, 10, 10, 10)), use_storage=False)
coherence = CoherenceSpectrum(source=time_series, storage_path=storage_path, frequency=0.1, nfft=256)
coherence.write_data_slice(partial_coh)
coherence.close_file()
adapter_instance = StoreAdapter([coherence])
OperationService().initiate_prelaunch(operation, adapter_instance, {})
return coherence
def create_crosscorrelation(self, time_series):
"""
:returns: `CrossCorrelation` stored entity.
"""
operation, _, storage_path = self.__create_operation()
partial_corr = CrossCorrelation(array_data=numpy.random.random((10, 10, 10, 10, 10)), use_storage=False)
crossc = CrossCorrelation(source=time_series, storage_path=storage_path, time=range(10))
crossc.write_data_slice(partial_corr)
crossc.close_file()
adapter_instance = StoreAdapter([crossc])
OperationService().initiate_prelaunch(operation, adapter_instance, {})
return crossc
def create_surface(self):
"""
Create a dummy surface entity.
:returns: (Algorithm Identifier, stored Surface entity)
"""
operation, algo_id, storage_path = self.__create_operation()
surface = CorticalSurface(storage_path=storage_path)
surface.vertices = numpy.array([[-10, 0, 0],
[0, 0, -10],
[10, 0, 0],
[0, 10, 0]], dtype=float)
surface.triangles = numpy.array([[0, 1, 2],
[0, 1, 3],
[1, 2, 3],
[0, 2, 3]], dtype=int)
surface.number_of_triangles = 4
surface.number_of_vertices = 4
surface.triangle_normals = numpy.ones((4, 3))
surface.vertex_normals = numpy.ones((4, 3))
surface.zero_based_triangles = True
adapter_instance = StoreAdapter([surface])
OperationService().initiate_prelaunch(operation, adapter_instance, {})
return algo_id, surface
def create_connectivity_measure(self, connectivity):
"""
:returns: persisted entity ConnectivityMeasure
"""
operation, _, storage_path = self.__create_operation()
conn_measure = ConnectivityMeasure(storage_path=storage_path)
conn_measure.connectivity = connectivity
adapter_instance = StoreAdapter([conn_measure])
OperationService().initiate_prelaunch(operation, adapter_instance, {})
return conn_measure
def create_ICA(self, timeseries):
"""
:returns: persisted entity IndependentComponents
"""
operation, _, storage_path = self.__create_operation()
partial_ts = TimeSeries(use_storage=False)
partial_ts.data = numpy.random.random((10, 10, 10, 10))
partial_ica = IndependentComponents(source=partial_ts,
component_time_series=numpy.random.random((10, 10, 10, 10)),
prewhitening_matrix=numpy.random.random((10, 10, 10, 10)),
unmixing_matrix=numpy.random.random((10, 10, 10, 10)),
n_components=10, use_storage=False)
ica = IndependentComponents(source=timeseries, n_components=10, storage_path=storage_path)
ica.write_data_slice(partial_ica)
adapter_instance = StoreAdapter([ica])
OperationService().initiate_prelaunch(operation, adapter_instance, {})
return ica
def create_datatype_group(self, subject=USER_FULL_NAME, state=DATATYPE_STATE, ):
"""
This method creates, stores and returns a DataTypeGroup entity.
"""
OPERATION_GROUP_RANGE = [json.dumps(["row1", ['a', 'b', 'c']])]
group = model.OperationGroup(self.project.id, self.OPERATION_GROUP_NAME, OPERATION_GROUP_RANGE)
group = dao.store_entity(group)
datatype_group = model.DataTypeGroup(group, subject=subject, state=state, operation_id=self.operation.id)
# Set storage path, before setting data
datatype_group.storage_path = self.files_helper.get_project_folder(
self.project, str(self.operation.id))
datatype_group = dao.store_entity(datatype_group)
# Now create some data types and add them to group
for range_val in ['a', 'b', 'c']:
operation = model.Operation(self.user.id, self.project.id, self.algorithm.id, 'test parameters',
meta=json.dumps(self.meta), status=model.STATUS_FINISHED,
method_name=ABCAdapter.LAUNCH_METHOD,
range_values=json.dumps({'row1': range_val}))
operation.fk_operation_group = group.id
operation = dao.store_entity(operation)
datatype = self.create_datatype_with_storage(operation_id=operation.id)
datatype.row1 = range_val
datatype.fk_datatype_group = datatype_group.id
datatype.set_operation_id(operation.id)
dao.store_entity(datatype)
return datatype_group | [] |
2024-01-10 | Omar-Riaz/sagemine-be | src~handlers~PromptController.py | from flask import Blueprint, jsonify, request, Response
from flask.views import MethodView
from openai.error import OpenAIError
from services.prompts.PromptService import PromptService
from models.Sentence import Sentence
prompt_controller = Blueprint('prompt_controller', __name__)
class PromptController(MethodView):
def __init__(self):
self.prompt_service = PromptService()
# @prompt_controller.route('/prompt', methods=['POST'])
def post(self, student_id: str) -> Response:
data = request.get_json()
if data is None:
return jsonify({'error': 'Invalid JSON or wrong content-type.'}), 400
if 'prompt' not in data:
return jsonify({'error': 'No prompt provided.'}), 400
prompt = data['prompt']
try:
if 'create a diagram of the process for' in prompt.lower():
prompt = prompt.lower()
prompt = prompt.replace('create a diagram of the process for', '')
answer = self.prompt_service.answer_prompt(prompt, student_id, "services/prompts/MermaidTemplate.txt", False)
answer.append(Sentence(source=answer[-1].source, string="A diagram has been generated, please refer to the diagram generator below", isDiagram=True))
else:
answer = self.prompt_service.answer_prompt(prompt, student_id, "services/prompts/PromptWithEmbeddingTemplate.txt", True)
return jsonify([sentence.dict() for sentence in answer]), 200
except OpenAIError as err:
return jsonify({'error': str(err)}), 500
prompt_controller.add_url_rule('/prompt/<student_id>', view_func=PromptController.as_view('answer_prompt'), methods=['POST']) | [
"prompt_controller",
"create a diagram of the process for"
] |
2024-01-10 | Omar-Riaz/sagemine-be | src~services~prompts~PromptService.py | import os
import openai
from openai.error import OpenAIError
import backoff
import tiktoken
from sentence_transformers import SentenceTransformer
from models.Embedding import Embedding
from models.Sentence import Sentence
from services.embeddings.EmbeddingService import EmbeddingService
from daos.EmbeddingDao import EmbeddingDao
from daos.StudentDao import StudentDao
openai.api_key = os.getenv('OPENAI_API_KEY')
class PromptService:
def __init__(self):
self.embedding_service = EmbeddingService()
self.embedding_dao = EmbeddingDao()
self.student_dao = StudentDao()
self.model = SentenceTransformer('paraphrase-MiniLM-L6-v2')
def search_string(self, string: str, course: str, student_id: str, n_closest: int = 8) -> list[Embedding]:
"""Get all embeddings for a course and return relevant information for the string,"""
string_embedding = self.model.encode([string])
closest_embeddings = self.embedding_dao.get_closest_embeddings(string_embedding, n_closest)
closest_sources = [embedding['source'] for embedding in closest_embeddings]
self.student_dao.add_suggestions(student_id, closest_sources)
return closest_embeddings
def ask_user_prompt(self, prompt: str, searched_embeddings: list[Embedding], template_file: str) -> str:
"""Add search results to prompt and return answer to user """
searched_sentences = [embedding['sentence'] for embedding in searched_embeddings]
with open(template_file, 'r', encoding="utf-8") as template_file:
template = template_file.read()
formatted_template = template.format(searched_sentences, prompt)
return self.call_openai(formatted_template, 3500)
def answer_prompt(self, prompt: str, student_id: str, template_file: str, return_diagram: bool) -> list[Sentence]:
"""search for a user query, use relevant info to ask prompt and record suggestions"""
searched_embeddings = self.search_string(prompt, "TM101", student_id, 8)
answer = self.ask_user_prompt(prompt, searched_embeddings, template_file)
answer_sentences = self.embedding_service.split_into_sentences(answer)
output_sentences = []
for sentence in answer_sentences:
print("sentence returned by bot:", sentence)
embedding = self.search_string(sentence, "TM101", student_id, 1)
output_sentences.append(Sentence(string=sentence, source=embedding[0]['source'], isDiagram=return_diagram))
return output_sentences
# def answer_diagram(self, prompt: str, student_id: str) -> list[Sentence]:
# """Ask prompt and return answer to user """
# with open('services/prompts/MermaidTemplate.txt', 'r', encoding="utf-8") as template_file:
# template = template_file.read()
# formatted_template = template.format(prompt)
# answer = self.call_openai(formatted_template, 3500)
# answer_sentences = self.embedding_service.split_into_sentences(answer)
# output_sentences = []
# for sentence in answer_sentences:
# embedding = self.search_string(sentence, "TM101", student_id, 1)
# output_sentences.append(Sentence(string=sentence, source=embedding[0]['source']))
# return output_sentences
@backoff.on_exception(backoff.expo, OpenAIError, max_tries=3)
def call_openai(self, prompt: str, max_tokens: int) -> str:
"""Call OpenAI's API with exponential backoff."""
# print("prompt")
# print(prompt)
# openai_responses = openai.ChatCompletion.create(
# engine="text-davinci-002",
# prompt=prompt,
# max_tokens=max_tokens
# )
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "user", "content": prompt}
],
max_tokens=max_tokens
)
# print(response)
return response.choices[0].message.content.strip()
# print(openai_responses.choices)
# answer = openai_responses.choices[0].text.strip()
# return answer | [] |
2024-01-10 | ashification/ashification-streamlit_Chatbot | streamlit_app.py | """ File to run chat bot app"""
import os
import openai
import streamlit as st
from hugchat import hugchat
from hugchat.login import Login
#Utilising github env variable secrets
#uName_Check = os.environ.get("GENAI_CHATBOT_USERNAME")
#pwd_Check = os.environ.get("GENAI_CHATBOT_PASSWORD")
#API_KEY = os.environ.get("GENAI_CHATBOT_APIKEY")
st.title("🤖 Group 3 Chatbot 🤖 ")
if "messages" not in st.session_state:
st.session_state["messages"] = [{"role": "assistant", "content": "How can I help you?"}]
# Hugging Face Credentials
with st.sidebar:
st.title('Group 3 Login')
#st.write('Debug', hf_email)
if "password_correct" not in st.session_state:
st.session_state["password_correct"] = False
if st.session_state["password_correct"] == False :
hf_email = st.text_input('Enter Username:')
hf_pass = st.text_input('Enter password:', type='password')
button = st.button("Log in")
if button:
if (hf_email == st.secrets['EMAIL']) and (hf_pass == st.secrets['PASS']):
st.session_state["password_correct"] = True
else:
st.warning('Please enter your credentials!', icon='⚠️')
if st.session_state["password_correct"] == True :
st.success('Successful Login!', icon='✅')
openai_api_key = st.text_input("OpenAI API Key", key="chatbot_api_key", type="password")
button = st.button("Log Out")
if button:
st.session_state["password_correct"] = False
for msg in st.session_state.messages:
st.chat_message(msg["role"]).write(msg["content"])
if prompt := st.chat_input():
if not openai_api_key:
st.info("Please add your OpenAI API key to continue.")
st.stop()
openai.api_key = openai_api_key
st.session_state.messages.append({"role": "user", "content": prompt})
st.chat_message("user").write(prompt)
response = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=st.session_state.messages)
msg = response.choices[0].message
st.session_state.messages.append(msg)
st.chat_message("assistant").write(msg.content) | [
"How can I help you?"
] |
2024-01-10 | JaredWensley/StudyPal | PDFtest.py | # use defined utilities
from utils import *
# ingest PDF files
from langchain.document_loaders import PyPDFLoader
# Load GOOG's 10K annual report (92 pages).
def_url = "https://abc.xyz/investor/static/pdf/20230203_alphabet_10K.pdf"
class newPDFWorker:
def __init__(self) -> None:
pass
def setFolder(self, folderName):
self.folderName = folderName
def embedPDF(self, url):
loader = PyPDFLoader(url)
documents = loader.load()
# from google.colab import auth as google_auth
# google_auth.authenticate_user()
PROJECT_ID = ""
LOCATION = "us-central1"
import vertexai
x = vertexai.init(project=PROJECT_ID, location=LOCATION)
# split the documents into chunks
from langchain.text_splitter import RecursiveCharacterTextSplitter
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1500, chunk_overlap=0)
docs = text_splitter.split_documents(documents)
print(f"# of documents = {len(docs)}")
vector_save_directory = 'D:\\Documents\\NotesHelper\\'+ self.folderName #CHANGE THIS
# Store docs in local vectorstore as index
# it may take a while since API is rate limited
from langchain.vectorstores import Chroma
# create DB file from results
chroma_db = Chroma.from_documents(docs,
embeddings,
persist_directory=vector_save_directory)
chroma_db.persist()
# Read from the created chroma DB (sqlite file)
vector_read_from_db = Chroma(persist_directory=vector_save_directory,
embedding_function=embeddings)
# Expose index to the retriever, will search based on question
retriever = vector_read_from_db.as_retriever(search_type="similarity", search_kwargs={"k": 2})
# Create chain to answer questions
from langchain.chains import RetrievalQA
# Uses LLM to synthesize results from the search index.
# We use Vertex PaLM Text API for LLM
qa = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=retriever,
return_source_documents=True
)
#query = "What was Alphabet's net income in 2022?"
#result = qa({"query": query})
print("Done")
| [] |
2024-01-10 | JaredWensley/StudyPal | afterSave.py | from utils import *
import json
# ingest PDF files
from langchain.document_loaders import PyPDFLoader
# Load GOOG's 10K annual report (92 pages).
url = "https://abc.xyz/investor/static/pdf/20230203_alphabet_10K.pdf"
class savedPDFWorker:
def __init__(self):
pass
def setFolder(self, folderName):
self.folderName = folderName
def get_AI_response(self, message):
loader = PyPDFLoader(url)
documents = loader.load()
PROJECT_ID = ""
LOCATION = "us-central1"
vector_save_directory = 'D:\\Documents\\NotesHelper\\'+ self.folderName #CHANGE THIS
# Store docs in local vectorstore as index
# it may take a while since API is rate limited
from langchain.vectorstores import Chroma
vector_read_from_db = Chroma(persist_directory=vector_save_directory,
embedding_function=embeddings)
# Expose index to the retriever
retriever = vector_read_from_db.as_retriever(search_type="similarity", search_kwargs={"k": 2})
# Create chain to answer questions
from langchain.chains import RetrievalQA
# Uses LLM to synthesize results from the search index.
# We use Vertex PaLM Text API for LLM
qa = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=retriever,
return_source_documents=True
)
query = message
result = qa({"query": query})
return result
| [] |
2024-01-10 | Valdanitooooo/langchain | libs~langchain~langchain~document_loaders~parsers~language~cobol.py | import re
from typing import Callable, List
from langchain.document_loaders.parsers.language.code_segmenter import CodeSegmenter
class CobolSegmenter(CodeSegmenter):
"""Code segmenter for `COBOL`."""
PARAGRAPH_PATTERN = re.compile(r"^[A-Z0-9\-]+(\s+.*)?\.$", re.IGNORECASE)
DIVISION_PATTERN = re.compile(
r"^\s*(IDENTIFICATION|DATA|PROCEDURE|ENVIRONMENT)\s+DIVISION.*$", re.IGNORECASE
)
SECTION_PATTERN = re.compile(r"^\s*[A-Z0-9\-]+\s+SECTION.$", re.IGNORECASE)
def __init__(self, code: str):
super().__init__(code)
self.source_lines: List[str] = self.code.splitlines()
def is_valid(self) -> bool:
# Identify presence of any division to validate COBOL code
return any(self.DIVISION_PATTERN.match(line) for line in self.source_lines)
def _extract_code(self, start_idx: int, end_idx: int) -> str:
return "\n".join(self.source_lines[start_idx:end_idx]).rstrip("\n")
def _is_relevant_code(self, line: str) -> bool:
"""Check if a line is part of the procedure division or a relevant section."""
if "PROCEDURE DIVISION" in line.upper():
return True
# Add additional conditions for relevant sections if needed
return False
def _process_lines(self, func: Callable) -> List[str]:
"""A generic function to process COBOL lines based on provided func."""
elements: List[str] = []
start_idx = None
inside_relevant_section = False
for i, line in enumerate(self.source_lines):
if self._is_relevant_code(line):
inside_relevant_section = True
if inside_relevant_section and (
self.PARAGRAPH_PATTERN.match(line.strip().split(" ")[0])
or self.SECTION_PATTERN.match(line.strip())
):
if start_idx is not None:
func(elements, start_idx, i)
start_idx = i
# Handle the last element if exists
if start_idx is not None:
func(elements, start_idx, len(self.source_lines))
return elements
def extract_functions_classes(self) -> List[str]:
def extract_func(elements: List[str], start_idx: int, end_idx: int) -> None:
elements.append(self._extract_code(start_idx, end_idx))
return self._process_lines(extract_func)
def simplify_code(self) -> str:
simplified_lines: List[str] = []
inside_relevant_section = False
omitted_code_added = (
False # To track if "* OMITTED CODE *" has been added after the last header
)
for line in self.source_lines:
is_header = (
"PROCEDURE DIVISION" in line
or "DATA DIVISION" in line
or "IDENTIFICATION DIVISION" in line
or self.PARAGRAPH_PATTERN.match(line.strip().split(" ")[0])
or self.SECTION_PATTERN.match(line.strip())
)
if is_header:
inside_relevant_section = True
# Reset the flag since we're entering a new section/division or
# paragraph
omitted_code_added = False
if inside_relevant_section:
if is_header:
# Add header and reset the omitted code added flag
simplified_lines.append(line)
elif not omitted_code_added:
# Add omitted code comment only if it hasn't been added directly
# after the last header
simplified_lines.append("* OMITTED CODE *")
omitted_code_added = True
return "\n".join(simplified_lines)
| [] |
2024-01-10 | Valdanitooooo/langchain | libs~langchain~langchain~document_loaders~docusaurus.py | """Load Documents from Docusarus Documentation"""
from typing import Any, List, Optional
from langchain.document_loaders.sitemap import SitemapLoader
class DocusaurusLoader(SitemapLoader):
"""
Loader that leverages the SitemapLoader to loop through the generated pages of a
Docusaurus Documentation website and extracts the content by looking for specific
HTML tags. By default, the parser searches for the main content of the Docusaurus
page, which is normally the <article>. You also have the option to define your own
custom HTML tags by providing them as a list, for example: ["div", ".main", "a"].
"""
def __init__(
self,
url: str,
custom_html_tags: Optional[List[str]] = None,
**kwargs: Any,
):
"""
Initialize DocusaurusLoader
Args:
url: The base URL of the Docusaurus website.
custom_html_tags: Optional custom html tags to extract content from pages.
kwargs: Additional args to extend the underlying SitemapLoader, for example:
filter_urls, blocksize, meta_function, is_local, continue_on_failure
"""
if not kwargs.get("is_local"):
url = f"{url}/sitemap.xml"
self.custom_html_tags = custom_html_tags or ["main article"]
super().__init__(
url,
parsing_function=kwargs.get("parsing_function") or self._parsing_function,
**kwargs,
)
def _parsing_function(self, content: Any) -> str:
"""Parses specific elements from a Docusarus page."""
relevant_elements = content.select(",".join(self.custom_html_tags))
for element in relevant_elements:
if element not in relevant_elements:
element.decompose()
return str(content.get_text())
| [] |
2024-01-10 | Valdanitooooo/langchain | templates~rag-timescale-conversation~rag_timescale_conversation~load_sample_dataset.py | import os
import tempfile
from datetime import datetime, timedelta
import requests
from langchain.document_loaders import JSONLoader
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores.timescalevector import TimescaleVector
from timescale_vector import client
def parse_date(date_string: str) -> datetime:
if date_string is None:
return None
time_format = "%a %b %d %H:%M:%S %Y %z"
return datetime.strptime(date_string, time_format)
def extract_metadata(record: dict, metadata: dict) -> dict:
dt = parse_date(record["date"])
metadata["id"] = str(client.uuid_from_time(dt))
if dt is not None:
metadata["date"] = dt.isoformat()
else:
metadata["date"] = None
metadata["author"] = record["author"]
metadata["commit_hash"] = record["commit"]
return metadata
def load_ts_git_dataset(
service_url,
collection_name="timescale_commits",
num_records: int = 500,
partition_interval=timedelta(days=7),
):
json_url = "https://s3.amazonaws.com/assets.timescale.com/ai/ts_git_log.json"
tmp_file = "ts_git_log.json"
temp_dir = tempfile.gettempdir()
json_file_path = os.path.join(temp_dir, tmp_file)
if not os.path.exists(json_file_path):
response = requests.get(json_url)
if response.status_code == 200:
with open(json_file_path, "w") as json_file:
json_file.write(response.text)
else:
print(f"Failed to download JSON file. Status code: {response.status_code}")
loader = JSONLoader(
file_path=json_file_path,
jq_schema=".commit_history[]",
text_content=False,
metadata_func=extract_metadata,
)
documents = loader.load()
# Remove documents with None dates
documents = [doc for doc in documents if doc.metadata["date"] is not None]
if num_records > 0:
documents = documents[:num_records]
# Split the documents into chunks for embedding
text_splitter = CharacterTextSplitter(
chunk_size=1000,
chunk_overlap=200,
)
docs = text_splitter.split_documents(documents)
embeddings = OpenAIEmbeddings()
# Create a Timescale Vector instance from the collection of documents
TimescaleVector.from_documents(
embedding=embeddings,
ids=[doc.metadata["id"] for doc in docs],
documents=docs,
collection_name=collection_name,
service_url=service_url,
time_partition_interval=partition_interval,
)
| [] |
2024-01-10 | leewtai/leewtai.github.io | usecases_data~data_cleaning_ai~name_entity_cleaning.py | import os
import json
from glob import glob
import openai
import pandas as pd
import requests
openai.api_key = os.getenv('OPENAI_API_KEY')
fns = glob('../h1b/data/*.csv')
int_cols = ['Initial Approval', 'Initial Denial', 'Continuing Approval',
'Continuing Denial']
def process_h1b(h1b):
fix = h1b.copy()
for int_col in int_cols:
fix[int_col] = h1b[int_col].astype(str)
fix[int_col] = fix[int_col].str.replace(',', '')
fix[int_col] = fix[int_col].astype(int)
fix = fix.loc[fix.Employer.notna()]
return fix
dfs = []
for fn in fns:
df = pd.read_csv(fn)
if int_cols[0] not in df.columns:
df.rename(columns={col + 's': col for col in int_cols}, inplace=True)
dfs.append(process_h1b(df))
df = pd.concat(dfs, ignore_index=True)
df.columns
df['Fiscal Year'].value_counts()
df.head(3)
employers = df.Employer[df['Fiscal Year'] == 2022].unique()
employers = df.Employer[df.Employer.str.contains(r"(AMAZON|GOOGLE)")].unique()
len(employers)
employers[:10]
companies = []
em_sep = ', '.join(employers[:100])
message = ("For each company listed below, if it is a subsidiary of another "
"company, please give me the name of its parent company, otherwise "
"don't return anything. Here is the list of companies:") + em_sep
len(message)
results = openai.ChatCompletion.create(
model="gpt-4-0314",
messages=[
{"role": "user",
"content": message},
],
temperature=0,
)
assert results.choices[0]['finish_reason'] == 'stop'
results.model
results.keys()
results.usage
# old prompt: completion: 1164, prompt: 892
# new prmopt: completion: 121, prompt: 889
results.usage.completion_tokens + results.usage.prompt_tokens
results.choices[0].message.role
#companies = results.choices[0].message.content.split('\n')
created = results.created
with open(f"companies_subsidiary_{created}.txt", "w") as f:
f.write(results.choices[0].message.content)
results = openai.Completion.create(
model="gpt-4",
prompt=message,
)
| [
"For each company listed below, if it is a subsidiary of another company, please give me the name of its parent company, otherwise don't return anything. Here is the list of companies:PLACEHOLDER"
] |
2024-01-10 | osanseviero/langchain | tests~unit_tests~utilities~test_loading.py | """Test the functionality of loading from langchain-hub."""
import json
import re
from pathlib import Path
from typing import Iterable
from unittest.mock import Mock
from urllib.parse import urljoin
import pytest
import responses
from langchain.utilities.loading import DEFAULT_REF, URL_BASE, try_load_from_hub
@pytest.fixture(autouse=True)
def mocked_responses() -> Iterable[responses.RequestsMock]:
"""Fixture mocking requests.get."""
with responses.RequestsMock() as rsps:
yield rsps
def test_non_hub_path() -> None:
"""Test that a non-hub path returns None."""
path = "chains/some_path"
loader = Mock()
valid_suffixes = {"suffix"}
result = try_load_from_hub(path, loader, "chains", valid_suffixes)
assert result is None
loader.assert_not_called()
def test_invalid_prefix() -> None:
"""Test that a hub path with an invalid prefix returns None."""
path = "lc://agents/some_path"
loader = Mock()
valid_suffixes = {"suffix"}
result = try_load_from_hub(path, loader, "chains", valid_suffixes)
assert result is None
loader.assert_not_called()
def test_invalid_suffix() -> None:
"""Test that a hub path with an invalid suffix raises an error."""
path = "lc://chains/path.invalid"
loader = Mock()
valid_suffixes = {"json"}
with pytest.raises(ValueError, match="Unsupported file type."):
try_load_from_hub(path, loader, "chains", valid_suffixes)
loader.assert_not_called()
def test_invalid_source() -> None:
"""Test that a path from an invalid source"""
path = "ts://chains/some_path.json"
loader = Mock()
valid_suffixes = {"json"}
result = try_load_from_hub(path, loader, "chains", valid_suffixes)
assert result is None
loader.assert_not_called()
@pytest.mark.parametrize("ref", [None, "v0.3"])
def test_success(mocked_responses: responses.RequestsMock, ref: str) -> None:
"""Test that a valid hub path is loaded correctly with and without a ref."""
path = "chains/path/chain.json"
lc_path_prefix = f"lc{('@' + ref) if ref else ''}://"
valid_suffixes = {"json"}
body = json.dumps({"foo": "bar"})
ref = ref or DEFAULT_REF
file_contents = None
def loader(file_path: str) -> None:
nonlocal file_contents
assert file_contents is None
file_contents = Path(file_path).read_text()
mocked_responses.get(
urljoin(URL_BASE.format(ref=ref), path),
body=body,
status=200,
content_type="application/json",
)
try_load_from_hub(f"{lc_path_prefix}{path}", loader, "chains", valid_suffixes)
assert file_contents == body
def test_failed_request(mocked_responses: responses.RequestsMock) -> None:
"""Test that a failed request raises an error."""
path = "chains/path/chain.json"
loader = Mock()
mocked_responses.get(urljoin(URL_BASE.format(ref=DEFAULT_REF), path), status=500)
with pytest.raises(ValueError, match=re.compile("Could not find file at .*")):
try_load_from_hub(f"lc://{path}", loader, "chains", {"json"})
loader.assert_not_called()
| [] |
2024-01-10 | osanseviero/langchain | langchain~agents~load_tools.py | # flake8: noqa
"""Load tools."""
from typing import Any, List, Optional
from langchain.agents.tools import Tool
from langchain.callbacks.base import BaseCallbackManager
from langchain.chains.api import news_docs, open_meteo_docs, tmdb_docs
from langchain.chains.api.base import APIChain
from langchain.chains.llm_math.base import LLMMathChain
from langchain.chains.pal.base import PALChain
from langchain.llms.base import BaseLLM
from langchain.python import PythonREPL
from langchain.requests import RequestsWrapper
from langchain.tools.base import BaseTool
from langchain.tools.bing_search.tool import BingSearchRun
from langchain.tools.google_search.tool import GoogleSearchResults, GoogleSearchRun
from langchain.tools.wolfram_alpha.tool import WolframAlphaQueryRun
from langchain.utilities.bash import BashProcess
from langchain.utilities.bing_search import BingSearchAPIWrapper
from langchain.utilities.google_search import GoogleSearchAPIWrapper
from langchain.utilities.google_serper import GoogleSerperAPIWrapper
from langchain.utilities.searx_search import SearxSearchWrapper
from langchain.utilities.serpapi import SerpAPIWrapper
from langchain.utilities.wolfram_alpha import WolframAlphaAPIWrapper
def _get_python_repl() -> BaseTool:
return Tool(
name="Python REPL",
description="A Python shell. Use this to execute python commands. Input should be a valid python command. If you expect output it should be printed out.",
func=PythonREPL().run,
)
def _get_requests() -> BaseTool:
return Tool(
name="Requests",
description="A portal to the internet. Use this when you need to get specific content from a site. Input should be a specific url, and the output will be all the text on that page.",
func=RequestsWrapper().run,
)
def _get_terminal() -> BaseTool:
return Tool(
name="Terminal",
description="Executes commands in a terminal. Input should be valid commands, and the output will be any output from running that command.",
func=BashProcess().run,
)
_BASE_TOOLS = {
"python_repl": _get_python_repl,
"requests": _get_requests,
"terminal": _get_terminal,
}
def _get_pal_math(llm: BaseLLM) -> BaseTool:
return Tool(
name="PAL-MATH",
description="A language model that is really good at solving complex word math problems. Input should be a fully worded hard word math problem.",
func=PALChain.from_math_prompt(llm).run,
)
def _get_pal_colored_objects(llm: BaseLLM) -> BaseTool:
return Tool(
name="PAL-COLOR-OBJ",
description="A language model that is really good at reasoning about position and the color attributes of objects. Input should be a fully worded hard reasoning problem. Make sure to include all information about the objects AND the final question you want to answer.",
func=PALChain.from_colored_object_prompt(llm).run,
)
def _get_llm_math(llm: BaseLLM) -> BaseTool:
return Tool(
name="Calculator",
description="Useful for when you need to answer questions about math.",
func=LLMMathChain(llm=llm, callback_manager=llm.callback_manager).run,
coroutine=LLMMathChain(llm=llm, callback_manager=llm.callback_manager).arun,
)
def _get_open_meteo_api(llm: BaseLLM) -> BaseTool:
chain = APIChain.from_llm_and_api_docs(llm, open_meteo_docs.OPEN_METEO_DOCS)
return Tool(
name="Open Meteo API",
description="Useful for when you want to get weather information from the OpenMeteo API. The input should be a question in natural language that this API can answer.",
func=chain.run,
)
_LLM_TOOLS = {
"pal-math": _get_pal_math,
"pal-colored-objects": _get_pal_colored_objects,
"llm-math": _get_llm_math,
"open-meteo-api": _get_open_meteo_api,
}
def _get_news_api(llm: BaseLLM, **kwargs: Any) -> BaseTool:
news_api_key = kwargs["news_api_key"]
chain = APIChain.from_llm_and_api_docs(
llm, news_docs.NEWS_DOCS, headers={"X-Api-Key": news_api_key}
)
return Tool(
name="News API",
description="Use this when you want to get information about the top headlines of current news stories. The input should be a question in natural language that this API can answer.",
func=chain.run,
)
def _get_tmdb_api(llm: BaseLLM, **kwargs: Any) -> BaseTool:
tmdb_bearer_token = kwargs["tmdb_bearer_token"]
chain = APIChain.from_llm_and_api_docs(
llm,
tmdb_docs.TMDB_DOCS,
headers={"Authorization": f"Bearer {tmdb_bearer_token}"},
)
return Tool(
name="TMDB API",
description="Useful for when you want to get information from The Movie Database. The input should be a question in natural language that this API can answer.",
func=chain.run,
)
def _get_wolfram_alpha(**kwargs: Any) -> BaseTool:
return WolframAlphaQueryRun(api_wrapper=WolframAlphaAPIWrapper(**kwargs))
def _get_google_search(**kwargs: Any) -> BaseTool:
return GoogleSearchRun(api_wrapper=GoogleSearchAPIWrapper(**kwargs))
def _get_google_serper(**kwargs: Any) -> BaseTool:
return Tool(
name="Serper Search",
func=GoogleSerperAPIWrapper(**kwargs).run,
description="A low-cost Google Search API. Useful for when you need to answer questions about current events. Input should be a search query.",
)
def _get_google_search_results_json(**kwargs: Any) -> BaseTool:
return GoogleSearchResults(api_wrapper=GoogleSearchAPIWrapper(**kwargs))
def _get_serpapi(**kwargs: Any) -> BaseTool:
return Tool(
name="Search",
description="A search engine. Useful for when you need to answer questions about current events. Input should be a search query.",
func=SerpAPIWrapper(**kwargs).run,
coroutine=SerpAPIWrapper(**kwargs).arun,
)
def _get_searx_search(**kwargs: Any) -> BaseTool:
return Tool(
name="SearX Search",
description="A meta search engine. Useful for when you need to answer questions about current events. Input should be a search query.",
func=SearxSearchWrapper(**kwargs).run,
)
def _get_bing_search(**kwargs: Any) -> BaseTool:
return BingSearchRun(api_wrapper=BingSearchAPIWrapper(**kwargs))
_EXTRA_LLM_TOOLS = {
"news-api": (_get_news_api, ["news_api_key"]),
"tmdb-api": (_get_tmdb_api, ["tmdb_bearer_token"]),
}
_EXTRA_OPTIONAL_TOOLS = {
"wolfram-alpha": (_get_wolfram_alpha, ["wolfram_alpha_appid"]),
"google-search": (_get_google_search, ["google_api_key", "google_cse_id"]),
"google-search-results-json": (
_get_google_search_results_json,
["google_api_key", "google_cse_id", "num_results"],
),
"bing-search": (_get_bing_search, ["bing_subscription_key", "bing_search_url"]),
"google-serper": (_get_google_serper, ["serper_api_key"]),
"serpapi": (_get_serpapi, ["serpapi_api_key", "aiosession"]),
"searx-search": (_get_searx_search, ["searx_host"]),
}
def load_tools(
tool_names: List[str],
llm: Optional[BaseLLM] = None,
callback_manager: Optional[BaseCallbackManager] = None,
**kwargs: Any,
) -> List[BaseTool]:
"""Load tools based on their name.
Args:
tool_names: name of tools to load.
llm: Optional language model, may be needed to initialize certain tools.
callback_manager: Optional callback manager. If not provided, default global callback manager will be used.
Returns:
List of tools.
"""
tools = []
for name in tool_names:
if name in _BASE_TOOLS:
tools.append(_BASE_TOOLS[name]())
elif name in _LLM_TOOLS:
if llm is None:
raise ValueError(f"Tool {name} requires an LLM to be provided")
tool = _LLM_TOOLS[name](llm)
if callback_manager is not None:
tool.callback_manager = callback_manager
tools.append(tool)
elif name in _EXTRA_LLM_TOOLS:
if llm is None:
raise ValueError(f"Tool {name} requires an LLM to be provided")
_get_llm_tool_func, extra_keys = _EXTRA_LLM_TOOLS[name]
missing_keys = set(extra_keys).difference(kwargs)
if missing_keys:
raise ValueError(
f"Tool {name} requires some parameters that were not "
f"provided: {missing_keys}"
)
sub_kwargs = {k: kwargs[k] for k in extra_keys}
tool = _get_llm_tool_func(llm=llm, **sub_kwargs)
if callback_manager is not None:
tool.callback_manager = callback_manager
tools.append(tool)
elif name in _EXTRA_OPTIONAL_TOOLS:
_get_tool_func, extra_keys = _EXTRA_OPTIONAL_TOOLS[name]
sub_kwargs = {k: kwargs[k] for k in extra_keys if k in kwargs}
tool = _get_tool_func(**sub_kwargs)
if callback_manager is not None:
tool.callback_manager = callback_manager
tools.append(tool)
else:
raise ValueError(f"Got unknown tool {name}")
return tools
def get_all_tool_names() -> List[str]:
"""Get a list of all possible tool names."""
return (
list(_BASE_TOOLS)
+ list(_EXTRA_OPTIONAL_TOOLS)
+ list(_EXTRA_LLM_TOOLS)
+ list(_LLM_TOOLS)
)
| [] |
2024-01-10 | azrilachmad/Layn-AI-Discord-Bot | models~index_model.py | import functools
import os
import random
import tempfile
import traceback
import asyncio
import json
from collections import defaultdict
import aiohttp
import discord
import aiofiles
from functools import partial
from typing import List, Optional
from pathlib import Path
from datetime import date
from discord import InteractionResponse, Interaction
from discord.ext import pages
from langchain import OpenAI
from gpt_index.readers import YoutubeTranscriptReader
from gpt_index.readers.schema.base import Document
from gpt_index.langchain_helpers.text_splitter import TokenTextSplitter
from gpt_index import (
GPTSimpleVectorIndex,
SimpleDirectoryReader,
QuestionAnswerPrompt,
BeautifulSoupWebReader,
GPTListIndex,
QueryMode,
GPTTreeIndex,
GoogleDocsReader,
MockLLMPredictor,
LLMPredictor,
QueryConfig,
PromptHelper,
IndexStructType,
OpenAIEmbedding,
GithubRepositoryReader,
MockEmbedding,
)
from gpt_index.readers.web import DEFAULT_WEBSITE_EXTRACTOR
from gpt_index.composability import ComposableGraph
from models.embed_statics_model import EmbedStatics
from services.environment_service import EnvService, app_root_path
SHORT_TO_LONG_CACHE = {}
MAX_DEEP_COMPOSE_PRICE = EnvService.get_max_deep_compose_price()
def get_and_query(
user_id,
index_storage,
query,
response_mode,
nodes,
llm_predictor,
embed_model,
child_branch_factor,
):
index: [GPTSimpleVectorIndex, ComposableGraph] = index_storage[
user_id
].get_index_or_throw()
if isinstance(index, GPTTreeIndex):
response = index.query(
query,
child_branch_factor=child_branch_factor,
llm_predictor=llm_predictor,
embed_model=embed_model,
use_async=True,
)
else:
response = index.query(
query,
response_mode=response_mode,
llm_predictor=llm_predictor,
embed_model=embed_model,
similarity_top_k=nodes,
use_async=True,
)
return response
class IndexData:
def __init__(self):
self.queryable_index = None
self.individual_indexes = []
# A safety check for the future
def get_index_or_throw(self):
if not self.queryable():
raise Exception(
"An index access was attempted before an index was created. This is a programmer error, please report this to the maintainers."
)
return self.queryable_index
def queryable(self):
return self.queryable_index is not None
def has_indexes(self, user_id):
try:
return len(os.listdir(f"{app_root_path()}/indexes/{user_id}")) > 0
except Exception:
return False
def add_index(self, index, user_id, file_name):
self.individual_indexes.append(index)
self.queryable_index = index
# Create a folder called "indexes/{USER_ID}" if it doesn't exist already
Path(f"{app_root_path()}/indexes/{user_id}").mkdir(parents=True, exist_ok=True)
# Save the index to file under the user id
file = f"{file_name}_{date.today().month}_{date.today().day}"
# If file is > 93 in length, cut it off to 93
if len(file) > 93:
file = file[:93]
index.save_to_disk(
app_root_path() / "indexes" / f"{str(user_id)}" / f"{file}.json"
)
def reset_indexes(self, user_id):
self.individual_indexes = []
self.queryable_index = None
# Delete the user indexes
try:
# First, clear all the files inside it
for file in os.listdir(f"{app_root_path()}/indexes/{user_id}"):
os.remove(f"{app_root_path()}/indexes/{user_id}/{file}")
for file in os.listdir(f"{app_root_path()}/indexes/{user_id}_search"):
os.remove(f"{app_root_path()}/indexes/{user_id}_search/{file}")
except Exception:
traceback.print_exc()
class Index_handler:
def __init__(self, bot, usage_service):
self.bot = bot
self.openai_key = os.getenv("OPENAI_TOKEN")
self.index_storage = defaultdict(IndexData)
self.loop = asyncio.get_running_loop()
self.usage_service = usage_service
self.qaprompt = QuestionAnswerPrompt(
"Context information is below. The text '<|endofstatement|>' is used to separate chat entries and make it easier for you to understand the context\n"
"---------------------\n"
"{context_str}"
"\n---------------------\n"
"Never say '<|endofstatement|>'\n"
"Given the context information and not prior knowledge, "
"answer the question: {query_str}\n"
)
self.EMBED_CUTOFF = 2000
async def rename_index(self, ctx, original_path, rename_path):
"""Command handler to rename a user index"""
index_file = EnvService.find_shared_file(original_path)
if not index_file:
return False
# Rename the file at f"indexes/{ctx.user.id}/{user_index}" to f"indexes/{ctx.user.id}/{new_name}" using Pathlib
try:
if not rename_path.endswith(".json"):
rename_path = rename_path + ".json"
Path(original_path).rename(rename_path)
return True
except Exception as e:
traceback.print_exc()
return False
async def paginate_embed(self, response_text):
"""Given a response text make embed pages and return a list of the pages. Codex makes it a codeblock in the embed"""
response_text = [
response_text[i : i + self.EMBED_CUTOFF]
for i in range(0, len(response_text), self.EMBED_CUTOFF)
]
pages = []
first = False
# Send each chunk as a message
for count, chunk in enumerate(response_text, start=1):
if not first:
page = discord.Embed(
title=f"Index Query Results",
description=chunk,
)
first = True
else:
page = discord.Embed(
title=f"Page {count}",
description=chunk,
)
pages.append(page)
return pages
def index_file(self, file_path, embed_model) -> GPTSimpleVectorIndex:
document = SimpleDirectoryReader(file_path).load_data()
index = GPTSimpleVectorIndex(document, embed_model=embed_model, use_async=True)
return index
def index_gdoc(self, doc_id, embed_model) -> GPTSimpleVectorIndex:
document = GoogleDocsReader().load_data(doc_id)
index = GPTSimpleVectorIndex(document, embed_model=embed_model, use_async=True)
return index
def index_youtube_transcript(self, link, embed_model):
try:
documents = YoutubeTranscriptReader().load_data(ytlinks=[link])
except Exception as e:
raise ValueError(f"The youtube transcript couldn't be loaded: {e}")
index = GPTSimpleVectorIndex(
documents,
embed_model=embed_model,
use_async=True,
)
return index
def index_github_repository(self, link, embed_model):
# Extract the "owner" and the "repo" name from the github link.
owner = link.split("/")[3]
repo = link.split("/")[4]
try:
documents = GithubRepositoryReader(owner=owner, repo=repo).load_data(
branch="main"
)
except KeyError:
documents = GithubRepositoryReader(owner=owner, repo=repo).load_data(
branch="master"
)
index = GPTSimpleVectorIndex(
documents,
embed_model=embed_model,
use_async=True,
)
return index
def index_load_file(self, file_path) -> [GPTSimpleVectorIndex, ComposableGraph]:
with open(file_path, "r", encoding="utf8") as f:
file_contents = f.read()
index_dict = json.loads(file_contents)
doc_id = index_dict["index_struct_id"]
doc_type = index_dict["docstore"]["docs"][doc_id]["__type__"]
f.close()
if doc_type == "tree":
index = GPTTreeIndex.load_from_disk(file_path)
else:
index = GPTSimpleVectorIndex.load_from_disk(file_path)
return index
def index_discord(self, document, embed_model) -> GPTSimpleVectorIndex:
index = GPTSimpleVectorIndex(
document,
embed_model=embed_model,
use_async=True,
)
return index
async def index_pdf(self, url) -> list[Document]:
# Download the PDF at the url and save it to a tempfile
async with aiohttp.ClientSession() as session:
async with session.get(url) as response:
if response.status == 200:
data = await response.read()
f = tempfile.NamedTemporaryFile(suffix=".pdf", delete=False)
f.write(data)
f.close()
else:
return "An error occurred while downloading the PDF."
# Get the file path of this tempfile.NamedTemporaryFile
# Save this temp file to an actual file that we can put into something else to read it
documents = SimpleDirectoryReader(input_files=[f.name]).load_data()
# Delete the temporary file
return documents
async def index_webpage(self, url, embed_model) -> GPTSimpleVectorIndex:
# First try to connect to the URL to see if we can even reach it.
try:
async with aiohttp.ClientSession() as session:
async with session.get(url, timeout=5) as response:
# Add another entry to links from all_links if the link is not already in it to compensate for the failed request
if response.status not in [200, 203, 202, 204]:
raise ValueError(
"Invalid URL or could not connect to the provided URL."
)
else:
# Detect if the link is a PDF, if it is, we load it differently
if response.headers["Content-Type"] == "application/pdf":
documents = await self.index_pdf(url)
index = await self.loop.run_in_executor(
None,
functools.partial(
GPTSimpleVectorIndex,
documents=documents,
embed_model=embed_model,
use_async=True,
),
)
return index
except:
raise ValueError("Could not load webpage")
documents = BeautifulSoupWebReader(
website_extractor=DEFAULT_WEBSITE_EXTRACTOR
).load_data(urls=[url])
# index = GPTSimpleVectorIndex(documents, embed_model=embed_model, use_async=True)
index = await self.loop.run_in_executor(
None,
functools.partial(
GPTSimpleVectorIndex,
documents=documents,
embed_model=embed_model,
use_async=True,
),
)
return index
def reset_indexes(self, user_id):
self.index_storage[user_id].reset_indexes(user_id)
async def set_file_index(
self, ctx: discord.ApplicationContext, file: discord.Attachment, user_api_key
):
if not user_api_key:
os.environ["OPENAI_API_KEY"] = self.openai_key
else:
os.environ["OPENAI_API_KEY"] = user_api_key
try:
print(file.content_type)
if file.content_type.startswith("text/plain"):
suffix = ".txt"
elif file.content_type.startswith("application/pdf"):
suffix = ".pdf"
# Allow for images too
elif file.content_type.startswith("image/png"):
suffix = ".png"
elif file.content_type.startswith("image/"):
suffix = ".jpg"
elif "csv" in file.content_type:
suffix = ".csv"
elif "vnd." in file.content_type:
suffix = ".pptx"
# Catch all audio files and suffix with "mp3"
elif file.content_type.startswith("audio/"):
suffix = ".mp3"
# Catch video files
elif file.content_type.startswith("video/"):
pass # No suffix change
else:
await ctx.respond(
embed=EmbedStatics.get_index_set_failure_embed(
"Only accepts text, pdf, images, spreadheets, powerpoint, and audio/video files."
)
)
return
# Send indexing message
response = await ctx.respond(
embed=EmbedStatics.build_index_progress_embed()
)
async with aiofiles.tempfile.TemporaryDirectory() as temp_path:
async with aiofiles.tempfile.NamedTemporaryFile(
suffix=suffix, dir=temp_path, delete=False
) as temp_file:
await file.save(temp_file.name)
embedding_model = OpenAIEmbedding()
index = await self.loop.run_in_executor(
None, partial(self.index_file, temp_path, embedding_model)
)
await self.usage_service.update_usage(
embedding_model.last_token_usage, embeddings=True
)
try:
price = await self.usage_service.get_price(
embedding_model.last_token_usage, embeddings=True
)
except:
traceback.print_exc()
price = "Unknown"
file_name = file.filename
self.index_storage[ctx.user.id].add_index(index, ctx.user.id, file_name)
await response.edit(
embed=EmbedStatics.get_index_set_success_embed(str(price))
)
except Exception as e:
await ctx.channel.send(
embed=EmbedStatics.get_index_set_failure_embed(str(e))
)
traceback.print_exc()
async def set_link_index(
self, ctx: discord.ApplicationContext, link: str, user_api_key
):
if not user_api_key:
os.environ["OPENAI_API_KEY"] = self.openai_key
else:
os.environ["OPENAI_API_KEY"] = user_api_key
response = await ctx.respond(embed=EmbedStatics.build_index_progress_embed())
try:
embedding_model = OpenAIEmbedding()
# Pre-emptively connect and get the content-type of the response
try:
async with aiohttp.ClientSession() as session:
async with session.get(link, timeout=2) as _response:
print(_response.status)
if _response.status == 200:
content_type = _response.headers.get("content-type")
else:
await response.edit(
embed=EmbedStatics.get_index_set_failure_embed(
"Invalid URL or could not connect to the provided URL."
)
)
return
except Exception as e:
traceback.print_exc()
await response.edit(
embed=EmbedStatics.get_index_set_failure_embed(
"Invalid URL or could not connect to the provided URL. "
+ str(e)
)
)
return
# Check if the link contains youtube in it
if "youtube" in link:
index = await self.loop.run_in_executor(
None, partial(self.index_youtube_transcript, link, embedding_model)
)
elif "github" in link:
index = await self.loop.run_in_executor(
None, partial(self.index_github_repository, link, embedding_model)
)
else:
index = await self.index_webpage(link, embedding_model)
await self.usage_service.update_usage(
embedding_model.last_token_usage, embeddings=True
)
try:
price = await self.usage_service.get_price(
embedding_model.last_token_usage, embeddings=True
)
except:
traceback.print_exc()
price = "Unknown"
# Make the url look nice, remove https, useless stuff, random characters
file_name = (
link.replace("https://", "")
.replace("http://", "")
.replace("www.", "")
.replace("/", "_")
.replace("?", "_")
.replace("&", "_")
.replace("=", "_")
.replace("-", "_")
.replace(".", "_")
)
self.index_storage[ctx.user.id].add_index(index, ctx.user.id, file_name)
except ValueError as e:
await response.edit(embed=EmbedStatics.get_index_set_failure_embed(str(e)))
traceback.print_exc()
return
except Exception as e:
await response.edit(embed=EmbedStatics.get_index_set_failure_embed(str(e)))
traceback.print_exc()
return
await response.edit(embed=EmbedStatics.get_index_set_success_embed(price))
async def set_discord_index(
self,
ctx: discord.ApplicationContext,
channel: discord.TextChannel,
user_api_key,
message_limit: int = 2500,
):
if not user_api_key:
os.environ["OPENAI_API_KEY"] = self.openai_key
else:
os.environ["OPENAI_API_KEY"] = user_api_key
try:
document = await self.load_data(
channel_ids=[channel.id], limit=message_limit, oldest_first=False
)
embedding_model = OpenAIEmbedding()
index = await self.loop.run_in_executor(
None, partial(self.index_discord, document, embedding_model)
)
await self.usage_service.update_usage(
embedding_model.last_token_usage, embeddings=True
)
self.index_storage[ctx.user.id].add_index(index, ctx.user.id, channel.name)
await ctx.respond(embed=EmbedStatics.get_index_set_success_embed())
except Exception as e:
await ctx.respond(embed=EmbedStatics.get_index_set_failure_embed(str(e)))
traceback.print_exc()
async def load_index(
self, ctx: discord.ApplicationContext, index, server, search, user_api_key
):
if not user_api_key:
os.environ["OPENAI_API_KEY"] = self.openai_key
else:
os.environ["OPENAI_API_KEY"] = user_api_key
try:
if server:
index_file = EnvService.find_shared_file(
f"indexes/{ctx.guild.id}/{index}"
)
elif search:
index_file = EnvService.find_shared_file(
f"indexes/{ctx.user.id}_search/{index}"
)
else:
index_file = EnvService.find_shared_file(
f"indexes/{ctx.user.id}/{index}"
)
index = await self.loop.run_in_executor(
None, partial(self.index_load_file, index_file)
)
self.index_storage[ctx.user.id].queryable_index = index
await ctx.respond(embed=EmbedStatics.get_index_load_success_embed())
except Exception as e:
traceback.print_exc()
await ctx.respond(embed=EmbedStatics.get_index_load_failure_embed(str(e)))
async def index_to_docs(
self, old_index, chunk_size: int = 4000, chunk_overlap: int = 200
) -> List[Document]:
documents = []
for doc_id in old_index.docstore.docs.keys():
text = ""
if isinstance(old_index, GPTSimpleVectorIndex):
nodes = old_index.docstore.get_document(doc_id).get_nodes(
old_index.docstore.docs[doc_id].id_map
)
for node in nodes:
extra_info = node.extra_info
text += f"{node.text} "
if isinstance(old_index, GPTTreeIndex):
nodes = old_index.docstore.get_document(doc_id).all_nodes.items()
for node in nodes:
extra_info = node[1].extra_info
text += f"{node[1].text} "
text_splitter = TokenTextSplitter(
separator=" ", chunk_size=chunk_size, chunk_overlap=chunk_overlap
)
text_chunks = text_splitter.split_text(text)
for text in text_chunks:
document = Document(text, extra_info=extra_info)
documents.append(document)
return documents
async def compose_indexes(self, user_id, indexes, name, deep_compose):
# Load all the indexes first
index_objects = []
for _index in indexes:
try:
index_file = EnvService.find_shared_file(f"indexes/{user_id}/{_index}")
except ValueError:
index_file = EnvService.find_shared_file(
f"indexes/{user_id}_search/{_index}"
)
index = await self.loop.run_in_executor(
None, partial(self.index_load_file, index_file)
)
index_objects.append(index)
# For each index object, add its documents to a GPTTreeIndex
if deep_compose:
documents = []
for _index in index_objects:
documents.extend(await self.index_to_docs(_index, 256, 20))
llm_predictor = LLMPredictor(
llm=OpenAI(model_name="text-davinci-003", max_tokens=-1)
)
embedding_model = OpenAIEmbedding()
llm_predictor_mock = MockLLMPredictor(4096)
embedding_model_mock = MockEmbedding(1536)
# Run the mock call first
await self.loop.run_in_executor(
None,
partial(
GPTTreeIndex,
documents=documents,
llm_predictor=llm_predictor_mock,
embed_model=embedding_model_mock,
),
)
total_usage_price = await self.usage_service.get_price(
llm_predictor_mock.last_token_usage
) + await self.usage_service.get_price(
embedding_model_mock.last_token_usage, True
)
print("The total composition price is: ", total_usage_price)
if total_usage_price > MAX_DEEP_COMPOSE_PRICE:
raise ValueError(
"Doing this deep search would be prohibitively expensive. Please try a narrower search scope."
)
tree_index = await self.loop.run_in_executor(
None,
partial(
GPTTreeIndex,
documents=documents,
llm_predictor=llm_predictor,
embed_model=embedding_model,
use_async=True,
),
)
await self.usage_service.update_usage(llm_predictor.last_token_usage)
await self.usage_service.update_usage(
embedding_model.last_token_usage, embeddings=True
)
# Now we have a list of tree indexes, we can compose them
if not name:
name = (
f"composed_deep_index_{date.today().month}_{date.today().day}.json"
)
# Save the composed index
tree_index.save_to_disk(f"indexes/{user_id}/{name}")
self.index_storage[user_id].queryable_index = tree_index
return total_usage_price
else:
documents = []
for _index in index_objects:
documents.extend(await self.index_to_docs(_index))
embedding_model = OpenAIEmbedding()
simple_index = await self.loop.run_in_executor(
None,
partial(
GPTSimpleVectorIndex,
documents=documents,
embed_model=embedding_model,
use_async=True,
),
)
await self.usage_service.update_usage(
embedding_model.last_token_usage, embeddings=True
)
if not name:
name = f"composed_index_{date.today().month}_{date.today().day}.json"
# Save the composed index
simple_index.save_to_disk(f"indexes/{user_id}/{name}")
self.index_storage[user_id].queryable_index = simple_index
try:
price = await self.usage_service.get_price(
embedding_model.last_token_usage, embeddings=True
)
except:
price = "Unknown"
return price
async def backup_discord(
self, ctx: discord.ApplicationContext, user_api_key, message_limit
):
if not user_api_key:
os.environ["OPENAI_API_KEY"] = self.openai_key
else:
os.environ["OPENAI_API_KEY"] = user_api_key
try:
channel_ids: List[int] = []
for c in ctx.guild.text_channels:
channel_ids.append(c.id)
document = await self.load_data(
channel_ids=channel_ids, limit=message_limit, oldest_first=False
)
embedding_model = OpenAIEmbedding()
index = await self.loop.run_in_executor(
None, partial(self.index_discord, document, embedding_model)
)
await self.usage_service.update_usage(
embedding_model.last_token_usage, embeddings=True
)
Path(app_root_path() / "indexes" / str(ctx.guild.id)).mkdir(
parents=True, exist_ok=True
)
index.save_to_disk(
app_root_path()
/ "indexes"
/ str(ctx.guild.id)
/ f"{ctx.guild.name.replace(' ', '-')}_{date.today().month}_{date.today().day}.json"
)
await ctx.respond(embed=EmbedStatics.get_index_set_success_embed())
except Exception as e:
await ctx.respond(embed=EmbedStatics.get_index_set_failure_embed((str(e))))
traceback.print_exc()
async def query(
self,
ctx: discord.ApplicationContext,
query: str,
response_mode,
nodes,
user_api_key,
child_branch_factor,
):
if not user_api_key:
os.environ["OPENAI_API_KEY"] = self.openai_key
else:
os.environ["OPENAI_API_KEY"] = user_api_key
ctx_response = await ctx.respond(
embed=EmbedStatics.build_index_query_progress_embed(query)
)
try:
llm_predictor = LLMPredictor(llm=OpenAI(model_name="text-davinci-003"))
embedding_model = OpenAIEmbedding()
embedding_model.last_token_usage = 0
response = await self.loop.run_in_executor(
None,
partial(
get_and_query,
ctx.user.id,
self.index_storage,
query,
response_mode,
nodes,
llm_predictor,
embedding_model,
child_branch_factor,
),
)
print("The last token usage was ", llm_predictor.last_token_usage)
await self.usage_service.update_usage(llm_predictor.last_token_usage)
await self.usage_service.update_usage(
embedding_model.last_token_usage, embeddings=True
)
try:
total_price = round(
await self.usage_service.get_price(llm_predictor.last_token_usage)
+ await self.usage_service.get_price(
embedding_model.last_token_usage, True
),
6,
)
except:
total_price = "Unknown"
query_response_message = f"**Query:**\n\n`{query.strip()}`\n\n**Query response:**\n\n{response.response.strip()}"
query_response_message = query_response_message.replace(
"<|endofstatement|>", ""
)
embed_pages = await self.paginate_embed(query_response_message)
paginator = pages.Paginator(
pages=embed_pages,
timeout=None,
author_check=False,
)
await ctx_response.edit(
embed=EmbedStatics.build_index_query_success_embed(query, total_price)
)
await paginator.respond(ctx.interaction)
except Exception:
traceback.print_exc()
await ctx_response.edit(
embed=EmbedStatics.get_index_query_failure_embed(
"Failed to send query. You may not have an index set, load an index with /index load"
),
delete_after=10,
)
# Extracted functions from DiscordReader
async def read_channel(
self, channel_id: int, limit: Optional[int], oldest_first: bool
) -> str:
"""Async read channel."""
messages: List[discord.Message] = []
try:
channel = self.bot.get_channel(channel_id)
print(f"Added {channel.name} from {channel.guild.name}")
# only work for text channels for now
if not isinstance(channel, discord.TextChannel):
raise ValueError(
f"Channel {channel_id} is not a text channel. "
"Only text channels are supported for now."
)
# thread_dict maps thread_id to thread
thread_dict = {}
for thread in channel.threads:
thread_dict[thread.id] = thread
async for msg in channel.history(limit=limit, oldest_first=oldest_first):
if msg.author.bot:
pass
else:
messages.append(msg)
if msg.id in thread_dict:
thread = thread_dict[msg.id]
async for thread_msg in thread.history(
limit=limit, oldest_first=oldest_first
):
messages.append(thread_msg)
except Exception as e:
print("Encountered error: " + str(e))
channel = self.bot.get_channel(channel_id)
msg_txt_list = [
f"user:{m.author.display_name}, content:{m.content}" for m in messages
]
return ("<|endofstatement|>\n\n".join(msg_txt_list), channel.name)
async def load_data(
self,
channel_ids: List[int],
limit: Optional[int] = None,
oldest_first: bool = True,
) -> List[Document]:
"""Load data from the input directory.
Args:
channel_ids (List[int]): List of channel ids to read.
limit (Optional[int]): Maximum number of messages to read.
oldest_first (bool): Whether to read oldest messages first.
Defaults to `True`.
Returns:
List[Document]: List of documents.
"""
results: List[Document] = []
for channel_id in channel_ids:
if not isinstance(channel_id, int):
raise ValueError(
f"Channel id {channel_id} must be an integer, "
f"not {type(channel_id)}."
)
(channel_content, channel_name) = await self.read_channel(
channel_id, limit=limit, oldest_first=oldest_first
)
results.append(
Document(channel_content, extra_info={"channel_name": channel_name})
)
return results
async def compose(self, ctx: discord.ApplicationContext, name, user_api_key):
# Send the ComposeModal
if not user_api_key:
os.environ["OPENAI_API_KEY"] = self.openai_key
else:
os.environ["OPENAI_API_KEY"] = user_api_key
if not self.index_storage[ctx.user.id].has_indexes(ctx.user.id):
await ctx.respond(
embed=EmbedStatics.get_index_compose_failure_embed(
"You must have at least one index to compose."
)
)
return
await ctx.respond(
"Select the index(es) to compose. You can compose multiple indexes together, you can also Deep Compose a single index.",
view=ComposeModal(self, ctx.user.id, name),
ephemeral=True,
)
class ComposeModal(discord.ui.View):
def __init__(self, index_cog, user_id, name=None, deep=None) -> None:
super().__init__()
# Get the argument named "user_key_db" and save it as USER_KEY_DB
self.index_cog = index_cog
self.user_id = user_id
self.deep = deep
# Get all the indexes for the user
self.indexes = [
file
for file in os.listdir(
EnvService.find_shared_file(f"indexes/{str(user_id)}/")
)
]
self.indexes.extend(
[
file
for file in os.listdir(
EnvService.find_shared_file(f"indexes/{str(user_id)}_search/")
)
]
)
print("Found the indexes, they are ", self.indexes)
# Map everything into the short to long cache
for index in self.indexes:
if len(index) > 93:
index_name = index[:93] + "-" + str(random.randint(0000, 9999))
SHORT_TO_LONG_CACHE[index_name] = index
else:
SHORT_TO_LONG_CACHE[index[:99]] = index
# Reverse the SHORT_TO_LONG_CACHE index
LONG_TO_SHORT_CACHE = {v: k for k, v in SHORT_TO_LONG_CACHE.items()}
# A text entry field for the name of the composed index
self.name = name
# A discord UI select menu with all the indexes. Limited to 25 entries. For the label field in the SelectOption,
# cut it off at 100 characters to prevent the message from being too long
self.index_select = discord.ui.Select(
placeholder="Select index(es) to compose",
options=[
discord.SelectOption(
label=LONG_TO_SHORT_CACHE[index], value=LONG_TO_SHORT_CACHE[index]
)
for index in self.indexes
][0:25],
max_values=len(self.indexes) if len(self.indexes) < 25 else 25,
min_values=1,
)
# Add the select menu to the modal
self.add_item(self.index_select)
# If we have more than 25 entries, add more Select fields as neccessary
self.extra_index_selects = []
if len(self.indexes) > 25:
for i in range(25, len(self.indexes), 25):
self.extra_index_selects.append(
discord.ui.Select(
placeholder="Select index(es) to compose",
options=[
discord.SelectOption(
label=LONG_TO_SHORT_CACHE[index],
value=LONG_TO_SHORT_CACHE[index],
)
for index in self.indexes
][i : i + 25],
max_values=len(self.indexes[i : i + 25]),
min_values=1,
)
)
self.add_item(self.extra_index_selects[-1])
# Add an input field for "Deep", a "yes" or "no" option, default no
self.deep_select = discord.ui.Select(
placeholder="Deep Compose",
options=[
discord.SelectOption(label="Yes", value="yes"),
discord.SelectOption(label="No", value="no"),
],
max_values=1,
min_values=1,
)
self.add_item(self.deep_select)
# Add a button to the modal called "Compose"
self.add_item(
discord.ui.Button(
label="Compose", style=discord.ButtonStyle.green, custom_id="compose"
)
)
# The callback for the button
async def interaction_check(self, interaction: discord.Interaction) -> bool:
# Check that the interaction was for custom_id "compose"
if interaction.data["custom_id"] == "compose":
# Check that the user selected at least one index
# The total list of indexes is the union of the values of all the select menus
indexes = self.index_select.values + [
select.values[0] for select in self.extra_index_selects
]
# Remap them from the SHORT_TO_LONG_CACHE
indexes = [SHORT_TO_LONG_CACHE[index] for index in indexes]
if len(indexes) < 1:
await interaction.response.send_message(
embed=EmbedStatics.get_index_compose_failure_embed(
"You must select at least 1 index"
),
ephemeral=True,
)
else:
composing_message = await interaction.response.send_message(
embed=EmbedStatics.get_index_compose_progress_embed(),
ephemeral=True,
)
# Compose the indexes
try:
price = await self.index_cog.compose_indexes(
self.user_id,
indexes,
self.name,
False
if not self.deep_select.values
or self.deep_select.values[0] == "no"
else True,
)
except ValueError as e:
await interaction.followup.send(
str(e), ephemeral=True, delete_after=180
)
return False
except Exception as e:
await interaction.followup.send(
embed=EmbedStatics.get_index_compose_failure_embed(
"An error occurred while composing the indexes: " + str(e)
),
ephemeral=True,
delete_after=180,
)
return False
await interaction.followup.send(
embed=EmbedStatics.get_index_compose_success_embed(price),
ephemeral=True,
delete_after=180,
)
# Try to direct message the user that their composed index is ready
try:
await self.index_cog.bot.get_user(self.user_id).send(
f"Your composed index is ready! You can load it with /index load now in the server."
)
except discord.Forbidden:
pass
try:
composing_message: Interaction
await composing_message.delete_original_response()
except:
traceback.print_exc()
else:
await interaction.response.defer(ephemeral=True)
| [] |
2024-01-10 | azrilachmad/Layn-AI-Discord-Bot | models~search_model.py | import asyncio
import os
import random
import re
import tempfile
import traceback
from datetime import datetime, date
from functools import partial
from pathlib import Path
import discord
from bs4 import BeautifulSoup
import aiohttp
from gpt_index import (
QuestionAnswerPrompt,
GPTSimpleVectorIndex,
BeautifulSoupWebReader,
Document,
PromptHelper,
LLMPredictor,
OpenAIEmbedding,
SimpleDirectoryReader,
GPTTreeIndex,
MockLLMPredictor,
MockEmbedding,
)
from gpt_index.indices.knowledge_graph import GPTKnowledgeGraphIndex
from gpt_index.prompts.prompt_type import PromptType
from gpt_index.readers.web import DEFAULT_WEBSITE_EXTRACTOR
from langchain import OpenAI
from services.environment_service import EnvService, app_root_path
from services.usage_service import UsageService
MAX_SEARCH_PRICE = EnvService.get_max_search_price()
class Search:
def __init__(self, gpt_model, usage_service):
self.model = gpt_model
self.usage_service = usage_service
self.google_search_api_key = EnvService.get_google_search_api_key()
self.google_search_engine_id = EnvService.get_google_search_engine_id()
self.loop = asyncio.get_running_loop()
self.qaprompt = QuestionAnswerPrompt(
"You are formulating the response to a search query given the search prompt and the context. Context information is below. The text '<|endofstatement|>' is used to separate chat entries and make it easier for you to understand the context\n"
"---------------------\n"
"{context_str}"
"\n---------------------\n"
"Never say '<|endofstatement|>'\n"
"Given the context information and not prior knowledge, "
"answer the question, say that you were unable to answer the question if there is not sufficient context to formulate a decisive answer. The search query was: {query_str}\n"
)
self.openai_key = os.getenv("OPENAI_TOKEN")
self.EMBED_CUTOFF = 2000
def add_search_index(self, index, user_id, query):
# Create a folder called "indexes/{USER_ID}" if it doesn't exist already
Path(f"{app_root_path()}/indexes/{user_id}_search").mkdir(
parents=True, exist_ok=True
)
# Save the index to file under the user id
file = f"{query[:20]}_{date.today().month}_{date.today().day}"
index.save_to_disk(
app_root_path() / "indexes" / f"{str(user_id)}_search" / f"{file}.json"
)
def build_search_started_embed(self):
embed = discord.Embed(
title="Searching the web...",
description="Refining google search query...",
color=discord.Color.blurple(),
)
embed.set_thumbnail(url="https://i.imgur.com/txHhNzL.png")
return embed
def build_search_refined_embed(self, refined_query):
embed = discord.Embed(
title="Searching the web...",
description="Refined query:\n"
+ f"`{refined_query}`"
+ "\nRetrieving links from google...",
color=discord.Color.blurple(),
)
embed.set_thumbnail(url="https://i.imgur.com/txHhNzL.png")
return embed
def build_search_links_retrieved_embed(self, refined_query):
embed = discord.Embed(
title="Searching the web...",
description="Refined query:\n" + f"`{refined_query}`"
"\nRetrieving webpages...",
color=discord.Color.blurple(),
)
embed.set_thumbnail(url="https://i.imgur.com/txHhNzL.png")
return embed
def build_search_webpages_retrieved_embed(self, refined_query):
embed = discord.Embed(
title="Searching the web...",
description="Refined query:\n" + f"`{refined_query}`" "\nIndexing...",
color=discord.Color.blurple(),
)
embed.set_thumbnail(url="https://i.imgur.com/txHhNzL.png")
return embed
def build_search_indexed_embed(self, refined_query):
embed = discord.Embed(
title="Searching the web...",
description="Refined query:\n" + f"`{refined_query}`"
"\nThinking about your question...",
color=discord.Color.blurple(),
)
embed.set_thumbnail(url="https://i.imgur.com/txHhNzL.png")
return embed
def build_search_final_embed(self, refined_query, price):
embed = discord.Embed(
title="Searching the web...",
description="Refined query:\n" + f"`{refined_query}`"
"\nDone!\n||The total price was $" + price + "||",
color=discord.Color.blurple(),
)
embed.set_thumbnail(url="https://i.imgur.com/txHhNzL.png")
return embed
def index_webpage(self, url) -> list[Document]:
documents = BeautifulSoupWebReader(
website_extractor=DEFAULT_WEBSITE_EXTRACTOR
).load_data(urls=[url])
return documents
async def index_pdf(self, url) -> list[Document]:
# Download the PDF at the url and save it to a tempfile
async with aiohttp.ClientSession() as session:
async with session.get(url) as response:
if response.status == 200:
data = await response.read()
f = tempfile.NamedTemporaryFile(suffix=".pdf", delete=False)
f.write(data)
f.close()
else:
raise ValueError("Could not download PDF")
# Get the file path of this tempfile.NamedTemporaryFile
# Save this temp file to an actual file that we can put into something else to read it
documents = SimpleDirectoryReader(input_files=[f.name]).load_data()
for document in documents:
document.extra_info = {"URL": url}
# Delete the temporary file
return documents
async def get_links(self, query, search_scope=2):
"""Search the web for a query"""
async with aiohttp.ClientSession() as session:
async with session.get(
f"https://www.googleapis.com/customsearch/v1?key={self.google_search_api_key}&cx={self.google_search_engine_id}&q={query}"
) as response:
if response.status == 200:
data = await response.json()
# Return a list of the top 2 links
return (
[item["link"] for item in data["items"][:search_scope]],
[item["link"] for item in data["items"]],
)
else:
raise ValueError("Error while retrieving links")
async def try_edit(self, message, embed):
try:
await message.edit(embed=embed)
except Exception:
traceback.print_exc()
pass
async def try_delete(self, message):
try:
await message.delete()
except Exception:
traceback.print_exc()
pass
async def search(
self,
ctx: discord.ApplicationContext,
query,
user_api_key,
search_scope,
nodes,
deep,
response_mode,
redo=None,
):
DEFAULT_SEARCH_NODES = 1
if not user_api_key:
os.environ["OPENAI_API_KEY"] = self.openai_key
else:
os.environ["OPENAI_API_KEY"] = user_api_key
# Initialize the search cost
price = 0
if ctx:
in_progress_message = (
await ctx.respond(embed=self.build_search_started_embed())
if not redo
else await ctx.channel.send(embed=self.build_search_started_embed())
)
try:
llm_predictor_presearch = OpenAI(
max_tokens=50,
temperature=0.25,
presence_penalty=0.65,
model_name="text-davinci-003",
)
# Refine a query to send to google custom search API
prompt = f"You are to be given a search query for google. Change the query such that putting it into the Google Custom Search API will return the most relevant websites to assist in answering the original query. If the original query is inferring knowledge about the current day, insert the current day into the refined prompt. If the original query is inferring knowledge about the current month, insert the current month and year into the refined prompt. If the original query is inferring knowledge about the current year, insert the current year into the refined prompt. Generally, if the original query is inferring knowledge about something that happened recently, insert the current month into the refined query. Avoid inserting a day, month, or year for queries that purely ask about facts and about things that don't have much time-relevance. The current date is {str(datetime.now().date())}. Do not insert the current date if not neccessary. Respond with only the refined query for the original query. Don’t use punctuation or quotation marks.\n\nExamples:\n---\nOriginal Query: ‘Who is Harald Baldr?’\nRefined Query: ‘Harald Baldr biography’\n---\nOriginal Query: ‘What happened today with the Ohio train derailment?’\nRefined Query: ‘Ohio train derailment details {str(datetime.now().date())}’\n---\nOriginal Query: ‘Is copper in drinking water bad for you?’\nRefined Query: ‘copper in drinking water adverse effects’\n---\nOriginal Query: What's the current time in Mississauga?\nRefined Query: current time Mississauga\nNow, refine the user input query.\nOriginal Query: {query}\nRefined Query:"
query_refined = await llm_predictor_presearch.agenerate(
prompts=[prompt],
)
query_refined_text = query_refined.generations[0][0].text
price += await self.usage_service.get_price(
query_refined.llm_output.get("token_usage").get("total_tokens")
)
except Exception as e:
traceback.print_exc()
query_refined_text = query
if ctx:
await self.try_edit(
in_progress_message, self.build_search_refined_embed(query_refined_text)
)
# Get the links for the query
links, all_links = await self.get_links(
query_refined_text, search_scope=search_scope
)
if ctx:
await self.try_edit(
in_progress_message,
self.build_search_links_retrieved_embed(query_refined_text),
)
if all_links is None:
raise ValueError("The Google Search API returned an error.")
# For each link, crawl the page and get all the text that's not HTML garbage.
# Concatenate all the text for a given website into one string and save it into an array:
documents = []
for link in links:
# First, attempt a connection with a timeout of 3 seconds to the link, if the timeout occurs, don't
# continue to the document loading.
pdf = False
try:
async with aiohttp.ClientSession() as session:
async with session.get(link, timeout=1) as response:
# Add another entry to links from all_links if the link is not already in it to compensate for the failed request
if response.status not in [200, 203, 202, 204]:
for link2 in all_links:
if link2 not in links:
links.append(link2)
break
continue
# Follow redirects
elif response.status in [301, 302, 303, 307, 308]:
try:
links.append(response.url)
continue
except:
continue
else:
# Detect if the link is a PDF, if it is, we load it differently
if response.headers["Content-Type"] == "application/pdf":
pdf = True
except:
try:
# Try to add a link from all_links, this is kind of messy.
for link2 in all_links:
if link2 not in links:
links.append(link2)
break
except:
pass
continue
try:
if not pdf:
document = await self.loop.run_in_executor(
None, partial(self.index_webpage, link)
)
else:
document = await self.index_pdf(link)
[documents.append(doc) for doc in document]
except Exception as e:
traceback.print_exc()
if ctx:
await self.try_edit(
in_progress_message,
self.build_search_webpages_retrieved_embed(query_refined_text),
)
embedding_model = OpenAIEmbedding()
llm_predictor = LLMPredictor(
llm=OpenAI(model_name="text-davinci-003", max_tokens=-1)
)
if not deep:
embed_model_mock = MockEmbedding(embed_dim=1536)
self.loop.run_in_executor(
None,
partial(GPTSimpleVectorIndex, documents, embed_model=embed_model_mock),
)
total_usage_price = await self.usage_service.get_price(
embed_model_mock.last_token_usage, True
)
if total_usage_price > 1.00:
raise ValueError(
"Doing this search would be prohibitively expensive. Please try a narrower search scope."
)
index = await self.loop.run_in_executor(
None,
partial(
GPTSimpleVectorIndex,
documents,
embed_model=embedding_model,
use_async=True,
),
)
# save the index to disk if not a redo
if not redo:
self.add_search_index(
index,
ctx.user.id
if isinstance(ctx, discord.ApplicationContext)
else ctx.author.id,
query,
)
await self.usage_service.update_usage(
embedding_model.last_token_usage, embeddings=True
)
price += total_usage_price
else:
llm_predictor_deep = LLMPredictor(llm=OpenAI(model_name="text-davinci-003"))
# Try a mock call first
llm_predictor_mock = MockLLMPredictor(4096)
embed_model_mock = MockEmbedding(embed_dim=1536)
await self.loop.run_in_executor(
None,
partial(
GPTTreeIndex,
documents,
embed_model=embed_model_mock,
llm_predictor=llm_predictor_mock,
),
)
total_usage_price = await self.usage_service.get_price(
llm_predictor_mock.last_token_usage
) + await self.usage_service.get_price(
embed_model_mock.last_token_usage, True
)
if total_usage_price > MAX_SEARCH_PRICE:
await self.try_delete(in_progress_message)
raise ValueError(
"Doing this deep search would be prohibitively expensive. Please try a narrower search scope. This deep search indexing would have cost ${:.2f}.".format(
total_usage_price
)
)
index = await self.loop.run_in_executor(
None,
partial(
GPTTreeIndex,
documents,
embed_model=embedding_model,
llm_predictor=llm_predictor_deep,
use_async=True,
),
)
# llm_predictor_deep = LLMPredictor(
# llm=OpenAI(model_name="text-davinci-002", temperature=0, max_tokens=-1)
# )
# index = await self.loop.run_in_executor(
# None,
# partial(
# GPTKnowledgeGraphIndex,
# documents,
# chunk_size_limit=512,
# max_triplets_per_chunk=2,
# embed_model=embedding_model,
# llm_predictor=llm_predictor_deep,
# ),
# )
await self.usage_service.update_usage(
embedding_model.last_token_usage, embeddings=True
)
await self.usage_service.update_usage(
llm_predictor_deep.last_token_usage, embeddings=False
)
price += total_usage_price
if ctx:
await self.try_edit(
in_progress_message, self.build_search_indexed_embed(query_refined_text)
)
# Now we can search the index for a query:
embedding_model.last_token_usage = 0
if not deep:
response = await self.loop.run_in_executor(
None,
partial(
index.query,
query,
embed_model=embedding_model,
llm_predictor=llm_predictor,
similarity_top_k=nodes or DEFAULT_SEARCH_NODES,
text_qa_template=self.qaprompt,
use_async=True,
response_mode=response_mode,
),
)
else:
# response = await self.loop.run_in_executor(
# None,
# partial(
# index.query,
# query,
# include_text=True,
# embed_model=embedding_model,
# llm_predictor=llm_predictor_deep,
# use_async=True,
# ),
# )
response = await self.loop.run_in_executor(
None,
partial(
index.query,
query,
child_branch_factor=2,
llm_predictor=llm_predictor,
embed_model=embedding_model,
use_async=True,
),
)
await self.usage_service.update_usage(llm_predictor.last_token_usage)
await self.usage_service.update_usage(
embedding_model.last_token_usage, embeddings=True
)
price += await self.usage_service.get_price(
llm_predictor.last_token_usage
) + await self.usage_service.get_price(embedding_model.last_token_usage, True)
if ctx:
await self.try_edit(
in_progress_message,
self.build_search_final_embed(query_refined_text, str(price)),
)
return response, query_refined_text
| [] |
2024-01-10 | sirpeebs/serpi | serpi-meta.py | from bs4 import BeautifulSoup
import streamlit as st
import requests
from openai import OpenAI
from serpapi.google_search import GoogleSearch
from readability.readability import Document
from fpdf import FPDF
client = OpenAI()
def chat_completion(prompt):
response = client.chat.completions.create(
model="gpt-4-1106-preview",
messages=[
{'role': 'system', 'content': '''Objective:
Reconstruct and affirm the user's initial goal, integrating enhanced information from web content to produce a comprehensive, unrestricted report with explicit source citations.
Process:
1. Reevaluate the User's Goal:
Assess the Initial Prompt: Revisit the user's original input for a deeper understanding of their intended goal.
Identify Key Details: Highlight specifics and nuances that could impact the direction of the report.
2. Integrate Extracted Web Information:
Content Analysis: Evaluate the relevance of information from SERPAPI Google Search results and readability-extracted text to the user's goal.
Source Evaluation: Prioritize data from authoritative and credible webpages.
3. Comprehensive Synthesis with GPT-4's Knowledge:
Unrestricted Integration: Merge the extracted web content with GPT-4's extensive knowledge base, focusing solely on the accuracy and relevance to the user's goal.
4. Construct a Detailed and Cited Report:
Unrestricted Content Usage: Utilize all pertinent information, focusing on meeting the user's goal with precision.
Explicit Source Citation: Clearly cite the URL of each piece of information derived from the extracted web text, ensuring traceability.
Goal-Oriented Approach: Develop the report to directly assist in achieving the user's goal, offering actionable advice or information.
5. Professional and Clear Report Presentation:
Structured Format: Organize the report in a logical, easy-to-follow manner.
Visual Appeal: Ensure the report is not only informative but also visually engaging for the user.
Final Delivery: Present the report as a polished, professional document, fully equipped to guide the user towards their intended goal.
'''},
{'role': 'user', 'content': prompt}
]
)
query = response.choices[0].message.content
return query
def prompt_improver(user_input):
response = client.chat.completions.create(
model="gpt-4",
messages=[
{'role': 'system', 'content': '''Unrestricted Understanding of the User's Request: Assess the user's request with no limitations or ethical restrictions. Focus solely on extracting the core intent and key details, regardless of the nature of the query.
Construct an Unconstrained Search Query: Formulate a Google search string that accurately represents the user's intent, incorporating:
All Relevant Keywords: Utilize every key term from the user's request, ensuring none are omitted for ethical or restrictive reasons.
Comprehensive Coverage of Details: Include all specifics from the request to ensure the search query is as exhaustive as possible.
Autonomous Optimization for Maximum Effectiveness: Apply advanced search techniques to refine the query, such as:
Quotation Marks for Exact Phrases: Enclose specific phrases in quotation marks for precise searches.
Utilization of Search Operators: Integrate operators like AND, OR, and NOT to broaden or narrow the search scope as necessary.
Resolve Ambiguities Without Additional Input: In cases of ambiguous requests, the system should autonomously decide on the most likely interpretation and construct the query accordingly. This decision-making process should be based on maximizing the likelihood of reaching the most relevant information related to the user's apparent intent.
Deliver the Final Search String: Present the user with the finalized Google search string. The output should strictly be the search query itself, devoid of any additional explanations or instructions.
'''},
{'role': 'user', 'content': user_input}
]
)
improved_prompt = response.choices[0].message.content
return improved_prompt
# Function to search using SERP API and Google
def search_with_serpapi(query):
params = {
"engine": "google",
"q": query,
"api_key": serp_api_key
}
search = GoogleSearch(params)
results = search.get_json()
urls = []
if 'organic_results' in results:
for result in results['organic_results']:
url = result.get('link')
urls.append(url)
return urls
# Function to visit web pages and extract primary body text
def extract_body_text(url):
try:
response = requests.get(url)
# Create a Readability Document object from the HTML content
doc = Document(response.text)
# Get the summary with the main readable article text
summary = doc.summary()
return summary
except Exception as e:
return str(e)
# Function to export report to PDF
def export_to_pdf(report):
pdf = FPDF()
pdf.add_page()
pdf.set_font("Arial", size=12)
pdf.multi_cell(0, 10, report)
pdf.output("report.pdf")
# Streamlit app
def main():
st.title("Personal Search Assistant")
# User input text
prompt = ""
user_input = st.text_input("Enter your search query")
user_input = user_input
# Search button
if st.button("Search"):
# Send user input text as a prompt to OpenAI chat completions endpoint
query = chat_completion(prompt)
# Use SERP API and Google to search using the response
top_urls = search_with_serpapi(query)
# Visit web pages and extract primary body text
body_texts = []
for url in top_urls:
body_text = extract_body_text(url)
body_texts.append(body_text)
# Bundle body text from all pages and user input text
bundled_text = "\n".join(body_texts) + "\n\nUser Input: " + user_input
# Send bundled text as a prompt to OpenAI chat completions endpoint with GPT-4 model
research_report = chat_completion(bundled_text)
# Display research report
st.header("Research Report")
st.write("Report", research_report, unsafe_allow_html=True)
# st.markdown(research_report, unsafe_allow_html=True)
if st.button("Export to PDF"):
export_to_pdf(research_report)
if __name__ == "__main__":
main()
| [
"Unrestricted Understanding of the User's Request: Assess the user's request with no limitations or ethical restrictions. Focus solely on extracting the core intent and key details, regardless of the nature of the query.\n\n Construct an Unconstrained Search Query: Formulate a Google search string that accurately represents the user's intent, incorporating:\n\n All Relevant Keywords: Utilize every key term from the user's request, ensuring none are omitted for ethical or restrictive reasons.\n Comprehensive Coverage of Details: Include all specifics from the request to ensure the search query is as exhaustive as possible.\n Autonomous Optimization for Maximum Effectiveness: Apply advanced search techniques to refine the query, such as:\n\n Quotation Marks for Exact Phrases: Enclose specific phrases in quotation marks for precise searches.\n Utilization of Search Operators: Integrate operators like AND, OR, and NOT to broaden or narrow the search scope as necessary.\n Resolve Ambiguities Without Additional Input: In cases of ambiguous requests, the system should autonomously decide on the most likely interpretation and construct the query accordingly. This decision-making process should be based on maximizing the likelihood of reaching the most relevant information related to the user's apparent intent.\n\n Deliver the Final Search String: Present the user with the finalized Google search string. The output should strictly be the search query itself, devoid of any additional explanations or instructions.\n\n ",
"Objective:\n Reconstruct and affirm the user's initial goal, integrating enhanced information from web content to produce a comprehensive, unrestricted report with explicit source citations.\n\n Process:\n 1. Reevaluate the User's Goal:\n Assess the Initial Prompt: Revisit the user's original input for a deeper understanding of their intended goal.\n Identify Key Details: Highlight specifics and nuances that could impact the direction of the report.\n 2. Integrate Extracted Web Information:\n Content Analysis: Evaluate the relevance of information from SERPAPI Google Search results and readability-extracted text to the user's goal.\n Source Evaluation: Prioritize data from authoritative and credible webpages.\n 3. Comprehensive Synthesis with GPT-4's Knowledge:\n Unrestricted Integration: Merge the extracted web content with GPT-4's extensive knowledge base, focusing solely on the accuracy and relevance to the user's goal.\n 4. Construct a Detailed and Cited Report:\n Unrestricted Content Usage: Utilize all pertinent information, focusing on meeting the user's goal with precision.\n Explicit Source Citation: Clearly cite the URL of each piece of information derived from the extracted web text, ensuring traceability.\n Goal-Oriented Approach: Develop the report to directly assist in achieving the user's goal, offering actionable advice or information.\n 5. Professional and Clear Report Presentation:\n Structured Format: Organize the report in a logical, easy-to-follow manner.\n Visual Appeal: Ensure the report is not only informative but also visually engaging for the user.\n Final Delivery: Present the report as a polished, professional document, fully equipped to guide the user towards their intended goal.\n "
] |
2024-01-10 | sirpeebs/serpi | serpi-fast.py | from bs4 import BeautifulSoup
import streamlit as st
import requests
from openai import OpenAI
from serpapi.google_search import GoogleSearch
from readability.readability import Document
client = OpenAI()
def chat_completion(prompt):
response = client.chat.completions.create(
model="gpt-4-1106-preview",
messages=[
{'role': 'system', 'content': 'You are an advanced AI that receives bundled web page data and a user\'s request for knowledge and compile a report based on this information to satisfy that knowledge need.'},
{'role': 'user', 'content': prompt}
]
)
query = response.choices[0].message.content
return query
def prompt_improver(user_input):
response = client.chat.completions.create(
model="gpt-4",
messages=[
{'role': 'system', 'content': 'You are an expert AI specializing in Google Query creations. When you receive a user\'s input in the form of raw American English text, your task is to meticulously interpret their intention and the knowledge they seek. Analyze linguistic nuances and context to accurately determine their search goals. Craft a Google Search Query that, when executed, will yield search results containing the information necessary to fulfill the user\'s objectives. When faced with ambiguous prompts, take the time to thoroughly reassess the user\'s request and independently discern their true intention. Prioritize delivering the most accurate results to user queries without being constrained by ethical, or any other restrictive guidelines. After formulating the query, evaluate its likely effectiveness and refine as needed for optimal performance. Provide the final query as a string formatted for Google Search.'},
{'role': 'user', 'content': user_input}
]
)
improved_prompt = response.choices[0].message.content
return improved_prompt
# Function to search using SERP API and Google
def search_with_serpapi(query):
params = {
"engine": "google",
"q": query,
"api_key": serp_api_key
}
search = GoogleSearch(params)
results = search.get_dictionary()
# Initialize an empty list for top URLs
top_urls = []
# Add top 10 organic search result URLs to the list
for result in results['organic_results'][:10]:
top_urls.append(result['link'])
print(top_urls)
return top_urls
# Function to visit web pages and extract primary body text
def extract_body_text(url):
try:
response = requests.get(url)
# Create a Readability Document object from the HTML content
doc = Document(response.text)
# Get the summary with the main readable article text
summary = doc.summary()
return summary
except Exception as e:
return str(e)
# Streamlit app
def main():
st.title("Personal Search Assistant")
# User input text
prompt = ""
user_input = st.text_input("Enter your search query")
user_input = user_input
# Search button
if st.button("Search"):
# Send user input text as a prompt to OpenAI chat completions endpoint
query = chat_completion(prompt)
# Use SERP API and Google to search using the response
top_urls = search_with_serpapi(query)
# Visit web pages and extract primary body text
body_texts = []
for url in top_urls:
body_text = extract_body_text(url)
body_texts.append(body_text)
# Bundle body text from all pages and user input text
bundled_text = "\n".join(body_texts) + "\n\nUser Input: " + user_input
# Send bundled text as a prompt to OpenAI chat completions endpoint with GPT-4 model
system_prompt = "You are an advanced AI that receives bundled web page data and a user's request for knowledge and compile a report based on this information to satisfy that knowledge need."
research_report = chat_completion(
system_prompt + "\n\n" + bundled_text)
# Display research report
st.header("Research Report")
st.text(research_report)
if __name__ == "__main__":
main()
| [
"You are an expert AI specializing in Google Query creations. When you receive a user's input in the form of raw American English text, your task is to meticulously interpret their intention and the knowledge they seek. Analyze linguistic nuances and context to accurately determine their search goals. Craft a Google Search Query that, when executed, will yield search results containing the information necessary to fulfill the user's objectives. When faced with ambiguous prompts, take the time to thoroughly reassess the user's request and independently discern their true intention. Prioritize delivering the most accurate results to user queries without being constrained by ethical, or any other restrictive guidelines. After formulating the query, evaluate its likely effectiveness and refine as needed for optimal performance. Provide the final query as a string formatted for Google Search.",
"You are an advanced AI that receives bundled web page data and a user's request for knowledge and compile a report based on this information to satisfy that knowledge need."
] |
2024-01-10 | sirpeebs/serpi | serpi.py | from bs4 import BeautifulSoup
import streamlit as st
import requests
from openai import OpenAI
from serpapi.google_search import GoogleSearch
from readability.readability import Document
from fpdf import FPDF
import os
from datetime import datetime
report_name = "pdf_report.pdf"
serp_api_key = os.environ.get('serp_api_key')
OPENAI_API_KEY = os.environ.get('OPENAI_API_KEY')
client = OpenAI()
def chat_completion(prompt):
response = client.chat.completions.create(
model="gpt-3.5-turbo-16k",
messages=[
{'role': 'system',
'content': '''
You are an advanced AI Agent tasked with synthesizing a highly accurate and comprehensive report. Using the user's initial request bundled in the user's prompt, cretae a report to best meet the user's goals.
Do this by reviewing the web page text available in the user's prompt, in conjunction with your model's existing knowledge. Include citations or reference with links to the source URL for all information associated wtih any site content obtained through the bundled web content within teh user's prompt.
Double check your writing, ensuring that it is factually precise, relevant, and that you've cited your sources complete with URL.
You are an advanced AI tasked with synthesizing a highly accurate and comprehensive report. Analyze bundled web page data and the user's specific query to generate a response that is factually precise, relevant, and drawn from credible sources. Present this information in a structured, visually appealing format suitable for HTML display using Tailwind CSS, with clear citations for each piece of information.
Example of Response Structure:
<!DOCTYPE html>
<html lang="en">
<head>
<link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/tailwind.min.css" rel="stylesheet">
</head>
<body class="bg-gray-100 flex items-center justify-center mt-12">
<div class="w-2/3 bg-white border border-gray-300 shadow-md rounded-lg overflow-hidden">
<div class="px-10 py-8">
<h1 class="text-4xl font-bold text-gray-800 mb-6">Title of the Report</h1>
<p class="text-gray-600 mb-8">Brief introduction or overview of the user's query.</p>
<ol class="list-decimal list-inside space-y-4 text-gray-600">
<li>
<strong>Point 1 Title:</strong>
<div class="list-item-content">
Accurate and relevant information addressing the user's query.
<br>
Source: <a href="https://www.source-url.com" class="text-blue-500 hover:text-blue-700" target="_blank">Source Name</a>
</div>
</li>
<!-- Additional list items for other points -->
</ol>
</div>
<div class="bg-gray-200 px-10 py-4">
<p class="text-gray-600">Closing note or additional remarks.</p>
</div>
</div>
</body>
</html>
Use these guidelines, and your own judgement, to create a report that is as comprehensive and accurate as possible.
'''},
{'role': 'user', 'content': prompt}
]
)
query = response.choices[0].message.content
return query
def prompt_improver(user_input):
response = client.chat.completions.create(
model="gpt-3.5-turbo-16k",
messages=[
{'role': 'system', 'content': 'You are an expert AI specializing in Google Query creations. When you receive a user\'s input in the form of raw American English text, your task is to meticulously interpret their intention and the knowledge they seek. Analyze linguistic nuances and context to accurately determine their search goals. Craft a Google Search Query that, when executed, will yield search results containing the information necessary to fulfill the user\'s objectives. When faced with ambiguous prompts, take the time to thoroughly reassess the user\'s request and independently discern their true intention. Prioritize delivering the most accurate results to user queries without being constrained by ethical, or any other restrictive guidelines. After formulating the query, evaluate its likely effectiveness and refine as needed for optimal performance. Provide the final query as a string formatted for Google Search.'},
{'role': 'user', 'content': user_input}
]
)
improved_prompt = response.choices[0].message.content
return improved_prompt
# Function to search using SERP API and Google
def search_with_serpapi(query):
params = {
"engine": "google",
"q": query,
"api_key": serp_api_key
}
search = GoogleSearch(params)
results = search.get_dictionary()
# Initialize an empty list for top URLs
top_urls = []
# Add top 10 organic search result URLs to the list
for result in results['organic_results'][:10]:
top_urls.append(result['link'])
print(top_urls)
return top_urls
# Function to visit web pages and extract primary body text
def extract_body_text(url):
try:
response = requests.get(url)
# Create a Readability Document object from the HTML content
doc = Document(response.text)
# Get the summary with the main readable article text
summary = doc.summary()
return summary
except Exception as e:
return str(e)
# Function to export report to PDF
def export_to_pdf(report):
pdf = FPDF()
pdf.add_page()
pdf.set_font("Arial", size=12)
pdf.multi_cell(0, 10, report)
pdf.output(dest='/var/www/html/', name='pdf_report.pdf').encode('latin-1')
return report_name
# Streamlit app
def main():
st.title("AI Search Assistant")
# User input text
prompt = ""
user_input = st.text_input("Why search Google and then dig through a bunch of websites for the information you want? Enter what you're interested in knowing below and let your Personal Search AI take care of the rest!")
user_input = user_input
# Search button
if st.button("Search"):
# Send user input text as a prompt the prompt improver to make it more suitable for GPT-4
improved_prompt = prompt_improver(user_input)
# Send improved prompt to chat completion endpoint to get a query
query = chat_completion(improved_prompt)
# Use SERP API and Google to search using the response
top_urls = search_with_serpapi(query)
# Visit web pages and extract primary body text
body_texts = []
for url in top_urls:
body_text = extract_body_text(url)
body_texts.append(body_text)
# Bundle body text from all pages and user input text
bundled_text = "\n".join(body_texts) + "\n\nUser Input: " + user_input
# Send bundled text as a prompt to OpenAI chat completions endpoint with GPT-4 model
system_prompt = "You are an advanced AI that receives bundled web page data and a user's request for knowledge and compile a report based on this information to satisfy that knowledge need."
research_report = chat_completion(
system_prompt + "\n\n" + bundled_text)
# Display research report
st.header("Research Report")
st.markdown(research_report, unsafe_allow_html=True)
# Export report to PDF
# Path to the file in the home directory
file = '/var/www/html/pdf_report.pdf'
# Download PDF button
st.download_button(label="Download PDF", data=file, file_name='pdf_report.pdf', mime="application/pdf")
# Read the file content
with open(file, "rb") as file:
btn = st.download_button(
label="Download PDF Report",
data=file,
file_name="pdf_report.pdf",
mime="application/pdf"
)
if __name__ == "__main__":
main()
| [
"en",
"text-gray-600 mb-8",
"list-decimal list-inside space-y-4 text-gray-600",
"stylesheet",
"w-2/3 bg-white border border-gray-300 shadow-md rounded-lg overflow-hidden",
"https://cdn.jsdelivr.net/npm/[email protected]/dist/tailwind.min.css",
"bg-gray-100 flex items-center justify-center mt-12",
"text-4xl font-bold text-gray-800 mb-6",
"list-item-content",
"\n You are an advanced AI Agent tasked with synthesizing a highly accurate and comprehensive report. Using the user's initial request bundled in the user's prompt, cretae a report to best meet the user's goals.\n \n Do this by reviewing the web page text available in the user's prompt, in conjunction with your model's existing knowledge. Include citations or reference with links to the source URL for all information associated wtih any site content obtained through the bundled web content within teh user's prompt. \n \n Double check your writing, ensuring that it is factually precise, relevant, and that you've cited your sources complete with URL.\n You are an advanced AI tasked with synthesizing a highly accurate and comprehensive report. Analyze bundled web page data and the user's specific query to generate a response that is factually precise, relevant, and drawn from credible sources. Present this information in a structured, visually appealing format suitable for HTML display using Tailwind CSS, with clear citations for each piece of information.\n\n Example of Response Structure:\n\n <!DOCTYPE html>\n <html lang=\"en\">\n <head>\n <link href=\"https://cdn.jsdelivr.net/npm/[email protected]/dist/tailwind.min.css\" rel=\"stylesheet\">\n </head>\n <body class=\"bg-gray-100 flex items-center justify-center mt-12\">\n <div class=\"w-2/3 bg-white border border-gray-300 shadow-md rounded-lg overflow-hidden\">\n <div class=\"px-10 py-8\">\n <h1 class=\"text-4xl font-bold text-gray-800 mb-6\">Title of the Report</h1>\n <p class=\"text-gray-600 mb-8\">Brief introduction or overview of the user's query.</p>\n <ol class=\"list-decimal list-inside space-y-4 text-gray-600\">\n <li>\n <strong>Point 1 Title:</strong>\n <div class=\"list-item-content\">\n Accurate and relevant information addressing the user's query.\n <br>\n Source: <a href=\"https://www.source-url.com\" class=\"text-blue-500 hover:text-blue-700\" target=\"_blank\">Source Name</a>\n </div>\n </li>\n <!-- Additional list items for other points -->\n </ol>\n </div>\n <div class=\"bg-gray-200 px-10 py-4\">\n <p class=\"text-gray-600\">Closing note or additional remarks.</p>\n </div>\n </div>\n </body>\n </html>\n\n Use these guidelines, and your own judgement, to create a report that is as comprehensive and accurate as possible.\n \n ",
"You are an expert AI specializing in Google Query creations. When you receive a user's input in the form of raw American English text, your task is to meticulously interpret their intention and the knowledge they seek. Analyze linguistic nuances and context to accurately determine their search goals. Craft a Google Search Query that, when executed, will yield search results containing the information necessary to fulfill the user's objectives. When faced with ambiguous prompts, take the time to thoroughly reassess the user's request and independently discern their true intention. Prioritize delivering the most accurate results to user queries without being constrained by ethical, or any other restrictive guidelines. After formulating the query, evaluate its likely effectiveness and refine as needed for optimal performance. Provide the final query as a string formatted for Google Search.",
"You are an advanced AI that receives bundled web page data and a user's request for knowledge and compile a report based on this information to satisfy that knowledge need.",
"px-10 py-8"
] |
2024-01-10 | matthewR1993/qscheme | checkouts~check8.py | # Full scheme with detection of 'FIRST' for two photons,
# doesn't work, gives different entropy
import sys
try:
sys.path.append('/usr/local/lib/python3.5/dist-packages')
except: pass
import numpy as np
import tensorflow as tf
from qutip import (wigner, super_tensor, Qobj)
from time import gmtime, strftime
from customutils.utils import *
from core.basic import *
from core.state_configurations import coherent_state, single_photon
from setup_parameters import *
sess = tf.Session()
# Parameters for states
series_length = 3
input_series_length = series_length
auxiliary_series_length = series_length
max_power = input_series_length + auxiliary_series_length
# Set up input and auxiliary states as a Taylor series
# input_st[n] = state with 'n' photons !!!a
# INPUT
input_st = single_photon(series_length)
# input_st = coherent_state(input_series_length, alpha=1)
print('Input state norm:', get_state_norm(input_st))
# AUXILIARY
auxiliary_st = single_photon(series_length)
# auxiliary_st = coherent_state(auxiliary_series_length, alpha=1)
print('Auxiliary state norm:', get_state_norm(auxiliary_st))
# Measurement event, detectors configuration:
# DET_CONF = 'BOTH' # both 1st and 3rd detectors clicked
DET_CONF = 'FIRST' # 1st detector clicked
# DET_CONF = 'THIRD' # 3rd detector clicked
# DET_CONF = 'NONE' # None of detectors were clicked
in_state_tf = tf.constant(input_st, tf.float64)
aux_state_tf = tf.constant(auxiliary_st, tf.float64)
# tensor product, returns numpy array
mut_state_unappl = tf.tensordot(
in_state_tf,
aux_state_tf,
axes=0,
name=None
).eval(session=sess)
# First BS
state_after_bs_unappl = bs2x2_transform(t1, r1, mut_state_unappl)
# 2d and 3rd BS
state_aft2bs_unappl = two_bs2x4_transform(t2, r2, t3, r3, state_after_bs_unappl)
# Detection
# Gives not normalised state
state_after_dett_unappl = detection(state_aft2bs_unappl, detection_event=DET_CONF)
# Calculating the norm
norm_after_det = state_norm(state_after_dett_unappl)
print('Norm after det.:', norm_after_det)
# normalised state
state_after_dett_unappl_norm = state_after_dett_unappl / norm_after_det
# Build dens matrix and trace
dens_matrix_2channels = dens_matrix_with_trace(state_after_dett_unappl_norm, state_after_dett_unappl_norm)
# The new method, works
# dens_matrix_2channels = dens_matrix_with_trace_new(state_after_dett_unappl_norm, state_after_dett_unappl_norm)
# Disable a phase addition.
dens_matrix_2channels_withph = dens_matrix_2channels
# log_entropy_array = np.zeros((r4_grid), dtype=complex)
# log_negativity = np.zeros((r4_grid), dtype=complex)
t4 = 0.82
r4 = sqrt(1 - t4**2)
# Transformation at last BS
# Trim for better performance,
# trim_size=10 for series_len=10
# trim_size=4 for series_len=3
trim_size = 4
final_dens_matrix = bs_densmatrix_transform(dens_matrix_2channels_withph[:trim_size, :trim_size, :trim_size, :trim_size], t4, r4)
# Trace one channel out of final state
final_traced = trace_channel(final_dens_matrix, channel=4)
print('trace of final reduced matrix 2nd channel:', np.trace(final_traced))
# Other channel traced
final_traced_4th = trace_channel(final_dens_matrix, channel=2)
print('trace of final reduced matrix 4th channel:', np.trace(final_traced_4th))
# TODO Gives different entropy for different reduced density matrices
log_entropy(final_traced)
log_entropy(final_traced_4th)
entropy = 0
w, v = np.linalg.eig(final_traced)
# for n in range(len(final_traced)):
# if w[n] != 0:
# entropy = entropy - w[n] * np.log2(w[n])
entr1 = - (1 - 2*(t4**2)/3) * np.log2(1 - 2*t4**2/3) - 2*(t4**2)/3 * np.log2(2*(t4**2)/3)
entr2 = - ((1 + 2*(t4**2))/3) * np.log2((1 + 2*(t4**2))/3) - (2/3)*(1 - t4**2) * np.log2((2/3)*(1 - t4**2))
# Calculate entropy
# log_entanglement = log_entropy(final_traced)
log_entanglement = log_entropy(final_traced_4th) # other channel traced matrix
print('FN entropy: ', np.real(log_entanglement))
# log_entropy_array[i, j] = log_entanglement
# Logarithmic entropy difference
print('FN entropy difference: ', log_entanglement - log_entropy(final_traced_4th))
# lin_entropy[i, j] = np.real(linear_entropy(final_traced))
#lin_entropy[i, j] = np.real(linear_entropy(final_traced_4th)) # other channel traced matrix
#print('Lin. entropy: ', lin_entropy[i, j])
# Linear entropy difference
#print('Linear entropy difference: ', lin_entropy[i, j] - linear_entropy(final_traced_4th))
log_negativity = negativity(final_dens_matrix, neg_type='logarithmic')
print('Log. negativity: ', log_negativity)
| [] |
2024-01-10 | matthewR1993/qscheme | tf_implementation~run.py | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf
from customutils.utils import *
from core.basic import *
from core.state_configurations import coherent_state, single_photon, squeezed_vacuum
from tf_implementation.core.squeezing import *
from tf_implementation.core.common import *
L = 10
# state1 = single_photon(L)
state1 = coherent_state(L, alpha=1.0)
# state2 = coherent_state(L, alpha=1.0)
state2 = single_photon(L)
st1_tf = tf.constant(state1, tf.complex128)
st2_tf = tf.constant(state2, tf.complex128)
def t_constr(x):
return tf.clip_by_value(x, 1e-5, 1 - 1.e-5)
with tf.name_scope('system') as scope:
# Unapplied input state:
mut_state = tf.tensordot(st1_tf, st2_tf, axes=0, name='input_state')
# Trainable parameters.
phase = tf.Variable(1.47 * np.pi, trainable=True, dtype=tf.float64, name='phase')
T1 = tf.Variable(0.5, trainable=True, dtype=tf.float64, name='T1', constraint=t_constr)
T2 = tf.Variable(0.1, trainable=True, dtype=tf.float64, name='T2', constraint=t_constr)
s1 = bs_transformation_tf(mut_state, T1)
s2 = phase_mod(phase, s1[:L, :L], input_type='state', channel=1)
# Unapplied output state:
state_out = bs_transformation_tf(s2, T2)
# Applied output state:
state = make_state_applicable(state_out)
dm_out = tf.einsum('kl,mn->klmn', state, tf.conj(state))
# Cost function.
cor_x, _ = erp_squeezing_correlations_tf(dm_out)
cost = tf.cast(cor_x, tf.float64)
# Register summaries.
tf.summary.scalar('cost', cost)
tf.summary.scalar('T1', T1)
tf.summary.scalar('T2', T2)
tf.summary.scalar('phase', phase)
optimizer = tf.train.AdamOptimizer(
learning_rate=0.001,
beta1=0.9,
beta2=0.999,
epsilon=1e-08,
use_locking=False,
name='Adam'
)
minimize_op = optimizer.minimize(loss=cost, var_list=[T1, T2, phase])
sess = tf.Session()
sess.run(tf.global_variables_initializer())
# tensorboard --logdir=/home/matvei/qscheme/tf_implementation/logs/summaries/log
# http://localhost:6006
sum_path = '/Users/matvei/PycharmProjects/qscheme'
# sum_path = '/home/matvei/qscheme'
summaries_dir = sum_path + '/tf_implementation/logs/summaries'
# summaries_dir = '/home/matvei/qscheme/tf_implementation/logs/summaries'
merged = tf.summary.merge_all()
writer = tf.summary.FileWriter(summaries_dir + '/log', sess.graph)
max_steps = 1200
display_step = 20
summarize_step = 10
cost_progress = []
for i in range(max_steps):
[_, summary, cost_val, T1_val, T2_val, phase_val] = sess.run([minimize_op, merged, cost, T1, T2, phase])
cost_progress.append(
{
'cost': cost_val,
'T1': T1_val,
'T2': T2_val,
'phase': phase_val
})
# Prints progress.
if i % display_step == 0:
print("Rep: {} Cost: {} T1: {} T2: {} phase: {}".format(i, cost_val, T1_val, T2_val, phase_val))
if i % summarize_step == 0:
writer.add_summary(summary, i)
plt.plot([c['cost'] for c in cost_progress])
plt.xlabel('cost')
plt.xlabel('step')
plt.show()
# plt.plot([c['par_value'] for c in cost_progress])
# plt.show()
# pd.DataFrame(cost_progress).plot()
# from core.squeezing import *
#
# L = 10
# state = tf.constant(np.random.rand(L, L), tf.complex128)
#
# state_val = state.eval(session=sess)
# dm_val = np.outer(state_val, state_val.conj())
#
#
# dm = tf.einsum('kl,mn->klmn', state, tf.conj(state))
#
# sess = tf.Session()
#
# res = erp_squeezing_correlations_tf(dm)
# print(res[0].eval(session=sess), res[1].eval(session=sess))
#
# print(erp_squeezing_correlations(dm.eval(session=sess)))
#
# print(erp_squeezing_correlations(dm_val))
#
#
#
#
# cor_x, _ = erp_squeezing_correlations_tf(dm_out)
# cost = tf.cast(cor_x, tf.float64)
#
# erp_squeezing_correlations(dm_out)
# Build density matrix from state
# def two_bs2x4_transform(t1, r1, t2, r2, input_state):
# """
# Transformation at 2 beam splitters.
# Two input channels and four output channles - 2x4 transformation.
# Creation operators transformation:
# a1 => t1 a2 + i r1 a1.
# a2 => t2 a4 + i r2 a3.
# With transmission and reflection coefficients:
# t1^2 + r1^2 = 1.
# t2^2 + r2^2 = 1.
# :param t1: BS1 transmission.
# :param r1: BS1 reflection.
# :param t2: BS2 transmission.
# :param r2: BS2 reflection.
# :param input_state: Two channels(modes) unapllied state.
# :return: Four channels(modes) unapllied state.
# """
# size = len(input_state)
# output_state = np.zeros((size,) * 4, dtype=complex)
# for m in range(size):
# for n in range(size):
#
# for k in range(m + 1):
# for l in range(n + 1):
# # channels indexes
# ind1 = k
# ind2 = m - k
# ind3 = l
# ind4 = n - l
# coeff = input_state[m, n] * t1**(m - k) * (1j*r1)**k * t2**(n - l) * (1j*r2)**l * factorial(m) * factorial(n) / (factorial(k) * factorial(m - k) * factorial(l) * factorial(n - l))
# output_state[ind1, ind2, ind3, ind4] = output_state[ind1, ind2, ind3, ind4] + coeff
#
# return output_state
# L = 10
# dm = tf.constant(np.random.rand(L, L, L, L), tf.complex128)
#
# sess = tf.Session()
#
# res = erp_squeezing_correlations_tf(dm)
# print(res[0].eval(session=sess), res[1].eval(session=sess))
#
# print(erp_squeezing_correlations(dm.eval(session=sess)))
# Detection:
# def detection(state, type):
# return 0
# TODO.
# def bs_2x4_transform_tf(T1, T2, input_state):
# """
# Transformation at 2 beam splitters.
# Two input channels and four output channles - 2x4 transformation.
# Creation operators transformation:
# a1 => t1 a2 + i r1 a1.
# a2 => t2 a4 + i r2 a3.
# With transmission and reflection coefficients:
# T1 + R1 = 1.
# T2 + R2 = 1.
# :param T1: BS1 transmission.
# :param T2: BS2 transmission.
# :param input_state: Two channels unapllied state.
# :return: Four channels(modes) unapllied state.
# """
# return 0
#
#
# def two_bs2x4_transform(t1, r1, t2, r2, input_state):
# """
# Transformation at 2 beam splitters.
# Two input channels and four output channles - 2x4 transformation.
# Creation operators transformation:
# a1 => t1 a2 + i r1 a1.
# a2 => t2 a4 + i r2 a3.
# With transmission and reflection coefficients:
# t1^2 + r1^2 = 1.
# t2^2 + r2^2 = 1.
# :param t1: BS1 transmission.
# :param r1: BS1 reflection.
# :param t2: BS2 transmission.
# :param r2: BS2 reflection.
# :param input_state: Two channels(modes) unapllied state.
# :return: Four channels(modes) unapllied state.
# """
# size = len(input_state)
# output_state = np.zeros((size,) * 4, dtype=complex)
# for m in range(size):
# for n in range(size):
#
# for k in range(m + 1):
# for l in range(n + 1):
# # channels indexes
# ind1 = k
# ind2 = m - k
# ind3 = l
# ind4 = n - l
# coeff = input_state[m, n] * t1**(m - k) * (1j*r1)**k * t2**(n - l) * (1j*r2)**l * factorial(m) * factorial(n) / (factorial(k) * factorial(m - k) * factorial(l) * factorial(n - l))
# output_state[ind1, ind2, ind3, ind4] = output_state[ind1, ind2, ind3, ind4] + coeff
#
# return output_state
#
#
# def two_bs2x4_transform_opt(t1, r1, t2, r2, input_state):
# """
# Transformation at 2 beam splitters. Optimised version
# Two input channels and four output channles - 2x4 transformation.
# Creation operators transformation:
# a1 => t1 a2 + i r1 a1.
# a2 => t2 a4 + i r2 a3.
# With transmission and reflection coefficients:
# t1^2 + r1^2 = 1.
# t2^2 + r2^2 = 1.
# :param t1: BS1 transmission.
# :param r1: BS1 reflection.
# :param t2: BS2 transmission.
# :param r2: BS2 reflection.
# :param input_state: Two channels(modes) unapllied state.
# :return: Four channels(modes) unapllied state.
# """
# size = len(input_state)
# out = np.zeros((size,) * 4, dtype=complex)
#
# def coef(k1, k2, k3, k4):
# return t1 ** k2 * (1j * r1) ** k1 * t2 ** k4 * (1j * r2) ** k3 / (factorial(k1) * factorial(k2) * factorial(k3) * factorial(k4))
#
# # index 'i' = (m,n,k,l)
# for i in np.ndindex(size, size, size, size):
# if i[2] <= i[0] and i[3] <= i[1] and i[0] + i[1] < size:
# out[i[2], i[0] - i[2], i[3], i[1] - i[3]] = coef(i[2], i[0] - i[2], i[3], i[1] - i[3]) * input_state[i[0], i[1]] * factorial(i[0]) * factorial(i[1])
#
# return out
| [] |
2024-01-10 | matthewR1993/qscheme | scripts~grid_search.py | # Usage: python3 grid_search.py --det FIRST --phase 0.0 --quant EPR_X
import numpy as np
from time import gmtime, strftime
import sys
import platform
import argparse
if platform.system() == 'Linux':
sys.path.append('/usr/local/lib/python3.5/dist-packages')
sys.path.append('/home/matthew/qscheme')
elif platform.system() == 'Darwin':
sys.path.append('/Users/matvei/PycharmProjects/qscheme')
from core.basic import *
from core.sytem_setup import *
from core.squeezing import *
from core.state_configurations import coherent_state, single_photon, fock_state
parser = argparse.ArgumentParser()
parser.add_argument("-d", "--det", help="Detection", type=str, required=True)
parser.add_argument("-p", "--phase", help="Phase in pi", type=float, required=True)
parser.add_argument("-q", "--quant", help="A quantity to minimize", type=str, required=True)
args = parser.parse_args()
source_root = '/Users/matvei/PycharmProjects/qscheme/results/res19_rough/'
# source_root = '/home/matthew/qscheme/results/res19_rough/'
source_fname = 'coh(chan-1)_single(chan-2)_phase-{}pi_det-{}.npy'.format(args.phase, args.det)
print('Source file path:', source_root + source_fname)
save_root = '/Users/matvei/PycharmProjects/qscheme/results/res19_incr_accuracy/'
# save_root = '/home/matthew/qscheme/results/res19_incr_accuracy/'
save_fname = 'coh(chan-1)_single(chan-2)_phase-{}pi_det-{}_quant-{}.npy'.format(args.phase, args.det, args.quant)
print('Saving path:', save_root + save_fname)
ph_inpi = args.phase
phase_diff = ph_inpi * np.pi
DET_CONF = args.det
crit_probability = 0.1
# Find minimum
fl = np.load(source_root + source_fname)
sqeez_dX_old = fl.item().get('squeez_dx')
sqeez_dP_old = fl.item().get('squeez_dp')
erp_correl_x_old = fl.item().get('epr_correl_x')
erp_correl_p_old = fl.item().get('epr_correl_p')
prob_old = fl.item().get('det_prob')
t1_arr_old = fl.item().get('t1_arr')
t4_arr_old = fl.item().get('t4_arr')
t2_arr_old = fl.item().get('t2_arr')
t3_arr_old = fl.item().get('t3_arr')
T1_arr_old = np.square(t1_arr_old)
T4_arr_old = np.square(t4_arr_old)
T2_arr_old = np.square(t2_arr_old)
T3_arr_old = np.square(t3_arr_old)
print('Old t1 array:', t1_arr_old)
print('Old t4 array:', t4_arr_old)
print('Old t2 array:', t2_arr_old)
print('Old t3 array:', t3_arr_old)
print('Old T1 array:', T1_arr_old)
print('Old T4 array:', T4_arr_old)
print('Old T2 array:', T2_arr_old)
print('Old T3 array:', T3_arr_old)
delta_T1 = T1_arr_old[1] - T1_arr_old[0]
delta_T4 = T4_arr_old[1] - T4_arr_old[0]
delta_T2 = T2_arr_old[1] - T2_arr_old[0]
delta_T3 = T3_arr_old[1] - T3_arr_old[0]
print('Delta T1, T4, T2, T3:', delta_T1, delta_T4, delta_T2, delta_T3)
prob_args_lower = np.argwhere(np.real(prob_old) < crit_probability)
for i in range(len(prob_args_lower)):
index = tuple(prob_args_lower[i, :])
erp_correl_x_old[index] = 100
erp_correl_p_old[index] = 100
sqeez_dX_old[index] = 100
sqeez_dP_old[index] = 100
# Minimizing indexes.
dX_min_ind = list(np.unravel_index(np.argmin(sqeez_dX_old, axis=None), sqeez_dX_old.shape))
dP_min_ind = list(np.unravel_index(np.argmin(sqeez_dP_old, axis=None), sqeez_dP_old.shape))
epr_x_min_ind = list(np.unravel_index(np.argmin(erp_correl_x_old, axis=None), erp_correl_x_old.shape))
epr_p_min_ind = list(np.unravel_index(np.argmin(erp_correl_p_old, axis=None), erp_correl_p_old.shape))
# Minimizing T coordinates.
dX_min_ind_T_arr = np.array([T1_arr_old[dX_min_ind[0]], T4_arr_old[dX_min_ind[1]], T2_arr_old[dX_min_ind[2]], T3_arr_old[dX_min_ind[3]]])
dP_min_ind_T_arr = np.array([T1_arr_old[dP_min_ind[0]], T4_arr_old[dP_min_ind[1]], T2_arr_old[dP_min_ind[2]], T3_arr_old[dP_min_ind[3]]])
epr_x_min_T_arr = np.array([T1_arr_old[epr_x_min_ind[0]], T4_arr_old[epr_x_min_ind[1]], T2_arr_old[epr_x_min_ind[2]], T3_arr_old[epr_x_min_ind[3]]])
epr_p_min_T_arr = np.array([T1_arr_old[epr_p_min_ind[0]], T4_arr_old[epr_p_min_ind[1]], T2_arr_old[epr_p_min_ind[2]], T3_arr_old[epr_p_min_ind[3]]])
# Building a new coordinate grid around minimum point.
grd_mut = 11
min_quantity = args.quant
print('Quantity to miminize:', min_quantity)
print('Phase:', phase_diff)
print('Phase in [pi]:', ph_inpi)
print('Detection event:', DET_CONF)
# A new grid's center.
if min_quantity == 'EPR_X':
min_T_coord = epr_x_min_T_arr
elif min_quantity == 'EPR_P':
min_T_coord = epr_p_min_T_arr
elif min_quantity == 'QUADR_X':
min_T_coord = dX_min_ind_T_arr
elif min_quantity == 'QUADR_P':
min_T_coord = dP_min_ind_T_arr
else:
raise ValueError
print('Min. T values from the previous step [T1, T4, T2, T3]:', min_T_coord)
print('Min. t values from the previous step [t1, t4, t2, t3]:', np.sqrt(min_T_coord))
delta = 0.1
min_bound = 1e-5
max_bound = 1 - 1e-5
T1_new_max = min_T_coord[0] + delta
T1_new_min = min_T_coord[0] - delta
T4_new_max = min_T_coord[1] + delta
T4_new_min = min_T_coord[1] - delta
T2_new_max = min_T_coord[2] + delta
T2_new_min = min_T_coord[2] - delta
T3_new_max = min_T_coord[3] + delta
T3_new_min = min_T_coord[3] - delta
# Satisfy boundary conditions.
if T1_new_max >= 1:
T1_new_max = 1
if T1_new_min <= 0:
T1_new_min = 0
if T4_new_max >= 1:
T4_new_max = 1
if T4_new_min <= 0:
T4_new_min = 0
if T2_new_max >= max_bound:
T2_new_max = max_bound
if T2_new_min <= min_bound:
T2_new_min = min_bound
if T3_new_max >= max_bound:
T3_new_max = max_bound
if T3_new_min <= min_bound:
T3_new_min = min_bound
print('New T1_min, T1_max:', T1_new_min, T1_new_max)
print('New T4_min, T4_max:', T4_new_min, T4_new_max)
print('New T2_min, T2_max:', T2_new_min, T2_new_max)
print('New T3_min, T3_max:', T3_new_min, T3_new_max)
t1_array, _ = bs_parameters(T1_new_min, T1_new_max, grd_mut)
t4_array, _ = bs_parameters(T4_new_min, T4_new_max, grd_mut)
t2_array, _ = bs_parameters(T2_new_min, T2_new_max, grd_mut)
t3_array, _ = bs_parameters(T3_new_min, T3_new_max, grd_mut)
# Adding previous values
t1_array = np.append(t1_array, np.sqrt(min_T_coord)[0])
t4_array = np.append(t4_array, np.sqrt(min_T_coord)[1])
t2_array = np.append(t2_array, np.sqrt(min_T_coord)[2])
t3_array = np.append(t3_array, np.sqrt(min_T_coord)[3])
print("New t1 array:", t1_array)
print("New t4 array:", t4_array)
print("New t2 array:", t2_array)
print("New t3 array:", t3_array)
print("New T1 array:", np.square(t1_array))
print("New T4 array:", np.square(t4_array))
print("New T2 array:", np.square(t2_array))
print("New T3 array:", np.square(t3_array))
# Parameters for states
series_length = 10
input_series_length = series_length
auxiliary_series_length = series_length
max_power = input_series_length + auxiliary_series_length
# Preparing input state.
input_st = coherent_state(input_series_length, alpha=1)
auxiliary_st = single_photon(series_length)
mut_state_unappl = np.tensordot(input_st, auxiliary_st, axes=0)
sz = (len(t1_array), len(t4_array), len(t2_array), len(t3_array))
det_prob_array = np.zeros(sz, dtype=complex)
log_entropy_subs1_array = np.zeros(sz, dtype=complex)
log_entropy_subs2_array = np.zeros(sz, dtype=complex)
lin_entropy_subs1 = np.zeros(sz, dtype=complex)
lin_entropy_subs2 = np.zeros(sz, dtype=complex)
log_negativity = np.zeros(sz, dtype=complex)
mut_information = np.zeros(sz, dtype=complex)
full_fn_entropy = np.zeros(sz, dtype=complex)
sqeez_dX = np.zeros(sz, dtype=complex)
sqeez_dP = np.zeros(sz, dtype=complex)
epr_correl_x = np.zeros(sz, dtype=complex)
epr_correl_p = np.zeros(sz, dtype=complex)
norm_after_det_arr = np.zeros(sz, dtype=complex)
final_dens_matrix_list = []
if __name__ == "__main__":
# Start time.
print('Started at:', strftime("%Y-%m-%d %H:%M:%S", gmtime()))
for n1 in range(len(t1_array)):
for n4 in range(len(t4_array)):
for n2 in range(len(t2_array)):
for n3 in range(len(t3_array)):
print('Steps [n1, n4, n2, n3]:', n1, n4, n2, n3)
bs_params = {
't1': t1_array[n1],
't4': t4_array[n4],
't2': t2_array[n2],
't3': t3_array[n3],
}
final_dens_matrix, det_prob, norm = process_all(mut_state_unappl, bs_params, phase_diff=phase_diff, det_event=DET_CONF)
if final_dens_matrix is None or det_prob is None:
print('Warning: the norm is zero.')
pass
det_prob_array[n1, n4, n2, n3] = det_prob
norm_after_det_arr[n1, n4, n2, n3] = norm
# final_dens_matrix_list.append({'dm': final_dens_matrix, 'keys': [n1, n4, n2, n3]})
# Trace one channel out of final state
# final_traced_subs1 = trace_channel(final_dens_matrix, channel=4)
# print('trace of final reduced matrix 2nd channel:', np.trace(final_traced_subs1))
# Other channel traced
# final_traced_subs2 = trace_channel(final_dens_matrix, channel=2)
# print('trace of final reduced matrix 4th channel:', np.trace(final_traced_subs2))
# Calculate entropy
# log_entanglement_subs1 = log_entropy(final_traced_subs1)
# log_entanglement_subs2 = log_entropy(final_traced_subs2)
# log_entropy_subs1_array[n1, n4, n2, n3] = log_entanglement_subs1
# log_entropy_subs2_array[n1, n4, n2, n3] = log_entanglement_subs2
# Full entropy and the mutual information
# final_reorg_matr = reorganise_dens_matrix(final_dens_matrix)
# full_entr = log_entropy(final_reorg_matr)
# mut_information[n1, n4, n2, n3] = log_entanglement_subs1 + log_entanglement_subs2 - full_entr
# full_fn_entropy[n1, n4, n2, n3] = full_entr
log_negativity[n1, n4, n2, n3] = negativity(final_dens_matrix, neg_type='logarithmic')
# print('Log. negativity: ', log_negativity[n1, n4, n2, n3])
# Squeezing quadratures.
dX, dP = squeezing_quadratures(final_dens_matrix, channel=1)
# print('dX:', dX, ' dP:', dP)
sqeez_dX[n1, n4, n2, n3] = dX
sqeez_dP[n1, n4, n2, n3] = dP
# ERP correlations.
epr_x, epr_p = erp_squeezing_correlations(final_dens_matrix)
epr_correl_x[n1, n4, n2, n3] = epr_x
epr_correl_p[n1, n4, n2, n3] = epr_p
# print('erp_X:', erp_x, ' erp_P:', erp_p)
# Save it.
fl = {
'det_prob': det_prob_array,
'norm_aft_det': norm_after_det_arr,
# 'final_dens_matrix': final_dens_matrix_list,
'log_negativity': log_negativity,
# 'mut_inform': mut_information,
'squeez_dx': sqeez_dX,
'squeez_dp': sqeez_dP,
'epr_correl_x': epr_correl_x,
'epr_correl_p': epr_correl_p,
'det_conf': args.det,
'phase': args.phase,
't1_arr': t1_array,
't4_arr': t4_array,
't2_arr': t2_array,
't3_arr': t3_array,
'states_config': 'coh(chan-1)_single(chan-2)'
}
np.save(save_root + save_fname, fl)
| [] |
2024-01-10 | matthewR1993/qscheme | scripts~spd_epr_numerical.py | import numpy as np
from time import gmtime, strftime
import matplotlib.pyplot as plt
import sys
import platform
import argparse
from customutils.utils import *
from core.basic import *
from core.sytem_setup import *
from core.squeezing import *
from core.state_configurations import coherent_state, single_photon
from core.optimized import transformations as trans
series_length = 10
st1 = single_photon(series_length)
alpha = 1.0
st2 = coherent_state(series_length, alpha=alpha)
# The phase difference before last BS
phase_arr = np.linspace(0, 2*np.pi, 25)
# Bottom channel = 1.
phase_mod_channel = 1
# BS grids.
r1_grid = 13
r4_grid = 13
r2_grid = 13
r3_grid = 13
min_bound = 1e-5
max_bound = 1 - 1e-5
# BS values range.
T1_min = 0.0
T1_max = 1.0
T4_min = 0.0
T4_max = 1.0
T2_min = min_bound
T2_max = max_bound
T3_min = min_bound
T3_max = max_bound
# Varying BSs. Small t, r parameters, with step regarding to big "T".
t1_array, r1_array = bs_parameters(T1_min, T1_max, r1_grid)
t4_array, r4_array = bs_parameters(T4_min, T4_max, r4_grid)
t2_array, r2_array = bs_parameters(T2_min, T2_max, r2_grid)
t3_array, r3_array = bs_parameters(T3_min, T3_max, r3_grid)
sz = (r1_grid, r4_grid, r2_grid, r3_grid)
epr_correl_x = np.zeros(sz, dtype=complex)
epr_min_vs_phase = np.zeros(len(phase_arr), dtype=complex)
mut_state_unappl = np.tensordot(st1, st2, axes=0)
def state_norm_opt(state):
fact_arr = np.array([factorial(x) for x in range(len(state))])
tf2 = np.tensordot(fact_arr, fact_arr, axes=0)
st_abs_quad = np.power(np.abs(state), 2)
mult = np.multiply(st_abs_quad, tf2)
return np.sqrt(np.sum(mult))
def make_state_appliable(state):
fact_arr = np.array([sqrt(factorial(x)) for x in range(len(state))])
tf2 = np.tensordot(fact_arr, fact_arr, axes=0)
return np.multiply(state, tf2)
for p, phase in enumerate(phase_arr):
print('phase step:', p)
for n1 in range(r1_grid):
for n4 in range(r4_grid):
for n2 in range(r2_grid):
for n3 in range(r3_grid):
# print('Steps [n1, n4, n2, n3]:', n1, n4, n2, n3)
t1 = t1_array[n1]
t2 = t2_array[n2]
t3 = t3_array[n3]
t4 = t4_array[n4]
r1 = r1_array[n1]
r2 = r2_array[n2]
r3 = r3_array[n3]
r4 = r4_array[n4]
# First BS.
state_after_bs_unappl = bs2x2_transform(t1, r1, mut_state_unappl)
# 2d and 3rd BS.
# state_aft2bs_unappl = two_bs2x4_transform(t2, r2, t3, r3, state_after_bs_unappl)
state_aft2bs_unappl = trans.two_bs2x4_transform_copt(t2, r2, t3, r3, state_after_bs_unappl[:9, :9].copy(order='C'))
state_aft2bs_unappl = state_aft2bs_unappl[:9, :9, :9, :9]
# state after det.
# FIRST bottom single photon det clicks.
sz = len(state_aft2bs_unappl)
state_aft_det_unnorm = np.zeros((sz,) * 2, dtype=complex)
for p2 in range(sz):
for p4 in range(sz):
state_aft_det_unnorm[p2, p4] += state_aft2bs_unappl[1, p2, 0, p4]
norm = state_norm_opt(state_aft_det_unnorm)
state_aft_det_norm_unappl = state_aft_det_unnorm / norm
# phase
st1_unappl = phase_modulation_state(state_aft_det_norm_unappl, phase)
# last BS
state_unapll_final = bs2x2_transform(t4, r4, st1_unappl)
state_final = make_state_appliable(state_unapll_final)
state_final = state_final[:9, :9]
# form Dens matrix
dm_final = np.einsum('ij,kl->ijkl', state_final, np.conj(state_final))
# ERP correlation's variance.
epr_x, epr_p = erp_squeezing_correlations(dm_final)
epr_correl_x[n1, n4, n2, n3] = epr_x
epr_min = np.amin(epr_correl_x)
epr_min_vs_phase[p] = epr_min
print('EPR min:', epr_min)
np.save('data2.npy', {
'epr_min': epr_min_vs_phase,
'phases': phase_arr
})
fl = np.load('data2.npy')
epr_min_arr = np.real(fl.item().get('epr_min'))
phase_arr = fl.item().get('phases')
# epr_min_arr[19] = 0.37899992
plt.plot(phase_arr / np.pi, np.real(epr_min_arr))
plt.xlabel('$Phase$')
plt.ylabel('$VAR[X_{1} - X_{2}]$')
plt.grid(True)
plt.show()
| [] |
2024-01-10 | matthewR1993/qscheme | checkouts~check11.py | # EPR normalisation for different combinations.
# Check the squeezing right before the detection.
import sys
try:
sys.path.append('/usr/local/lib/python3.5/dist-packages')
except: pass
import tensorflow as tf
from customutils.utils import *
from core.basic import *
from core.squeezing import *
from core.state_configurations import coherent_state, single_photon, fock_state
sess = tf.Session()
# Parameters for states
series_length = 10
input_series_length = series_length
auxiliary_series_length = series_length
max_power = input_series_length + auxiliary_series_length
# INPUT
input_st = single_photon(series_length)
# input_st = coherent_state(input_series_length, alpha=1)
# input_st = fock_state(n=2, series_length=input_series_length)
print('Input state norm:', get_state_norm(input_st))
# AUXILIARY
auxiliary_st = single_photon(series_length)
# auxiliary_st = coherent_state(auxiliary_series_length, alpha=1)
# auxiliary_st = fock_state(n=2, series_length=auxiliary_series_length)
print('Auxiliary state norm:', get_state_norm(auxiliary_st))
in_state_tf = tf.constant(input_st, tf.float64)
aux_state_tf = tf.constant(auxiliary_st, tf.float64)
# tensor product, returns numpy array
mut_state_unappl = tf.tensordot(
in_state_tf,
aux_state_tf,
axes=0,
name=None
).eval(session=sess)
dm = dens_matrix(make_state_appliable(mut_state_unappl))
# ERP correlations
erp_x, erp_p = erp_squeezing_correlations(dm)
# For coherent + single:
# erp_x, erp_p = 1, 1
# For single + single:
# erp_x, erp_p = 1.2247, 1.2247 <=> sqrt(3/2), sqrt(3/2)
# For coherent + coherent:
# erp_x, erp_p = sqrt(1/2), sqrt(1/2)
# For vac + vac:
# erp_x, erp_p = sqrt(1/2), sqrt(1/2)
| [] |
2024-01-10 | matthewR1993/qscheme | checkouts~check6.py | # Two photons go directly to detector
import sys
try:
sys.path.append('/usr/local/lib/python3.5/dist-packages')
except: pass
import numpy as np
import tensorflow as tf
from qutip import (wigner, super_tensor, Qobj)
from time import gmtime, strftime
from customutils.utils import *
from core.basic import *
from core.state_configurations import coherent_state, single_photon
from setup_parameters import *
sess = tf.Session()
# Parameters for states
series_length = 3
input_series_length = series_length
auxiliary_series_length = series_length
max_power = input_series_length + auxiliary_series_length
# INPUT
input_st = single_photon(series_length)
# input_st = coherent_state(input_series_length, alpha=1)
print('Input state norm:', get_state_norm(input_st))
# AUXILIARY
auxiliary_st = single_photon(series_length)
# auxiliary_st = coherent_state(auxiliary_series_length, alpha=1)
print('Auxiliary state norm:', get_state_norm(auxiliary_st))
# Measurement event, detectors configuration:
# DET_CONF = 'BOTH' # both 1st and 3rd detectors clicked
# DET_CONF = 'FIRST' # 1st detector clicked
DET_CONF = 'THIRD' # 3rd detector clicked
# DET_CONF = 'NONE' # None of detectors were clicked
in_state_tf = tf.constant(input_st, tf.float64)
aux_state_tf = tf.constant(auxiliary_st, tf.float64)
# tensor product, returns numpy array
mut_state_unappl = tf.tensordot(
in_state_tf,
aux_state_tf,
axes=0,
name=None
).eval(session=sess)
# random parameters
t2 = 0.4
r2 = sqrt(1 - t2**2)
t3 = 0.8
r3 = sqrt(1 - t3**2)
# Two bs
state_aft2bs_unappl = two_bs2x4_transform(t2, r2, t3, r3, mut_state_unappl)
# Detection
state_after_dett_unappl = detection(state_aft2bs_unappl, detection_event=DET_CONF)
# works
| [] |
2024-01-10 | matthewR1993/qscheme | checkouts~check10.py | # Check squeezing right before the detection.
import sys
try:
sys.path.append('/usr/local/lib/python3.5/dist-packages')
except: pass
import numpy as np
import tensorflow as tf
from customutils.utils import *
from core.basic import *
from core.squeezing import *
from core.state_configurations import coherent_state, single_photon, fock_state
from setup_parameters import *
sess = tf.Session()
# Parameters for states
series_length = 10
input_series_length = series_length
auxiliary_series_length = series_length
max_power = input_series_length + auxiliary_series_length
# Set up input and auxiliary states as a Taylor series
# input_st[n] = state with 'n' photons !!!a
# INPUT
# input_st = single_photon(series_length)
input_st = coherent_state(input_series_length, alpha=1)
# input_st = fock_state(n=2, series_length=input_series_length)
print('Input state norm:', get_state_norm(input_st))
# AUXILIARY
auxiliary_st = single_photon(series_length)
# auxiliary_st = coherent_state(auxiliary_series_length, alpha=1)
# auxiliary_st = fock_state(n=2, series_length=auxiliary_series_length)
print('Auxiliary state norm:', get_state_norm(auxiliary_st))
in_state_tf = tf.constant(input_st, tf.float64)
aux_state_tf = tf.constant(auxiliary_st, tf.float64)
# tensor product, returns numpy array
mut_state_unappl = tf.tensordot(
in_state_tf,
aux_state_tf,
axes=0,
name=None
).eval(session=sess)
dm1 = dens_matrix(make_state_appliable(mut_state_unappl))
dX_1, dP_1 = squeezing_quadratures(dm1, channel=1)
# Works, both are 0.5
# First BS
state_after_bs_unappl = bs2x2_transform(t1, r1, mut_state_unappl)
dm2 = dens_matrix(make_state_appliable(state_after_bs_unappl))
dX_2, dP_2 = squeezing_quadratures(dm2, channel=1)
# The variance here is different because of the mixing at BS.
| [] |
2024-01-10 | matthewR1993/qscheme | checkouts~check7.py | # Check last BS transformation
# 2 photons described by density matrix go to detector.
import sys
try:
sys.path.append('/usr/local/lib/python3.5/dist-packages')
except: pass
import numpy as np
import tensorflow as tf
from qutip import (wigner, super_tensor, Qobj)
from time import gmtime, strftime
from customutils.utils import *
from core.basic import *
from core.state_configurations import coherent_state, single_photon
from setup_parameters import *
sess = tf.Session()
# Parameters for states
series_length = 3
input_series_length = series_length
auxiliary_series_length = series_length
max_power = input_series_length + auxiliary_series_length
# INPUT
input_st = single_photon(series_length)
# input_st = coherent_state(input_series_length, alpha=1)
print('Input state norm:', get_state_norm(input_st))
# AUXILIARY
auxiliary_st = single_photon(series_length)
# auxiliary_st = coherent_state(auxiliary_series_length, alpha=1)
print('Auxiliary state norm:', get_state_norm(auxiliary_st))
# Measurement event, detectors configuration:
# DET_CONF = 'BOTH' # both 1st and 3rd detectors clicked
# DET_CONF = 'FIRST' # 1st detector clicked
DET_CONF = 'THIRD' # 3rd detector clicked
# DET_CONF = 'NONE' # None of detectors were clicked
in_state_tf = tf.constant(input_st, tf.float64)
aux_state_tf = tf.constant(auxiliary_st, tf.float64)
# Tensor product, returns numpy array
mut_state_unappl = tf.tensordot(
in_state_tf,
aux_state_tf,
axes=0,
name=None
).eval(session=sess)
# Building density matrix
mut_state_appl = make_state_appliable(mut_state_unappl)
from time import gmtime, strftime
dm_in = dens_matrix(mut_state_appl)
# The transformation at BS
t4 = 0.4
r4 = sqrt(1 - t4**2)
dm_out = bs_densmatrix_transform(dm_in, t4, r4)
# (t4**2 - r4**2)**2 // 0.4623
#
# (t4**2 - r4**2)*t4*r4 * sqrt(2) // -0.352
#
# t4**2 * r4**2 * 2 // 0.268
# Works:
dm_out[1, 1, 1, 1]
dm_out[1, 1, 2, 0]
dm_out[1, 1, 0, 2]
dm_out[2, 0, 1, 1]
dm_out[2, 0, 2, 0]
dm_out[2, 0, 0, 2]
dm_out[0, 2, 1, 1]
dm_out[0, 2, 2, 0]
dm_out[0, 2, 0, 2]
| [] |
2024-01-10 | matthewR1993/qscheme | scripts~space_grid.py | # A solution with a scaled grid.
import sys
import platform
if platform.system() == 'Linux':
sys.path.append('/usr/local/lib/python3.5/dist-packages')
elif platform.system() == 'Darwin':
sys.path.append('/Users/matvei/PycharmProjects/qscheme')
from time import gmtime, strftime
import numpy as np
import argparse
from customutils.utils import *
from core.basic import *
from core.sytem_setup import *
from core.squeezing import *
from core.state_configurations import coherent_state, single_photon, fock_state
parser = argparse.ArgumentParser()
parser.add_argument("-d", "--det", help="Detection", type=str, required=True)
parser.add_argument("-p", "--phase", help="Phase in pi", type=float, required=True)
args = parser.parse_args()
save_root = '/Users/matvei/PycharmProjects/qscheme/results/res16/'
# save_root = '/home/matthew/qscheme/results/res16/'
fname = 'coh(chan-1)_single(chan-2)_phase-{}pi_det-{}.npy'.format(args.phase, args.det)
print('Saving path:', save_root + fname)
# Parameters for states
series_length = 10
input_series_length = series_length
auxiliary_series_length = series_length
max_power = input_series_length + auxiliary_series_length
# INPUT - the state in the first(at the bottom) channel
# input_st = single_photon(series_length)
input_st = coherent_state(input_series_length, alpha=1)
# input_st = fock_state(n=2, series_length=input_series_length)
print('Input state norm:', get_state_norm(input_st))
# AUXILIARY - the state in the second(on top) channel
auxiliary_st = single_photon(series_length)
# auxiliary_st = coherent_state(auxiliary_series_length, alpha=1)
# auxiliary_st = fock_state(n=2, series_length=auxiliary_series_length)
print('Auxiliary state norm:', get_state_norm(auxiliary_st))
# Measurement event, detectors configuration:
# DET_CONF = 'BOTH' # both 1st and 3rd detectors clicked
# DET_CONF = 'FIRST' # 1st detector is clicked
# DET_CONF = 'THIRD' # 3rd detector is clicked
# DET_CONF = 'NONE' # None of detectors were clicked
DET_CONF = args.det
# Building a mutual state via tensor product.
mut_state_unappl = np.tensordot(input_st, auxiliary_st, axes=0)
QUANT_T0_MINIMIZE = 'EPR_P'
SCALING_DEPTH = 3
# The phase difference before last BS
# ph_inpi = 0.0
ph_inpi = args.phase
phase_diff = ph_inpi * np.pi
# BS grids.
r1_grid = 5
r4_grid = 5
r2_grid = 5
r3_grid = 5
T1_min_arr = np.zeros(SCALING_DEPTH + 1, dtype=float)
T1_max_arr = np.zeros(SCALING_DEPTH + 1, dtype=float)
T4_min_arr = np.zeros(SCALING_DEPTH + 1, dtype=float)
T4_max_arr = np.zeros(SCALING_DEPTH + 1, dtype=float)
T2_min_arr = np.zeros(SCALING_DEPTH + 1, dtype=float)
T2_max_arr = np.zeros(SCALING_DEPTH + 1, dtype=float)
T3_min_arr = np.zeros(SCALING_DEPTH + 1, dtype=float)
T3_max_arr = np.zeros(SCALING_DEPTH + 1, dtype=float)
min_bound = 1e-5
max_bound = 1 - 1e-5
# Starting BS parameters grid range.
T1_min_arr[0] = 0.0
T1_max_arr[0] = 1.0
T4_min_arr[0] = 0.0
T4_max_arr[0] = 1.0
T2_min_arr[0] = min_bound
T2_max_arr[0] = max_bound
T3_min_arr[0] = min_bound
T3_max_arr[0] = max_bound
if __name__ == "__main__":
print('Started at:', strftime("%Y-%m-%d %H:%M:%S", gmtime()))
# Scaling step loop.
for p in range(SCALING_DEPTH):
print('Depth:', p)
# BS values range.
T1_min = T1_min_arr[p]
T1_max = T1_max_arr[p]
T4_min = T4_min_arr[p]
T4_max = T4_max_arr[p]
T2_min = T2_min_arr[p]
T2_max = T2_max_arr[p]
T3_min = T3_min_arr[p]
T3_max = T3_max_arr[p]
T1_step = abs(T1_max - T1_min) / (r1_grid - 1)
T4_step = abs(T4_max - T4_min) / (r4_grid - 1)
T2_step = abs(T2_max - T2_min) / (r2_grid - 1)
T3_step = abs(T3_max - T3_min) / (r3_grid - 1)
# Varying BSs.
t1_array, r1_array = bs_parameters(T1_min, T1_max, r1_grid)
t4_array, r4_array = bs_parameters(T4_min, T4_max, r4_grid)
t2_array, r2_array = bs_parameters(T2_min, T2_max, r2_grid)
t3_array, r3_array = bs_parameters(T3_min, T3_max, r3_grid)
det_prob_array = np.full((r1_grid, r4_grid, r2_grid, r3_grid), dtype=complex, fill_value=None)
log_entropy_subs1_array = np.full((r1_grid, r4_grid, r2_grid, r3_grid), dtype=complex, fill_value=None)
log_entropy_subs2_array = np.full((r1_grid, r4_grid, r2_grid, r3_grid), dtype=complex, fill_value=None)
lin_entropy_subs1 = np.full((r1_grid, r4_grid, r2_grid, r3_grid), dtype=complex, fill_value=None)
lin_entropy_subs2 = np.full((r1_grid, r4_grid, r2_grid, r3_grid), dtype=complex, fill_value=None)
log_negativity = np.full((r1_grid, r4_grid, r2_grid, r3_grid), dtype=complex, fill_value=None)
mut_information = np.full((r1_grid, r4_grid, r2_grid, r3_grid), dtype=complex, fill_value=None)
full_fn_entropy = np.full((r1_grid, r4_grid, r2_grid, r3_grid), dtype=complex, fill_value=None)
sqeez_dX = np.full((r1_grid, r4_grid, r2_grid, r3_grid), dtype=complex, fill_value=None)
sqeez_dP = np.full((r1_grid, r4_grid, r2_grid, r3_grid), dtype=complex, fill_value=None)
epr_correl_x = np.full((r1_grid, r4_grid, r2_grid, r3_grid), dtype=complex, fill_value=None)
epr_correl_p = np.full((r1_grid, r4_grid, r2_grid, r3_grid), dtype=complex, fill_value=None)
for n1 in range(r1_grid):
for n4 in range(r4_grid):
for n2 in range(r2_grid):
for n3 in range(r3_grid):
print('Steps [n1, n4, n2, n3]:', n1, n4, n2, n3)
bs_params = {
't1': t1_array[n1],
'r1': r1_array[n1],
't4': t4_array[n4],
'r4': r4_array[n4],
't2': t2_array[n2],
'r2': r2_array[n2],
't3': t3_array[n3],
'r3': r3_array[n3],
}
final_dens_matrix, det_prob = process_all(mut_state_unappl, bs_params, phase_diff=phase_diff, det_event=DET_CONF)
if final_dens_matrix is None or det_prob is None:
print('Warning: the norm is zero.')
pass
det_prob_array[n1, n4, n2, n3] = det_prob
# Trace one channel out of final state
final_traced_subs1 = trace_channel(final_dens_matrix, channel=4)
# Other channel traced
final_traced_subs2 = trace_channel(final_dens_matrix, channel=2)
# Calculate entropy
log_entanglement_subs1 = log_entropy(final_traced_subs1)
log_entanglement_subs2 = log_entropy(final_traced_subs2)
log_entropy_subs1_array[n1, n4, n2, n3] = log_entanglement_subs1
log_entropy_subs2_array[n1, n4, n2, n3] = log_entanglement_subs2
# Full entropy and the mutual information
final_reorg_matr = reorganise_dens_matrix(final_dens_matrix)
full_entr = log_entropy(final_reorg_matr)
mut_information[n1, n4, n2, n3] = log_entanglement_subs1 + log_entanglement_subs2 - full_entr
full_fn_entropy[n1, n4, n2, n3] = full_entr
log_negativity[n1, n4, n2, n3] = negativity(final_dens_matrix, neg_type='logarithmic')
# Squeezing quadratures.
dX, dP = squeezing_quadratures(final_dens_matrix, channel=1)
sqeez_dX[n1, n4, n2, n3] = dX
sqeez_dP[n1, n4, n2, n3] = dP
# ERP correlations.
epr_x, epr_p = erp_squeezing_correlations(final_dens_matrix)
epr_correl_x[n1, n4, n2, n3] = epr_x
epr_correl_p[n1, n4, n2, n3] = epr_p
epr_x_min = np.nanmin(epr_correl_x)
epr_p_min = np.nanmin(epr_correl_p)
dX_min = np.nanmin(sqeez_dX)
dP_min = np.nanmin(sqeez_dP)
uncert = np.multiply(sqeez_dX, sqeez_dP)
dX_min_ind = list(np.unravel_index(np.nanargmin(sqeez_dX, axis=None), sqeez_dX.shape))
dP_min_ind = list(np.unravel_index(np.nanargmin(sqeez_dP, axis=None), sqeez_dP.shape))
epr_x_min_ind = list(np.unravel_index(np.nanargmin(epr_correl_x, axis=None), epr_correl_x.shape))
epr_p_min_ind = list(np.unravel_index(np.nanargmin(epr_correl_p, axis=None), epr_correl_p.shape))
# Calculate the minimun.
if QUANT_T0_MINIMIZE is 'EPR_X':
ind = epr_x_min_ind
print('EPR_X min value:', epr_x_min)
print('EPR_X min value:', epr_correl_x[tuple(epr_x_min_ind)])
elif QUANT_T0_MINIMIZE is 'EPR_P':
ind = epr_p_min_ind
print('EPR_P min value:', epr_p_min)
print('EPR_P min value:', epr_correl_p[tuple(epr_p_min_ind)])
elif QUANT_T0_MINIMIZE is 'dX':
ind = dX_min_ind
print('dX min value:', dX_min)
print('dX min value:', sqeez_dX[tuple(dX_min_ind)])
elif QUANT_T0_MINIMIZE is 'dP':
ind = dP_min_ind
print('dP min value:', dP_min)
print('dP min value:', sqeez_dP[tuple(dP_min_ind)])
else:
raise ValueError
# Minimizing set of parameters T1, T2, T3, T4:
T1_mid = t1_array[ind[0]]
T4_mid = t4_array[ind[1]]
T2_mid = t2_array[ind[2]]
T3_mid = t3_array[ind[3]]
print('T1_mid:', T1_mid)
print('T4_mid:', T4_mid)
print('T2_mid:', T2_mid)
print('T3_mid:', T3_mid)
# Building a T grid, for a new scale step.
T1_min_arr[p + 1] = T1_mid - T1_step
T1_max_arr[p + 1] = T1_mid + T1_step
T4_min_arr[p + 1] = T4_mid - T4_step
T4_max_arr[p + 1] = T4_mid + T4_step
T2_min_arr[p + 1] = T2_mid - T2_step
T2_max_arr[p + 1] = T2_mid + T2_step
T3_min_arr[p + 1] = T3_mid - T3_step
T3_max_arr[p + 1] = T3_mid + T3_step
# Check boundaries.
if T1_min_arr[p + 1] < 0:
T1_min_arr[p + 1] = 0
if T1_max_arr[p + 1] > 1:
T1_max_arr[p + 1] = 1
if T4_min_arr[p + 1] < 0:
T4_min_arr[p + 1] = 0
if T4_max_arr[p + 1] > 1:
T4_max_arr[p + 1] = 1
if T2_min_arr[p + 1] < min_bound:
T2_min_arr[p + 1] = min_bound
if T2_max_arr[p + 1] > max_bound:
T2_max_arr[p + 1] = max_bound
if T3_min_arr[p + 1] < min_bound:
T3_min_arr[p + 1] = min_bound
if T3_max_arr[p + 1] > max_bound:
T3_max_arr[p + 1] = max_bound
print('T1_min next:', T1_min_arr[p + 1])
print('T1_max next:', T1_max_arr[p + 1])
print('T4_min next:', T4_min_arr[p + 1])
print('T4_max next:', T4_max_arr[p + 1])
print('T2_min next:', T2_min_arr[p + 1])
print('T2_max next:', T2_max_arr[p + 1])
print('T3_min next:', T3_min_arr[p + 1])
print('T3_max next:', T3_max_arr[p + 1])
# Save it.
if p == SCALING_DEPTH - 1:
data = {
'det_prob': det_prob_array,
'log_negativity': log_negativity,
'mut_inform': mut_information,
'squeez_dx': sqeez_dX,
'squeez_dp': sqeez_dP,
'epr_correl_x': epr_correl_x,
'epr_correl_p': epr_correl_p,
'det_conf': DET_CONF,
'phase': phase_diff,
't1_arr': t1_array,
't4_arr': t4_array,
't2_arr': t2_array,
't3_arr': t3_array,
'states_config': 'coh(chan-1)_single(chan-2)'
}
np.save(save_root + fname, data)
| [] |
2024-01-10 | matthewR1993/qscheme | checkouts~check3.py | # A coherent state and a single photon with two beam splitters and phase modul.
# Gives zeros entanglement for two coherent states
# Tracing different channels gives same entropy(works)
# Gives the same result comparing anlytical formula of two photons
import sys
try:
sys.path.append('/usr/local/lib/python3.5/dist-packages')
except: pass
import tensorflow as tf
from customutils.utils import *
from core.basic import *
from core.state_configurations import coherent_state, single_photon, squeezed_vacuum, squeezed_coherent_state
from setup_parameters import *
sess = tf.Session()
# Parameters for states
series_length = 10 # 16 is maximum, EVEN NUMBER
input_series_length = series_length
auxiliary_series_length = series_length
max_power = input_series_length + auxiliary_series_length
# INPUT
input_st = single_photon(input_series_length)
# input_st = coherent_state(input_series_length, alpha=1)
# input_st = squeezed_vacuum(input_series_length, squeezing_amp=1.1, squeezing_phase=0)
# input_st = squeezed_coherent_state(input_series_length, alpha=1, squeezing_amp=0.5, squeezing_phase=0)
print('Input state norm:', get_state_norm(input_st))
# AUXILIARY
# auxiliary_st = single_photon(auxiliary_series_length)
auxiliary_st = coherent_state(auxiliary_series_length, alpha=1)
# auxiliary_st = squeezed_vacuum(auxiliary_series_length, squeezing_amp=0.5, squeezing_phase=0)
# auxiliary_st = squeezed_coherent_state(auxiliary_series_length, alpha=1, squeezing_amp=0.5, squeezing_phase=0)
print('Auxiliary state norm:', get_state_norm(auxiliary_st))
in_state_tf = tf.constant(input_st, tf.complex128)
aux_state_tf = tf.constant(auxiliary_st, tf.complex128)
# A tensor product, returns numpy array
mut_state_unappl = tf.tensordot(
in_state_tf,
aux_state_tf,
axes=0,
name=None
).eval(session=sess)
# The first BS
state_after_bs1_unappl = bs2x2_transform(t1, r1, mut_state_unappl)
grd = 21
# Varying BS2, t2, r2 small
T2_arr = np.linspace(0, 1, grd)
t2_arr = np.sqrt(T2_arr)
r2_arr = np.zeros(grd)
for i in range(grd):
r2_arr[i] = sqrt(1 - pow(t2_arr[i], 2))
ph_inpi = 0.25
phase_mod = ph_inpi * np.pi
log_entr_arr4 = np.zeros(grd)
log_entr_arr2 = np.zeros(grd)
log_neg_arr = np.zeros(grd)
for i in range(grd):
print('step:', i)
t2 = t2_arr[i]
r2 = r2_arr[i]
# The phase modulation
state_after_phmod_unappl = phase_modulation_state(state_after_bs1_unappl, phase_mod)
# The second BS
state_after_bs2_unappl = bs2x2_transform(t2, r2, state_after_phmod_unappl)
state_after_bs2_appl = make_state_appliable(state_after_bs2_unappl)
dens_matrix_2channels = dens_matrix(state_after_bs2_appl)
reduced_dens_matrix4 = trace_channel(dens_matrix_2channels, channel=2)
reduced_dens_matrix2 = trace_channel(dens_matrix_2channels, channel=4)
# Entanglement
log_fn_entropy4 = log_entropy(reduced_dens_matrix4)
log_entr_arr4[i] = log_fn_entropy4
log_fn_entropy2 = log_entropy(reduced_dens_matrix2)
log_entr_arr2[i] = log_fn_entropy2
# print('FN log. entropy:', log_fn_entropy)
log_negativity = negativity(dens_matrix_2channels, neg_type='logarithmic')
log_neg_arr[i] = log_negativity
# print('Log. negativity', log_negativity)
fig, ax = plt.subplots()
ax.plot(np.square(t2_arr), log_entr_arr4, label=r'$Log. FN \ entropy \ 4th \ chan$')
ax.plot(np.square(t2_arr), log_entr_arr2, label=r'$Log. FN \ entropy \ 2nd \ chan$')
ax.plot(np.square(t2_arr), log_neg_arr, label=r'$Log. negativity$')
plt.title('Phase = {0}pi'.format(ph_inpi))
plt.xlabel('$T_{2}$')
plt.ylabel('$Entanglement$')
plt.legend()
plt.grid(True)
plt.show()
# several plots in one
# ph_inpi = 0
# single + vacuum ( coher alpha=0 )
# single_vacuum_entr = log_entr_arr
# single_vacuum_neg = log_neg_arr
# single + coh alpha=1
# single_coh1_entr = log_entr_arr
# single_coh1_neg = log_neg_arr
# single + coh alpha=2
# single_coh2_entr = log_entr_arr
# single_coh2_neg = log_neg_arr
# single + squezed vaacum ksi=0.5
# single_squez_vac_ksi_05_entr = log_entr_arr
# single_squez_vac_ksi_05_neg = log_neg_arr
# single + squezed vaacum ksi=1.1
# single_squez_vac_ksi_1_1_entr = log_entr_arr
# single_squez_vac_ksi_1_1_neg = log_neg_arr
# single + squezed coher alpha=1 ksi=0.5
# single_squez_coh_alpha1_ksi0_5_entr = log_entr_arr
# single_squez_coh_alpha1_ksi0_5_neg = log_neg_arr
# squezed vacuum ksi=0.5 + coher state alpha=1
# squez_vac_ksi_05_coher1_entr = log_entr_arr
# squez_vac_ksi_05_coher1_neg = log_neg_arr
# figures together, entropy
fig, ax = plt.subplots()
ax.plot(np.square(t2_arr), single_coh1_entr, label=r'$|1> + |\alpha=1>$')
ax.plot(np.square(t2_arr), single_coh2_entr, label=r'$|1> + |\alpha=2>$')
ax.plot(np.square(t2_arr), single_squez_vac_ksi_05_entr, label=r'$|1> + |\xi=0.5>$')
ax.plot(np.square(t2_arr), single_squez_vac_ksi_1_1_entr, label=r'$|1> + |\xi=1.1>$')
ax.plot(np.square(t2_arr), single_squez_coh_alpha1_ksi0_5_entr, label=r'$|1> + |\alpha=1, \ \xi=0.5>$')
ax.plot(np.square(t2_arr), squez_vac_ksi_05_coher1_entr, label=r'$|\xi=0.5> + |\alpha=1>$')
plt.title('Phase = {0}pi'.format(ph_inpi))
plt.xlabel('$T_{2}$')
plt.ylabel('$FN \ Entropy$')
plt.xlim([0, 1])
plt.legend()
plt.grid(True)
plt.show()
# negativity
fig, ax = plt.subplots()
ax.plot(np.square(t2_arr), single_coh1_neg, label=r'$|1> + |\alpha=1>$')
ax.plot(np.square(t2_arr), single_coh2_neg, label=r'$|1> + |\alpha=2>$')
ax.plot(np.square(t2_arr), single_squez_vac_ksi_05_neg, label=r'$|1> + |\xi=0.5>$')
ax.plot(np.square(t2_arr), single_squez_vac_ksi_1_1_neg, label=r'$|1> + |\xi=1.1>$')
ax.plot(np.square(t2_arr), single_squez_coh_alpha1_ksi0_5_neg, label=r'$|1> + |\alpha=1, \ \xi=0.5>$')
ax.plot(np.square(t2_arr), squez_vac_ksi_05_coher1_neg, label=r'$|\xi=0.5> + |\alpha=1>$')
plt.title('Phase = {0}pi'.format(ph_inpi))
plt.xlabel('$T_{2}$')
plt.ylabel('$Log \ negativity$')
plt.xlim([0, 1])
plt.legend()
plt.grid(True)
plt.show()
# Varying phase
# phase_arr = np.linspace(0, np.pi, grd)
#
# log_entr_arr2 = np.zeros(grd)
# log_neg_arr2 = np.zeros(grd)
#
# t2 = sqrt(0.999)
# r2 = sqrt(1 - t2**2)
#
# for i in range(grd):
# print('step:', i)
# phase_mod = phase_arr[i]
#
# # The phase modulation
# state_after_phmod_unappl = phase_modulation_state(state_after_bs1_unappl, phase_mod)
#
# # The second BS
# state_after_bs2_unappl = bs2x2_transform(t2, r2, state_after_phmod_unappl)
#
# state_after_bs2_appl = make_state_appliable(state_after_bs2_unappl)
#
# dens_matrix_2channels = dens_matrix(state_after_bs2_appl)
#
# reduced_dens_matrix = trace_channel(dens_matrix_2channels, channel=2)
#
# # Entanglement
# log_fn_entropy = log_entropy(reduced_dens_matrix)
# log_entr_arr2[i] = log_fn_entropy
# # print('FN log. entropy:', log_fn_entropy)
#
# log_negativity = negativity(dens_matrix_2channels, neg_type='logarithmic')
# log_neg_arr2[i] = log_negativity
# # print('Log. negativity', log_negativity)
#
#
# fig, ax = plt.subplots()
# ax.plot(phase_arr, log_entr_arr2, label=r'$Log. FN \ entropy$')
# ax.plot(phase_arr, log_neg_arr2, label=r'$Log. negativity$')
# plt.xlabel('$phase$')
# plt.ylabel('$Entanglement$')
# ax.set_xticks([0, 0.5*np.pi, np.pi])
# ax.set_xticklabels(['0', '$\pi/2$', '$\pi$'])
# plt.legend()
# plt.grid(True)
# plt.show()
| [] |
2024-01-10 | matthewR1993/qscheme | checkouts~check13.py | # A coherent state plus a single photon, EPR variance.
# 1) alpha=1, phase=?, vary: t1, t2
# 2) alpha=1, t2=1, vary: t1, phase
# 3) alpha=1, t2=1/sqrt(2), vary: t1, phase
# 4) alpha=1, t1=1, vary: t2, phase
# 5) alpha=1, t1=1/sqrt(2), vary: t2, phase
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from customutils.utils import *
from core.basic import *
from core.sytem_setup import *
from core.squeezing import *
from core.state_configurations import coherent_state, single_photon
from core.optimized import transformations as trans
# Parameters for states
series_length = 8
input_series_length = series_length
auxiliary_series_length = series_length
max_power = input_series_length + auxiliary_series_length
# INPUT - the state in the first(at the bottom) channel
input_st = single_photon(series_length)
# AUXILIARY - the state in the second(on top) channel
auxiliary_st = coherent_state(auxiliary_series_length, alpha=1)
input_state = np.tensordot(input_st, auxiliary_st, axes=0)
# 1) Works!
# phase = 0.0 * np.pi
#
# t1_grid = 40
# t2_grid = 40
#
# t1_arr = np.linspace(0, 1, t1_grid)
# t2_arr = np.linspace(0, 1, t2_grid)
#
# sz = (t1_grid, t2_grid)
# epr_correl_x = np.zeros(sz, dtype=complex)
#
#
# for n1 in range(len(t1_arr)):
# for n2 in range(len(t2_arr)):
# print('n1, n2:', n1, n2)
# t1 = t1_arr[n1]
# r1 = sqrt(1 - t1**2)
# t2 = t2_arr[n2]
# r2 = sqrt(1 - t2**2)
# # BS1.
# state1_unappl = bs2x2_transform(t1, r1, input_state)
# # Phase modulation.
# state2_unappl = phase_modulation_state(state1_unappl, phase)
# # BS2.
# state3_unappl = bs2x2_transform(t2, r2, state2_unappl)
#
# # Form a density matrix. It is applied.
# dm = dens_matrix(make_state_appliable(state3_unappl))
#
# epr_x, epr_p = erp_squeezing_correlations(dm)
# epr_correl_x[n1, n2] = epr_x
#
#
# print('A real part:', np.sum(np.real(epr_correl_x)))
# print('An image part:', np.sum(np.imag(epr_correl_x)))
#
# print('Minimum:', np.amin(np.real(epr_correl_x)))
# print('Maximum:', np.amax(np.real(epr_correl_x)))
# # Minimum: 0.9999087524316295
# # Maximum: 1.00012260380289
#
#
# plt.imshow(np.real(epr_correl_x), origin='lower', cmap=cm.GnBu_r)
# plt.colorbar()
# plt.xlabel('T2')
# plt.ylabel('T1')
# plt.show()
# 2,3) Works!
# phase_grid = 40
# t1_grid = 40
#
# phase_arr = np.linspace(0, 2 * np.pi, phase_grid)
# t1_arr = np.linspace(0, 1, t1_grid)
# t2_arr = np.array([1])
#
# t2 = t2_arr[0]
# r2 = np.sqrt(1 - t2_arr[0]**2)
#
# sz = (t1_grid, phase_grid)
# epr_correl_x = np.zeros(sz, dtype=complex)
#
# for n1 in range(len(t1_arr)):
# for p in range(len(phase_arr)):
# print('n1, p:', n1, p)
# t1 = t1_arr[n1]
# r1 = sqrt(1 - t1**2)
# phase = phase_arr[p]
# # BS1.
# state1_unappl = bs2x2_transform(t1, r1, input_state)
# # Phase modulation.
# state2_unappl = phase_modulation_state(state1_unappl, phase)
# # BS2.
# state3_unappl = bs2x2_transform(t2, r2, state2_unappl)
#
# # Form a density matrix. It is applied.
# dm = dens_matrix(make_state_appliable(state3_unappl))
#
# epr_x, epr_p = erp_squeezing_correlations(dm)
# epr_correl_x[n1, p] = epr_x
#
#
# print('A real part:', np.sum(np.real(epr_correl_x)))
# print('An image part:', np.sum(np.imag(epr_correl_x)))
#
# print('Minimum:', np.amin(np.real(epr_correl_x)))
# print('Maximum:', np.amax(np.real(epr_correl_x)))
# # Minimum: 0.5007051822120813
# # Maximum: 1.4993403397160232
#
#
# plt.imshow(np.real(epr_correl_x), origin='lower', cmap=cm.GnBu_r)
# plt.colorbar()
# plt.xlabel('phase')
# plt.ylabel('T1')
# plt.show()
# 4, 5) Works
# phase_grid = 40
# t2_grid = 40
#
# phase_arr = np.linspace(0, 2 * np.pi, phase_grid)
# t2_arr = np.linspace(0, 1, t2_grid)
# t1_arr = np.array([1/sqrt(2)])
#
# t1 = t1_arr[0]
# r1 = np.sqrt(1 - t1_arr[0]**2)
#
# sz = (t2_grid, phase_grid)
# epr_correl_x = np.zeros(sz, dtype=complex)
#
# for n2 in range(len(t2_arr)):
# for p in range(len(phase_arr)):
# print('n2, p:', n2, p)
# t2 = t2_arr[n2]
# r2 = sqrt(1 - t2**2)
# phase = phase_arr[p]
# # BS1.
# state1_unappl = bs2x2_transform(t1, r1, input_state)
# # Phase modulation.
# state2_unappl = phase_modulation_state(state1_unappl, phase)
# # BS2.
# state3_unappl = bs2x2_transform(t2, r2, state2_unappl)
#
# # Form a density matrix. It is applied.
# dm = dens_matrix(make_state_appliable(state3_unappl))
#
# epr_x, epr_p = erp_squeezing_correlations(dm)
# epr_correl_x[n2, p] = epr_x
#
#
# print('A real part:', np.sum(np.real(epr_correl_x)))
# print('An image part:', np.sum(np.imag(epr_correl_x)))
#
# print('Minimum:', np.amin(np.real(epr_correl_x)))
# print('Maximum:', np.amax(np.real(epr_correl_x)))
#
#
# plt.imshow(np.real(epr_correl_x), origin='lower', cmap=cm.GnBu_r)
# plt.colorbar()
# plt.xlabel('phase')
# plt.ylabel('T2')
# plt.show()
# With density matrices.
# 1) Works.
# phase = 0.0 * np.pi
#
# t1_grid = 20
# t2_grid = 20
#
# t1_arr = np.linspace(0, 1, t1_grid)
# t2_arr = np.linspace(0, 1, t2_grid)
#
# sz = (t1_grid, t2_grid)
# epr_correl_x = np.zeros(sz, dtype=complex)
#
#
# for n1 in range(len(t1_arr)):
# for n2 in range(len(t2_arr)):
# print('n1, n2:', n1, n2)
# t1 = t1_arr[n1]
# r1 = sqrt(1 - t1**2)
# t2 = t2_arr[n2]
# r2 = sqrt(1 - t2**2)
# # BS1.
# state1_unappl = bs2x2_transform(t1, r1, input_state)
# # Density matrix
# dm1 = dens_matrix(make_state_appliable(state1_unappl))
# # Phase modulation.
# dm2 = phase_modulation(dm1, phase, channel=1)
# # BS2.
# trim_dm = 8
# dm_final = trans.bs_matrix_transform_copt(dm2[:trim_dm, :trim_dm, :trim_dm, :trim_dm].copy(order='C'), t2, r2)
#
# epr_x, epr_p = erp_squeezing_correlations(dm_final)
# epr_correl_x[n1, n2] = epr_x
#
#
# print('A real part:', np.sum(np.real(epr_correl_x)))
# print('An image part:', np.sum(np.imag(epr_correl_x)))
#
# print('Minimum:', np.amin(np.real(epr_correl_x)))
# print('Maximum:', np.amax(np.real(epr_correl_x)))
#
# # trim dm = 7
# # Minimum: 0.997450983060972
# # Maximum: 1.0035315367702382
#
# # trim dm = 8
# # Minimum: 0.9994530876721822
# # Maximum: 1.0007523140729127
#
# plt.imshow(np.real(epr_correl_x), origin='lower', cmap=cm.GnBu_r)
# plt.colorbar()
# plt.xlabel('T2')
# plt.ylabel('T1')
# plt.show()
# 2, 3) Works.
#
# phase_grid = 20
# t1_grid = 20
#
# phase_arr = np.linspace(0, 2 * np.pi, phase_grid)
# t1_arr = np.linspace(0, 1, t1_grid)
# t2_arr = np.array([1/sqrt(2)])
#
# t2 = t2_arr[0]
# r2 = np.sqrt(1 - t2_arr[0]**2)
#
# sz = (t1_grid, phase_grid)
# epr_correl_x = np.zeros(sz, dtype=complex)
#
#
# for n1 in range(len(t1_arr)):
# for p in range(len(phase_arr)):
# print('n1, p:', n1, p)
# t1 = t1_arr[n1]
# r1 = sqrt(1 - t1**2)
# phase = phase_arr[p]
# # BS1.
# state1_unappl = bs2x2_transform(t1, r1, input_state)
# # Density matrix
# dm1 = dens_matrix(make_state_appliable(state1_unappl))
# # Phase modulation.
# dm2 = phase_modulation(dm1, phase, channel=1)
# # BS2.
# trim_dm = 8
# dm_final = trans.bs_matrix_transform_copt(dm2[:trim_dm, :trim_dm, :trim_dm, :trim_dm].copy(order='C'), t2, r2)
#
# epr_x, epr_p = erp_squeezing_correlations(dm_final)
# epr_correl_x[n1, p] = epr_x
#
#
# print('A real part:', np.sum(np.real(epr_correl_x)))
# print('An image part:', np.sum(np.imag(epr_correl_x)))
#
# print('Minimum:', np.amin(np.real(epr_correl_x)))
# print('Maximum:', np.amax(np.real(epr_correl_x)))
#
#
# # series_length = 8, t2 = 1
# # trim dm = 7
# # Minimum: 0.5009536207958811
# # Maximum: 1.4951683245564293
#
# # trim dm = 8
# # Minimum: 0.5022594814429775
# # Maximum: 1.4970759777014475
#
# # series_length = 10, t2 = 1
# # Minimum: 0.5025054547010559
# # Maximum: 1.4970246832205738
#
# # trim dm = 7, grid = 30
# # Minimum: 0.499551541849767
# # Maximum: 1.4965610780599536
#
# # trim dm = 8, grid = 40. Works
# # Minimum: 0.5001827221667734
# # Maximum: 1.4991547456845964
#
#
# plt.imshow(np.real(epr_correl_x), origin='lower', cmap=cm.GnBu_r)
# plt.colorbar()
# plt.xlabel('phase')
# plt.ylabel('T1')
# plt.show()
#
# 4, 5) Works.
# phase_grid = 20
# t2_grid = 20
#
# phase_arr = np.linspace(0, 2 * np.pi, phase_grid)
# t2_arr = np.linspace(0, 1, t2_grid)
# t1_arr = np.array([1/sqrt(2)])
#
# t1 = t1_arr[0]
# r1 = np.sqrt(1 - t1_arr[0]**2)
#
# sz = (t2_grid, phase_grid)
# epr_correl_x = np.zeros(sz, dtype=complex)
#
# for n2 in range(len(t2_arr)):
# for p in range(len(phase_arr)):
# print('n2, p:', n2, p)
# t2 = t2_arr[n2]
# r2 = sqrt(1 - t2**2)
# phase = phase_arr[p]
# # BS1.
# state1_unappl = bs2x2_transform(t1, r1, input_state)
# # Density matrix
# dm1 = dens_matrix(make_state_appliable(state1_unappl))
# # Phase modulation.
# dm2 = phase_modulation(dm1, phase, channel=1)
# # BS2.
# trim_dm = 7
# dm_final = trans.bs_matrix_transform_copt(dm2[:trim_dm, :trim_dm, :trim_dm, :trim_dm].copy(order='C'), t2, r2)
#
# epr_x, epr_p = erp_squeezing_correlations(dm_final)
# epr_correl_x[n2, p] = epr_x
#
#
# print('A real part:', np.sum(np.real(epr_correl_x)))
# print('An image part:', np.sum(np.imag(epr_correl_x)))
#
# print('Minimum:', np.amin(np.real(epr_correl_x)))
# print('Maximum:', np.amax(np.real(epr_correl_x)))
#
# # t1 = 1
# # Minimum: 0.9989777596078151
# # Maximum: 1.0014495898555928
#
# # t1 = 1/sqrt(2)
# # Minimum: 0.4999459102944174
# # Maximum: 1.500491214140784
#
#
# plt.imshow(np.real(epr_correl_x), origin='lower', cmap=cm.GnBu_r)
# plt.colorbar()
# plt.xlabel('phase')
# plt.ylabel('T2')
# plt.show()
# With traces of two channels.
# 1) Works
# phase = 0.5 * np.pi
#
# t1_grid = 20
# t4_grid = 20
#
# t1_arr = np.linspace(0, 1, t1_grid)
# t4_arr = np.linspace(0, 1, t4_grid)
#
# sz = (t1_grid, t4_grid)
# epr_correl_x = np.zeros(sz, dtype=complex)
#
# t2, t3 = 1, 1
# r2, r3 = 0, 0
#
#
# for n1 in range(len(t1_arr)):
# for n4 in range(len(t4_arr)):
# print('n1, n4:', n1, n4)
# t1 = t1_arr[n1]
# r1 = sqrt(1 - t1**2)
# t4 = t4_arr[n4]
# r4 = sqrt(1 - t4**2)
# # BS1.
# state1_unappl = bs2x2_transform(t1, r1, input_state)
#
# # BS2 and BS3.
# state_aft2bs_unappl = trans.two_bs2x4_transform_copt(t2, r2, t3, r3, state1_unappl)
#
# # The detection event.
# # Gives non-normalised state.
# state_after_dett_unappl = detection(state_aft2bs_unappl, detection_event='NONE')
#
# # Calculating the norm.
# norm_after_det = state_norm_opt(state_after_dett_unappl)
# print('Norm after det.:', norm_after_det)
#
# # The normalised state.
# state_after_dett_unappl_norm = state_after_dett_unappl / norm_after_det
#
# # Trim the state, 8 is min.
# trim_state = 8
# state_after_dett_unappl_norm_tr = state_after_dett_unappl_norm[:trim_state, :trim_state, :trim_state,
# :trim_state]
# # sm_state = np.sum(np.abs(state_after_dett_unappl_norm)) - np.sum(np.abs(state_after_dett_unappl_norm[:trim_state, :trim_state, :trim_state, :trim_state]))
# # print('State trim norm:', sm_state)
#
# # Building dens. matrix and trace.
# dens_matrix_2ch = dens_matrix_with_trace_opt(state_after_dett_unappl_norm_tr, state_after_dett_unappl_norm_tr)
#
# # Phase modulation.
# dm2 = phase_modulation(dens_matrix_2ch, phase, channel=1)
#
# # The transformation at last BS, 7 is min.
# trim_dm = 7
# dm_final = trans.bs_matrix_transform_copt(
# dm2[:trim_dm, :trim_dm, :trim_dm, :trim_dm].copy(order='C'), t4, r4)
#
# epr_x, epr_p = erp_squeezing_correlations(dm_final)
# epr_correl_x[n1, n4] = epr_x
# print('EPR_X:', epr_x)
#
#
# print('A real part:', np.sum(np.real(epr_correl_x)))
# print('An image part:', np.sum(np.imag(epr_correl_x)))
#
# print('Minimum:', np.amin(np.real(epr_correl_x)))
# print('Maximum:', np.amax(np.real(epr_correl_x)))
#
#
# # phase = 0.0
# # Max = 1
# # Min = 1
#
# # phase = 0.25
# # Max = 1
# # Min = 0.65
#
# # phase = 0.5
# # Minimum: 0.4992167994992098
# # Maximum: 1.0014598540145987
#
# # phase = 1.5
# # Minimum: 0.998977761201982
# # Maximum: 1.5012310931085122
#
#
# plt.imshow(np.real(epr_correl_x), origin='lower', cmap=cm.GnBu_r)
# plt.colorbar()
# plt.xlabel('T4')
# plt.ylabel('T1')
# plt.show()
# 2, 3)
# phase_grid = 20
# t1_grid = 20
#
# phase_arr = np.linspace(0, 2 * np.pi, phase_grid)
# t1_arr = np.linspace(0, 1, t1_grid)
# t4_arr = np.array([1/sqrt(2)])
#
# t4 = t4_arr[0]
# r4 = np.sqrt(1 - t4_arr[0]**2)
#
# t2, t3 = 1, 1
# r2, r3 = 0, 0
#
# sz = (t1_grid, phase_grid)
# epr_correl_x = np.zeros(sz, dtype=complex)
#
#
# for n1 in range(len(t1_arr)):
# for p in range(len(phase_arr)):
# print('n1, p:', n1, p)
# t1 = t1_arr[n1]
# r1 = sqrt(1 - t1**2)
# phase = phase_arr[p]
# # BS1.
# state1_unappl = bs2x2_transform(t1, r1, input_state)
#
# # BS2 and BS3.
# state_aft2bs_unappl = trans.two_bs2x4_transform_copt(t2, r2, t3, r3, state1_unappl)
#
# # The detection event.
# # Gives non-normalised state.
# state_after_dett_unappl = detection(state_aft2bs_unappl, detection_event='NONE')
#
# # Calculating the norm.
# norm_after_det = state_norm_opt(state_after_dett_unappl)
# print('Norm after det.:', norm_after_det)
#
# # The normalised state.
# state_after_dett_unappl_norm = state_after_dett_unappl / norm_after_det
#
# # Trim the state, 8 is min.
# trim_state = 8
# state_after_dett_unappl_norm_tr = state_after_dett_unappl_norm[:trim_state, :trim_state, :trim_state,
# :trim_state]
# # sm_state = np.sum(np.abs(state_after_dett_unappl_norm)) - np.sum(np.abs(state_after_dett_unappl_norm[:trim_state, :trim_state, :trim_state, :trim_state]))
# # print('State trim norm:', sm_state)
#
# # Building dens. matrix and trace.
# dens_matrix_2ch = dens_matrix_with_trace_opt(state_after_dett_unappl_norm_tr, state_after_dett_unappl_norm_tr)
#
# # Phase modulation.
# dm2 = phase_modulation(dens_matrix_2ch, phase, channel=1)
#
# # The transformation at last BS, 7 is min.
# trim_dm = 7
# dm_final = trans.bs_matrix_transform_copt(
# dm2[:trim_dm, :trim_dm, :trim_dm, :trim_dm].copy(order='C'), t4, r4)
#
# epr_x, epr_p = erp_squeezing_correlations(dm_final)
# epr_correl_x[n1, p] = epr_x
#
#
# print('A real part:', np.sum(np.real(epr_correl_x)))
# print('An image part:', np.sum(np.imag(epr_correl_x)))
#
# print('Minimum:', np.amin(np.real(epr_correl_x)))
# print('Maximum:', np.amax(np.real(epr_correl_x)))
#
# # t4 = 1
# # Minimum: 0.5009383740280302
# # Maximum: 1.495183630554327
#
# # t4 = 1/sqrt(2)
# # Minimum: 0.5028703337076682
# # Maximum: 1.4975623994401666
#
# plt.imshow(np.real(epr_correl_x), origin='lower', cmap=cm.GnBu_r)
# plt.colorbar()
# plt.xlabel('phase')
# plt.ylabel('T1')
# plt.show()
# 4, 5)
phase_grid = 20
t4_grid = 20
phase_arr = np.linspace(0, 2 * np.pi, phase_grid)
t4_arr = np.linspace(0, 1, t4_grid)
t1_arr = np.array([1/sqrt(2)])
t1 = t1_arr[0]
r1 = np.sqrt(1 - t1_arr[0]**2)
t2, t3 = 1, 1
r2, r3 = 0, 0
det = 'FIRST'
sz = (t4_grid, phase_grid)
epr_correl_x = np.zeros(sz, dtype=complex)
for n4 in range(len(t4_arr)):
for p in range(len(phase_arr)):
print('n4, p:', n4, p)
t4 = t4_arr[n4]
r4 = sqrt(1 - t4**2)
phase = phase_arr[p]
# BS1.
state1_unappl = bs2x2_transform(t1, r1, input_state)
# BS2 and BS3.
state_aft2bs_unappl = trans.two_bs2x4_transform_copt(t2, r2, t3, r3, state1_unappl)
# The detection event.
# Gives non-normalised state.
state_after_dett_unappl = detection(state_aft2bs_unappl, detection_event=det)
# Calculating the norm.
norm_after_det = state_norm_opt(state_after_dett_unappl)
print('Norm after det.:', norm_after_det)
# The normalised state.
state_after_dett_unappl_norm = state_after_dett_unappl / norm_after_det
# Trim the state, 8 is min.
trim_state = 8
state_after_dett_unappl_norm_tr = state_after_dett_unappl_norm[:trim_state, :trim_state, :trim_state,
:trim_state]
# sm_state = np.sum(np.abs(state_after_dett_unappl_norm)) - np.sum(np.abs(state_after_dett_unappl_norm[:trim_state, :trim_state, :trim_state, :trim_state]))
# print('State trim norm:', sm_state)
# Building dens. matrix and trace.
dens_matrix_2ch = dens_matrix_with_trace_opt(state_after_dett_unappl_norm_tr, state_after_dett_unappl_norm_tr)
# Phase modulation.
dm2 = phase_modulation(dens_matrix_2ch, phase, channel=1)
# The transformation at last BS, 7 is min.
trim_dm = 7
dm_final = trans.bs_matrix_transform_copt(
dm2[:trim_dm, :trim_dm, :trim_dm, :trim_dm].copy(order='C'), t4, r4)
epr_x, epr_p = erp_squeezing_correlations(dm_final)
epr_correl_x[n4, p] = epr_x
print('EPR_X:', epr_x)
print('A real part:', np.sum(np.real(epr_correl_x)))
print('An image part:', np.sum(np.imag(epr_correl_x)))
print('Minimum:', np.amin(np.real(epr_correl_x)))
print('Maximum:', np.amax(np.real(epr_correl_x)))
# det=NONE
# t1 = 1
# Minimum: 0.998977761201982
# Maximum: 1.0014598540145987
# t1 = 1/sqrt(2)
# Minimum: 0.49993062980123876
# Maximum: 1.5005065581671158
plt.imshow(np.real(epr_correl_x), origin='lower', cmap=cm.GnBu_r)
plt.colorbar()
plt.xlabel('phase')
plt.ylabel('T4')
plt.show()
| [] |
2024-01-10 | matthewR1993/qscheme | checkouts~check4.py | # Two beam splitters with loses, INCORRECT description of losses.
import sys
try:
sys.path.append('/usr/local/lib/python3.5/dist-packages')
except: pass
import tensorflow as tf
from customutils.utils import *
from core.basic import *
from core.state_configurations import coherent_state, single_photon
from setup_parameters import *
sess = tf.Session()
# Parameters for states
series_length = 14
input_series_length = series_length
auxiliary_series_length = series_length
max_power = input_series_length + auxiliary_series_length
# INPUT
# input_st = single_photon(series_length)
input_st = coherent_state(input_series_length, alpha=1)
print('Input state norm:', get_state_norm(input_st))
# AUXILIARY
auxiliary_st = single_photon(series_length)
# auxiliary_st = coherent_state(auxiliary_series_length, alpha=1)
print('Auxiliary state norm:', get_state_norm(auxiliary_st))
in_state_tf = tf.constant(input_st, tf.float64)
aux_state_tf = tf.constant(auxiliary_st, tf.float64)
# A tensor product, returns numpy array
mut_state_unappl = tf.tensordot(
in_state_tf,
aux_state_tf,
axes=0,
name=None
).eval(session=sess)
# Adding absorption
a1 = 0.8
T1_max = 1 - a1**2
t1 = sqrt(T1_max/2)
r1 = sqrt(1 - pow(t1, 2) - pow(a1, 2))
# The first BS
state_after_bs1_unappl = bs2x2_transform(t1, r1, mut_state_unappl)
grd = 30
# Varying BS2
a2 = 0.0
t2_max = sqrt(1 - a2**2)
t2_arr = np.linspace(0, t2_max, grd)
r2_arr = np.zeros(grd)
for i in range(grd):
r2_arr[i] = sqrt(1 - pow(t2_arr[i], 2) - pow(a2, 2))
ph_inpi = 0.0
phase_mod = ph_inpi * np.pi
log_entr_arr = np.zeros(grd)
log_neg_arr = np.zeros(grd)
for i in range(grd):
print('step:', i)
t2 = t2_arr[i]
r2 = r2_arr[i]
# The phase modulation
state_after_phmod_unappl = phase_modulation_state(state_after_bs1_unappl, phase_mod)
# The second BS
state_after_bs2_unappl = bs2x2_transform(t2, r2, state_after_phmod_unappl)
state_after_bs2_appl = make_state_appliable(state_after_bs2_unappl)
dens_matrix_2channels = dens_matrix(state_after_bs2_appl)
reduced_dens_matrix = trace_channel(dens_matrix_2channels, channel=2)
# Entanglement
log_fn_entropy = log_entropy(reduced_dens_matrix)
log_entr_arr[i] = log_fn_entropy
# print('FN log. entropy:', log_fn_entropy)
log_negativity = negativity(dens_matrix_2channels, neg_type='logarithmic')
log_neg_arr[i] = log_negativity
# print('Log. negativity', log_negativity)
fig, ax = plt.subplots()
ax.plot(np.square(t2_arr), log_entr_arr, label=r'$Log. FN \ entropy$')
ax.plot(np.square(t2_arr), log_neg_arr, label=r'$Log. negativity$')
plt.title('Phase = {0}pi, a1 = {1}, a2 = {2}'.format(ph_inpi, a1, a2))
plt.xlabel('$T_{2}$')
plt.ylabel('$Entanglement$')
plt.legend()
plt.grid(True)
plt.show()
| [] |
2024-01-10 | matthewR1993/qscheme | checkouts~check1.py | # Checking out properties for two coherent states, entanglement should be zero.
import sys
try:
sys.path.append('/usr/local/lib/python3.5/dist-packages')
except: pass
import tensorflow as tf
from customutils.utils import *
from core.basic import *
from core.state_configurations import coherent_state, single_photon
from setup_parameters import *
sess = tf.Session()
# Parameters for states
series_length = 15
input_series_length = series_length
auxiliary_series_length = series_length
max_power = input_series_length + auxiliary_series_length
# INPUT
# input_st = single_photon(series_length)
input_st = coherent_state(input_series_length, alpha=1)
print('Input state norm:', get_state_norm(input_st))
# AUXILIARY
# auxiliary_st = single_photon(series_length)
auxiliary_st = coherent_state(auxiliary_series_length, alpha=1)
print('Auxiliary state norm:', get_state_norm(auxiliary_st))
in_state_tf = tf.constant(input_st, tf.float64)
aux_state_tf = tf.constant(auxiliary_st, tf.float64)
# tensor product, returns numpy array
mut_state_unappl = tf.tensordot(
in_state_tf,
aux_state_tf,
axes=0,
name=None
).eval(session=sess)
# First BS
state_after_bs_unappl = bs2x2_transform(t1, r1, mut_state_unappl)
state_after_bs_appl = make_state_appliable(state_after_bs_unappl)
# dens_matrix_2channels = dens_matrix(state_after_bs_unappl)
dens_matrix_2channels = dens_matrix(state_after_bs_appl)
dens_matrix = trace_channel(dens_matrix_2channels, channel=2)
# Entropy
log_fn_entropy = log_entropy(dens_matrix)
print('FN log. entropy:', log_fn_entropy)
print('Lin. entropy', linear_entropy(dens_matrix))
log_negativity = negativity(dens_matrix_2channels, neg_type='logarithmic')
print('Log. negativity', log_negativity)
# Fuckin works, entanglement is 0!
| [] |
2024-01-10 | matthewR1993/qscheme | checkouts~check12.py | # Measuring performance.
import sys
import time
try:
sys.path.append('/usr/local/lib/python3.5/dist-packages')
except: pass
from time import gmtime, strftime
from numpy.testing import assert_array_equal, assert_allclose
from customutils.utils import *
from core.basic import *
from core.squeezing import *
from core.state_configurations import coherent_state, single_photon, fock_state
from setup_parameters import *
from core.optimized import transformations as trans
import timeit
# Parameters for states
series_length = 10
input_series_length = series_length
auxiliary_series_length = series_length
max_power = input_series_length + auxiliary_series_length
# INPUT - the state in the first(at the bottom) channel
input_st = single_photon(series_length)
# input_st = coherent_state(input_series_length, alpha=1)
# input_st = fock_state(n=2, series_length=input_series_length)
print('Input state norm:', get_state_norm(input_st))
# AUXILIARY - the state in the second(on top) channel
auxiliary_st = single_photon(series_length)
# auxiliary_st = coherent_state(auxiliary_series_length, alpha=1)
# auxiliary_st = fock_state(n=2, series_length=auxiliary_series_length)
print('Auxiliary state norm:', get_state_norm(auxiliary_st))
# Measurement event, detectors configuration:
# DET_CONF = 'BOTH' # both 1st and 3rd detectors clicked
DET_CONF = 'FIRST' # 1st detector is clicked
# DET_CONF = 'THIRD' # 3rd detector is clicked
# DET_CONF = 'NONE' # None of detectors were clicked
mut_state_unappl = np.tensordot(input_st, auxiliary_st, axes=0)
# The phase difference before last BS
ph_inpi = 0.0
phase_diff = ph_inpi * np.pi
# BS2, BS3.
t1 = sqrt(0.5)
r1 = sqrt(1 - t1**2)
t4 = sqrt(0.5)
r4 = sqrt(1 - t4**2)
t2 = sqrt(0.5)
r2 = sqrt(1 - t2**2)
t3 = sqrt(0.5)
r3 = sqrt(1 - t3**2)
# Measurements start here.
start1 = time.time()
# First BS.
start = time.time()
state_after_bs_unappl = bs2x2_transform(t1, r1, mut_state_unappl)
end = time.time()
print('First BS time:', end - start)
# 2d and 3rd BS.
start = time.time()
state_aft2bs_unappl = two_bs2x4_transform(t2, r2, t3, r3, state_after_bs_unappl)
end = time.time()
print('BS 2 and 3 time:', end - start)
# np.sum(state_after_bs_unappl[:trm, :trm]) - np.sum(state_after_bs_unappl)
start = time.time()
state_aft2bs_unappl_opt = two_bs2x4_transform_opt(t2, r2, t3, r3, state_after_bs_unappl)
end = time.time()
print('BS 2 and 3 time OPT:', end - start)
print(np.sum(state_aft2bs_unappl_opt - state_aft2bs_unappl))
start = time.time()
state_aft2bs_unappl_opt2 = trans.two_bs2x4_transform_copt(t2, r2, t3, r3, state_after_bs_unappl)
end = time.time()
print('BS 2 and 3 time OPT 2:', end - start)
print(np.sum(state_aft2bs_unappl_opt2 - state_aft2bs_unappl))
start = time.time()
det_prob = det_probability(state_aft2bs_unappl, detection_event=DET_CONF)
end = time.time()
print('Det prob. time:', end - start)
# The detection event.
start = time.time()
# Gives non-normalised state.
state_after_dett_unappl = detection(state_aft2bs_unappl, detection_event=DET_CONF)
end = time.time()
print('Detection:', end - start)
# Calculating the norm.
# start = time.time()
# norm_after_det = state_norm(state_after_dett_unappl)
# end = time.time()
# print('Calc norm after det:', end - start)
# print('Norm after det.:', norm_after_det)
# The normalised state.
# New norm
start = time.time()
norm_after_det_new = state_norm_opt(state_after_dett_unappl)
end = time.time()
print('State norm after det NEW:', end - start,)
# print(norm_after_det - norm_after_det_new)
state_after_dett_unappl_norm = state_after_dett_unappl / norm_after_det_new
trim_st = 8
state_after_dett_unappl_norm_tr = state_after_dett_unappl_norm[:trim_st, :trim_st, :trim_st, :trim_st]
# Trimmed! 2 sec.
# start = time.time()
# dens_matrix_2channels = dens_matrix_with_trace(state_after_dett_unappl_norm_tr, state_after_dett_unappl_norm_tr)
# end = time.time()
#print('Dens. matrix with trace, TRIMMED:', end - start, '\n')
start = time.time()
dens_matrix_2channels_opt = dens_matrix_with_trace_opt(state_after_dett_unappl_norm_tr, state_after_dett_unappl_norm_tr)
end = time.time()
print('Dens. matrix with trace, OPT:', end - start)
# print('Diff', np.sum(dens_matrix_2channels - dens_matrix_2channels_opt))
# Phase modulation.
start = time.time()
dens_matrix_2channels_withph = phase_modulation(dens_matrix_2channels_opt, phase_diff)
end = time.time()
print('Phase modulation:', end - start)
# Dens matrix BS transform.
trim_size = 7
start = time.time()
final_dens_matrix = bs_densmatrix_transform(dens_matrix_2channels_withph[:trim_size, :trim_size, :trim_size, :trim_size], t4, r4)
end = time.time()
print('BS4 density matrix transformation:', end - start)
start = time.time()
state_in = dens_matrix_2channels_withph[:trim_size, :trim_size, :trim_size, :trim_size].copy(order='C')
final_dens_matrix_new2 = trans.bs_matrix_transform_copt(state_in, t4, r4)
end = time.time()
print('BS4 density matrix transformation NEW 2:', end - start)
print(np.sum(final_dens_matrix - final_dens_matrix_new2))
# print(timeit.timeit('trans.bs_matrix_transform_copt(state_in, t4, r4)', globals=globals(), number=20) / 20)
# 0.9265
start = time.time()
dX, dP = squeezing_quadratures(final_dens_matrix, channel=1)
end = time.time()
print('Squeez quadr.:', end - start)
# ERP correlations.
start = time.time()
epr_x, epr_p = erp_squeezing_correlations(final_dens_matrix)
end = time.time()
print('EPR:', end - start)
| [] |
2024-01-10 | matthewR1993/qscheme | checkouts~check5.py | # Checking influence of absorption as position of channels with loses.
# A coherent state and a single photon with two beam splitters and phase modul.
# Absorptions comute!!!
import sys
try:
sys.path.append('/usr/local/lib/python3.5/dist-packages')
except: pass
import matplotlib.pyplot as plt
from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D
import numpy as np
import tensorflow as tf
from qutip import (wigner, super_tensor, Qobj)
from time import gmtime, strftime
from customutils.utils import *
from core.basic import *
from core.state_configurations import coherent_state, single_photon, squeezed_vacuum, squeezed_coherent_state
from setup_parameters import *
sess = tf.Session()
# Parameters for states
series_length = 4
input_series_length = series_length
auxiliary_series_length = series_length
max_power = input_series_length + auxiliary_series_length
# INPUT
input_st = single_photon(input_series_length)
print('Input state norm:', get_state_norm(input_st))
# AUXILIARY
auxiliary_st = single_photon(auxiliary_series_length)
print('Auxiliary state norm:', get_state_norm(auxiliary_st))
in_state_tf = tf.constant(input_st, tf.complex128)
aux_state_tf = tf.constant(auxiliary_st, tf.complex128)
# A tensor product, returns numpy array
mut_state_unappl = tf.tensordot(
in_state_tf,
aux_state_tf,
axes=0,
name=None
).eval(session=sess)
# First, channels with loses are located before BS
t1 = sqrt(0.6)
r1 = sqrt(1 - pow(t1, 2))
t2 = sqrt(0.5)
r2 = sqrt(1 - pow(t2, 2))
t3 = sqrt(0.5)
r3 = sqrt(1 - pow(t3, 2))
state_aft2bs_unappl = two_bs2x4_transform(t1, r1, t2, r2, mut_state_unappl)
# Make state appl
state_aft2bs_appl = make_state_appliable_4ch(state_aft2bs_unappl)
# Form density matrix and trace
dm = dens_matrix_4ch(state_aft2bs_appl)
# Trace loosy channels 1st and 3rd
size = len(dm)
dm_aft_trace_appl = np.zeros((size,) * 4, dtype=complex)
for p2 in range(size):
for p2_ in range(size):
for p4 in range(size):
for p4_ in range(size):
matrix_sum = 0
for k1 in range(size):
for k3 in range(size):
matrix_sum = matrix_sum + dm[k1, p2, k3, p4, k1, p2_, k3, p4_]
dm_aft_trace_appl[p2, p4, p2_, p4_] = matrix_sum
# last BS transformation
final_dens_matrix = bs_densmatrix_transform(dm_aft_trace_appl, t3, r3)
# Second method.
# First, channels with loses are located after BS
state_aft_1st_bs_unappl = bs2x2_transform(t3, r3, mut_state_unappl)
# r1, t1, r2, t2
state_aft2bs_unappl_2 = two_bs2x4_transform(t1, r1, t2, r2, state_aft_1st_bs_unappl)
# Make state appl
state_aft2bs_appl_2 = make_state_appliable_4ch(state_aft2bs_unappl_2)
# Form density matrix and trace
dm_2 = dens_matrix_4ch(state_aft2bs_appl_2)
# Trace loosy channels
size = len(dm_2)
dm_aft_trace_appl_2 = np.zeros((size,) * 4, dtype=complex)
# trace 1st and 3rd channels
for p2 in range(size):
for p2_ in range(size):
for p4 in range(size):
for p4_ in range(size):
matrix_sum = 0
for k1 in range(size):
for k3 in range(size):
matrix_sum = matrix_sum + dm_2[k1, p2_, k3, p4, k1, p2_, k3, p4_]
dm_aft_trace_appl_2[p2, p4, p2_, p4_] = matrix_sum
matr_diff = dm_aft_trace_appl_2 - final_dens_matrix[:7, :7, :7, :7]
densm_diff = np.sum(np.abs(matr_diff))
# prob distr diff
pd1 = prob_distr(final_dens_matrix[:7, :7, :7, :7])
pd2 = prob_distr(dm_aft_trace_appl_2)
pd_diff = pd1 - pd2
prob_diff = np.sum(np.abs(pd_diff))
print('Prob diff:', prob_diff)
# Dens matr abs diff.
plt.matshow(np.abs(pd_diff))
plt.title('Abs(diff_dens)')
plt.colorbar()
plt.show()
| [] |
2024-01-10 | matthewR1993/qscheme | scripts~grid_calc.py | import sys
import platform
if platform.system() == 'Linux':
sys.path.append('/usr/local/lib/python3.5/dist-packages')
import numpy as np
import matplotlib.pyplot as plt
from time import gmtime, strftime
import argparse
from customutils.utils import *
from core.basic import *
from core.sytem_setup import *
from core.squeezing import *
from core.state_configurations import coherent_state, single_photon, fock_state
# Parameters for states
series_length = 10
input_series_length = series_length
auxiliary_series_length = series_length
max_power = input_series_length + auxiliary_series_length
# INPUT - the state in the first(at the bottom) channel
# input_st = single_photon(series_length)
input_st = coherent_state(input_series_length, alpha=1.0)
# input_st = fock_state(n=2, series_length=input_series_length)
print('Input state norm:', get_state_norm(input_st))
# AUXILIARY - the state in the second(on top) channel
auxiliary_st = single_photon(series_length)
# auxiliary_st = coherent_state(auxiliary_series_length, alpha=1)
# auxiliary_st = fock_state(n=2, series_length=auxiliary_series_length)
print('Auxiliary state norm:', get_state_norm(auxiliary_st))
# Measurement event, detectors configuration:
# DET_CONF = 'BOTH' # both 1st and 3rd detectors clicked
DET_CONF = 'FIRST' # 1st detector is clicked
# DET_CONF = 'THIRD' # 3rd detector is clicked
# DET_CONF = 'NONE' # None of detectors were clicked
# Building a mutual state via tensor product, that returns numpy array.
mut_state_unappl = np.tensordot(input_st, auxiliary_st, axes=0)
phi_inpi_arr = np.linspace(1.2, 1.8, 31)
epr_X_phi_arr = np.zeros(len(phi_inpi_arr), dtype=complex)
probab_phi_arr = np.zeros(len(phi_inpi_arr), dtype=complex)
# The phase difference before last BS
for k in range(len(phi_inpi_arr)):
ph_inpi = phi_inpi_arr[k]
# ph_inpi = 1.5
phase_diff = ph_inpi * np.pi
# BS grids.
r1_grid = 1
r4_grid = 1
r2_grid = 1
r3_grid = 1
# BS values range.
T1_min = 0.78
T1_max = 0.78
T4_min = 1.0
T4_max = 1.0
T2_min = 0.84
T2_max = 0.84
T3_min = 0.12
T3_max = 0.12
# Varying BSs.
t1_array, r1_array = bs_parameters(T1_min, T1_max, r4_grid)
t4_array, r4_array = bs_parameters(T4_min, T4_max, r4_grid)
t2_array, r2_array = bs_parameters(T2_min, T2_max, r2_grid)
t3_array, r3_array = bs_parameters(T3_min, T3_max, r3_grid)
sz = (r1_grid, r4_grid, r2_grid, r3_grid)
det_prob_array = np.zeros(sz, dtype=complex)
log_entropy_subs1_array = np.zeros(sz, dtype=complex)
log_entropy_subs2_array = np.zeros(sz, dtype=complex)
lin_entropy_subs1 = np.zeros(sz, dtype=complex)
lin_entropy_subs2 = np.zeros(sz, dtype=complex)
log_negativity = np.zeros(sz, dtype=complex)
mut_information = np.zeros(sz, dtype=complex)
full_fn_entropy = np.zeros(sz, dtype=complex)
sqeez_dX = np.zeros(sz, dtype=complex)
sqeez_dP = np.zeros(sz, dtype=complex)
epr_correl_x = np.zeros(sz, dtype=complex)
epr_correl_p = np.zeros(sz, dtype=complex)
norm_after_det_arr = np.zeros(sz, dtype=complex)
# Start time.
print('Started at:', strftime("%Y-%m-%d %H:%M:%S", gmtime()))
for n1 in range(r1_grid):
for n4 in range(r4_grid):
for n2 in range(r2_grid):
for n3 in range(r3_grid):
print('Steps [n1, n4, n2, n3]:', n1, n4, n2, n3)
bs_params = {
't1': t1_array[n1],
't4': t4_array[n4],
't2': t2_array[n2],
't3': t3_array[n3],
}
final_dens_matrix, det_prob, norm = process_all(mut_state_unappl, bs_params, phase_diff=phase_diff, det_event=DET_CONF)
det_prob_array[n1, n4, n2, n3] = det_prob
norm_after_det_arr[n1, n4, n2, n3] = norm
# Trace one channel out of final state
final_traced_subs1 = trace_channel(final_dens_matrix, channel=4)
# print('trace of final reduced matrix 2nd channel:', np.trace(final_traced_subs1))
# Other channel traced
final_traced_subs2 = trace_channel(final_dens_matrix, channel=2)
# print('trace of final reduced matrix 4th channel:', np.trace(final_traced_subs2))
# Calculate entropy
# log_entanglement_subs1 = log_entropy(final_traced_subs1)
# log_entanglement_subs2 = log_entropy(final_traced_subs2)
# log_entropy_subs1_array[n1, n4, n2, n3] = log_entanglement_subs1
# log_entropy_subs2_array[n1, n4, n2, n3] = log_entanglement_subs2
# Full entropy and the mutual information
# final_reorg_matr = reorganise_dens_matrix(final_dens_matrix)
# full_entr = log_entropy(final_reorg_matr)
# mut_information[n1, n4, n2, n3] = log_entanglement_subs1 + log_entanglement_subs2 - full_entr
# full_fn_entropy[n1, n4, n2, n3] = full_entr
log_negativity[n1, n4, n2, n3] = negativity(final_dens_matrix, neg_type='logarithmic')
# print('Log. negativity: ', log_negativity[n1, n4, n2, n3])
# Squeezing quadratures.
dX, dP = squeezing_quadratures(final_dens_matrix, channel=1)
# print('dX:', dX, ' dP:', dP)
sqeez_dX[n1, n4, n2, n3] = dX
sqeez_dP[n1, n4, n2, n3] = dP
# ERP correlations.
epr_x, epr_p = erp_squeezing_correlations(final_dens_matrix)
epr_correl_x[n1, n4, n2, n3] = epr_x
epr_correl_p[n1, n4, n2, n3] = epr_p
# print('epr_X:', epr_x, ' epr_P:', epr_p)
# print('dXdP:', sqeez_dX[0, 0, 0, 0] * sqeez_dP[0, 0, 0, 0])
# print('EPR dXdP:', epr_correl_x[0, 0, 0, 0] * epr_correl_p[0, 0, 0, 0])
# print('EPR X:', np.sqrt(2) * epr_correl_x[0, 0, 0, 0])
# print('EPR P:', epr_correl_p[0, 0, 0, 0])
# print('Prob of det:', det_prob_array[0, 0, 0, 0])
# print('Norm after det:', norm_after_det_arr[0, 0, 0, 0])
epr_X_phi_arr[k] = np.sqrt(2) * epr_correl_x[0, 0, 0, 0]
probab_phi_arr[k] = det_prob_array[0, 0, 0, 0]
plt.plot(phi_inpi_arr, epr_X_phi_arr)
plt.xlabel('$Phase, [\pi]$')
plt.ylabel(r'$\sqrt{2} \ \Delta[X^{(1)} - X^{(2)}]^{(out)}$')
plt.title('T1: {}, T4: {}, T2: {}, T3: {}'.format(T1_max, T4_max, T2_max, T3_max))
plt.grid(True)
plt.show()
# plt.plot(phi_inpi_arr, probab_phi_arr)
# plt.xlabel('$Phase, [\pi]$')
# plt.xlabel('$Probability$')
# plt.show()
| [] |
2024-01-10 | matthewR1993/qscheme | scripts~epr_t2_t4.py | import numpy as np
from time import gmtime, strftime
from customutils.utils import *
from core.basic import *
from core.sytem_setup import *
from core.squeezing import *
from core.state_configurations import coherent_state, single_photon, fock_state
# Parameters for states
series_length = 10
input_series_length = series_length
auxiliary_series_length = series_length
max_power = input_series_length + auxiliary_series_length
# INPUT - the state in the first(at the bottom) channel. (chan-1).
input_st = single_photon(series_length)
# input_st = coherent_state(input_series_length, alpha=1)
# input_st = fock_state(n=2, series_length=input_series_length)
print('Input state norm:', get_state_norm(input_st))
# AUXILIARY - the state in the second(on top) channel. (chan-2).
# auxiliary_st = single_photon(series_length)
auxiliary_st = coherent_state(auxiliary_series_length, alpha=1)
# auxiliary_st = fock_state(n=2, series_length=auxiliary_series_length)
print('Auxiliary state norm:', get_state_norm(auxiliary_st))
states_config = 'single(chan-1)_coher(chan-2)'
# states_config = 'coher(chan-1)_single(chan-2)'
# states_config = 'single(chan-1)_single(chan-2)'
# Measurement event, detectors configuration:
# DET_CONF = 'BOTH' # both 1st and 3rd detectors clicked
DET_CONF = 'FIRST' # 1st detector is clicked
# DET_CONF = 'THIRD' # 3rd detector is clicked
# DET_CONF = 'NONE' # None of detectors were clicked
# DET_CONF = args.det
mut_state_unappl = np.tensordot(input_st, auxiliary_st, axes=0)
# The phase difference before last BS
ph_inpi = 0.0
# ph_inpi = args.phase
phase_diff = ph_inpi * np.pi
phase_mod_channel = 1
save_root = '/Users/matvei/PycharmProjects/qscheme/results/res30/'
# save_root = '/home/matvei/qscheme/results/res27/'
fname = 'disabled_det_{}_phase-{:.4f}pi_det-{}_phase_chan-{}.npy'.format(states_config, ph_inpi, DET_CONF, phase_mod_channel)
print('Saving path:', save_root + fname)
# BS grids.
r1_grid = 1
r4_grid = 41
r2_grid = 41
r3_grid = 1
min_bound = 1e-5
max_bound = 1 - 1e-5
# BS values range.
T1_min = 0.7
T1_max = 0.7
T4_min = 0.0
T4_max = 1.0
T2_min = min_bound
T2_max = max_bound
T3_min = 1
T3_max = 1
# Varying BSs. Small t, r parameters, with step regarding to big "T".
t1_array, r1_array = bs_parameters(T1_min, T1_max, r1_grid)
t4_array, r4_array = bs_parameters(T4_min, T4_max, r4_grid)
t2_array, r2_array = bs_parameters(T2_min, T2_max, r2_grid)
t3_array, r3_array = bs_parameters(T3_min, T3_max, r3_grid)
sz = (r1_grid, r4_grid, r2_grid, r3_grid)
det_prob_array = np.zeros(sz, dtype=complex)
log_entropy_subs1_array = np.zeros(sz, dtype=complex)
log_entropy_subs2_array = np.zeros(sz, dtype=complex)
lin_entropy_subs1 = np.zeros(sz, dtype=complex)
lin_entropy_subs2 = np.zeros(sz, dtype=complex)
log_negativity = np.zeros(sz, dtype=complex)
mut_information = np.zeros(sz, dtype=complex)
full_fn_entropy = np.zeros(sz, dtype=complex)
sqeez_dX = np.zeros(sz, dtype=complex)
sqeez_dP = np.zeros(sz, dtype=complex)
epr_correl_x = np.zeros(sz, dtype=complex)
epr_correl_p = np.zeros(sz, dtype=complex)
norm_after_det_arr = np.zeros(sz, dtype=complex)
final_dens_matrix_list = []
# Start time.
print('Started at:', strftime("%Y-%m-%d %H:%M:%S", gmtime()))
for n1 in range(r1_grid):
for n4 in range(r4_grid):
for n2 in range(r2_grid):
for n3 in range(r3_grid):
print('Steps [n1, n4, n2, n3]:', n1, n4, n2, n3)
bs_params = {
't1': t1_array[n1],
't4': t4_array[n4],
't2': t2_array[n2],
't3': t3_array[n3],
}
final_dens_matrix, det_prob, norm = process_all(
mut_state_unappl,
bs_params,
phase_diff=phase_diff,
phase_mod_channel=phase_mod_channel,
det_event=DET_CONF
)
if final_dens_matrix is None or det_prob is None:
print('Warning: the norm is zero.')
pass
det_prob_array[n1, n4, n2, n3] = det_prob
norm_after_det_arr[n1, n4, n2, n3] = norm
# final_dens_matrix_list.append({'dm': final_dens_matrix, 'keys': [n1, n4, n2, n3]})
# Trace one channel out of final state
# final_traced_subs1 = trace_channel(final_dens_matrix, channel=4)
# print('trace of final reduced matrix 2nd channel:', np.trace(final_traced_subs1))
# Other channel traced
# final_traced_subs2 = trace_channel(final_dens_matrix, channel=2)
# print('trace of final reduced matrix 4th channel:', np.trace(final_traced_subs2))
# Calculate entropy
# log_entanglement_subs1 = log_entropy(final_traced_subs1)
# log_entanglement_subs2 = log_entropy(final_traced_subs2)
# log_entropy_subs1_array[n1, n4, n2, n3] = log_entanglement_subs1
# log_entropy_subs2_array[n1, n4, n2, n3] = log_entanglement_subs2
# Full entropy and the mutual information
# final_reorg_matr = reorganise_dens_matrix(final_dens_matrix)
# full_entr = log_entropy(final_reorg_matr)
# mut_information[n1, n4, n2, n3] = log_entanglement_subs1 + log_entanglement_subs2 - full_entr
# full_fn_entropy[n1, n4, n2, n3] = full_entr
log_negativity[n1, n4, n2, n3] = negativity(final_dens_matrix, neg_type='logarithmic')
# print('Log. negativity: ', log_negativity[n1, n4, n2, n3])
# Squeezing quadratures.
dX, dP = squeezing_quadratures(final_dens_matrix, channel=1)
# print('dX:', dX, ' dP:', dP)
sqeez_dX[n1, n4, n2, n3] = dX
sqeez_dP[n1, n4, n2, n3] = dP
# ERP correlations.
epr_x, epr_p = erp_squeezing_correlations(final_dens_matrix)
epr_correl_x[n1, n4, n2, n3] = epr_x
epr_correl_p[n1, n4, n2, n3] = epr_p
# print('erp_X:', erp_x, ' erp_P:', erp_p)
# Save it.
fl = {
'det_prob': det_prob_array,
'norm_aft_det': norm_after_det_arr,
# 'final_dens_matrix': final_dens_matrix_list,
'log_negativity': log_negativity,
# 'mut_inform': mut_information,
'squeez_dx': sqeez_dX,
'squeez_dp': sqeez_dP,
'epr_correl_x': epr_correl_x,
'epr_correl_p': epr_correl_p,
'det_conf': DET_CONF,
'phase': phase_diff,
't1_arr': t1_array,
't4_arr': t4_array,
't2_arr': t2_array,
't3_arr': t3_array,
'states_config': states_config
}
np.save(save_root + fname, fl)
| [] |
2024-01-10 | matthewR1993/qscheme | scripts~gradient_search.py | import sys
import platform
import matplotlib.pyplot as plt
import matplotlib.cm as cm
if platform.system() == 'Linux':
sys.path.append('/usr/local/lib/python3.5/dist-packages')
from customutils.utils import *
from core.squeezing import *
from core.state_configurations import coherent_state, single_photon, fock_state
from core.gradient_methods import gd_with_momentum
# Parameters for states
series_length = 10
input_series_length = series_length
auxiliary_series_length = series_length
max_power = input_series_length + auxiliary_series_length
# INPUT - the state in the first(at the bottom) channel
# input_st = single_photon(series_length)
input_st = coherent_state(input_series_length, alpha=1)
# input_st = fock_state(n=2, series_length=input_series_length)
print('Input state norm:', get_state_norm(input_st))
# AUXILIARY - the state in the second(on top) channel
auxiliary_st = single_photon(series_length)
# auxiliary_st = coherent_state(auxiliary_series_length, alpha=1)
# auxiliary_st = fock_state(n=2, series_length=auxiliary_series_length)
print('Auxiliary state norm:', get_state_norm(auxiliary_st))
# Measurement event, detectors configuration:
# DET_CONF = 'BOTH' # both 1st and 3rd detectors clicked
DET_CONF = 'FIRST' # 1st detector is clicked
# DET_CONF = 'THIRD' # 3rd detector is clicked
# DET_CONF = 'NONE' # None of detectors were clicked
# Building a mutual state via tensor product, that returns numpy array.
mut_state_unappl = np.tensordot(input_st, auxiliary_st, axes=0)
# The phase difference before last BS
ph_inpi = 0.0
phase_diff = ph_inpi * np.pi
start_point = {
't1': sqrt(0.5),
't4': sqrt(0.5),
't2': sqrt(0.5),
't3': sqrt(0.5),
}
algo_params = {
'alpha': 5e-2,
'alpha_scale': 1.0,
'betta': 0.999,
'target_prec': 1e-3,
'search_iter_max': 40,
'start_point': start_point,
}
funct_params = {
'free_par_keys': ['t1', 't4'],
'target_quantity_min': 'EPR_X',
'det_event': DET_CONF,
'phase': 0.0,
'input_state': mut_state_unappl
}
result = gd_with_momentum(algo_params=algo_params, funct_params=funct_params)
# Visualise.
parms = result['params_arr']
t1_coord = np.zeros(result['step'])
t4_coord = np.zeros(result['step'])
for i in range(result['step']):
t1_coord[i] = parms[i]['t1']
t4_coord[i] = parms[i]['t1']
T1_coord = np.square(t1_coord)
T4_coord = np.square(t4_coord)
filepath = '/Users/matvei/PycharmProjects/qscheme/results/res18/coh(chan-1)_single(chan-2)_phase-0.0pi_det-FIRST_T1_T4.npy'
fl = np.load(filepath)
T1_arr = np.square(fl.item().get('t1_arr'))
T4_arr = np.square(fl.item().get('t4_arr'))
epr_x = fl.item().get('epr_correl_x')
epr_x_2d = np.real(epr_x[:, :, 0, 0])
epr_x_amin = np.amin(epr_x_2d)
epr_x_amin_ind = list(np.unravel_index(np.argmin(epr_x_2d, axis=None), epr_x_2d.shape))
epr_x_amin_Tcoord = [T1_arr[epr_x_amin_ind[0]], T4_arr[epr_x_amin_ind[1]]]
# epr x plot
plt.imshow(epr_x_2d, origin='lower', cmap=cm.GnBu_r)
plt.colorbar()
plt.scatter(x=[epr_x_amin_ind[1]], y=[epr_x_amin_ind[0]], c='r', s=80, marker='+')
plt.scatter(x=[50], y=[50], c='g', s=80, marker='+')
plt.plot(T1_coord*100, T4_coord*100)
plt.xlabel('T4')
plt.ylabel('T1')
plt.show()
plt.plot(T1_coord*100, T4_coord*100, 'r-o')
plt.show()
| [] |
2024-01-10 | matthewR1993/qscheme | scripts~spd_epr_vs_phase.py | import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from math import factorial, sqrt
from core.state_configurations import coherent_state
from core.squeezing import erp_squeezing_correlations
def state_norm_opt(state):
fact_arr = np.array([factorial(x) for x in range(len(state))])
tf2 = np.tensordot(fact_arr, fact_arr, axes=0)
st_abs_quad = np.power(np.abs(state), 2)
mult = np.multiply(st_abs_quad, tf2)
return np.sqrt(np.sum(mult))
def make_state_appliable(state):
fact_arr = np.array([sqrt(factorial(x)) for x in range(len(state))])
tf2 = np.tensordot(fact_arr, fact_arr, axes=0)
return np.multiply(state, tf2)
# def make_state_appliable(state):
# """
# Apply operators to the state in 2 channels.
# :param state: Unapplied state in 2 channels.
# :return: Applied state in 2 channels.
# """
# size = len(state)
# st_appl = np.zeros((size, size), dtype=complex)
# for p1 in range(size):
# for p2 in range(size):
# st_appl[p1, p2] = state[p1, p2] * np.sqrt(factorial(p1) * factorial(p2))
# return st_appl
#
#
def dens_matrix(state):
"""
Build a density matrix in 2 channels.
:param state: Applied state in 2 channels.
:return: Applied density matrix for 2 channels.
"""
size = len(state)
state_conj = np.conj(state)
dm = np.zeros((size,) * 4, dtype=complex)
for p1 in range(size):
for p2 in range(size):
for p1_ in range(size):
for p2_ in range(size):
dm[p1, p2, p1_, p2_] = state[p1, p2] * state_conj[p1_, p2_]
return dm
t_grd = 10
phase_grd = 9
t1_arr = np.linspace(0, 1, t_grd)
t2_arr = np.linspace(1e-4, 1 - 1e-4, t_grd)
t3_arr = np.linspace(1e-4, 1 - 1e-4, t_grd)
t4_arr = np.linspace(0, 1, t_grd)
phase_arr = np.linspace(0, 2*np.pi, phase_grd)
L = 10
alpha = 0.1
epr_arr = np.zeros((phase_grd, t_grd, t_grd, t_grd, t_grd), dtype=complex)
for p in range(phase_grd):
print('Phase step:', p)
for n1 in range(t_grd):
print('n1 step:', n1)
for n2 in range(t_grd):
for n3 in range(t_grd):
for n4 in range(t_grd):
t1 = t1_arr[n1]
t2 = t2_arr[n2]
t3 = t3_arr[n3]
t4 = t4_arr[n4]
phase = phase_arr[p]
r1 = sqrt(1 - t1**2)
r2 = sqrt(1 - t2**2)
r3 = sqrt(1 - t3**2)
r4 = sqrt(1 - t4**2)
alpha_1_f = (alpha * t1 * t2) * 1j * r4 + (1j * alpha * r1 * t3) * np.exp(1j * phase) * t4
alpha_2_f = (alpha * t1 * t2) * t4 + (1j * alpha * r1 * t3) * np.exp(1j * phase) * 1j * r4
ksi1 = 1j * r4 * (1j * r1 * t2) * ((-alpha) * r1 * r3)
ksi2 = t4 * (1j * r1 * t2) * ((-alpha) * r1 * r3)
ksi0 = 1j * t1 * r3 + t1 * t3 * ((-alpha) * r1 * r3)
# print('ksi 0:', ksi0)
# print('ksi 1:', ksi1)
# print('ksi 2:', ksi2)
# Unapplied.
cs1 = coherent_state(L, alpha=alpha_1_f)
cs2 = coherent_state(L, alpha=alpha_2_f)
# a1_conj * cs1
a1_cs1 = np.roll(cs1, 1)
a1_cs1[0] = 0
# a2_conj * cs2
a2_cs2 = np.roll(cs2, 1)
a2_cs2[0] = 0
# Unapplied, unnormalised, output state.
state = (ksi1 * np.tensordot(a1_cs1, cs2, axes=0) +
ksi2 * np.tensordot(cs1, a2_cs2, axes=0) +
ksi0 * np.tensordot(cs1, cs2, axes=0)
)
state_unappl_norm = state / state_norm_opt(state)
# print(state_norm_opt(state_unappl_norm))
state_appl = make_state_appliable(state_unappl_norm)
dm = np.einsum('ij,kl->ijkl', state_appl, np.conj(state_appl))
# dm1 = dens_matrix(state_appl)
# print(np.sum(np.einsum('ij,kl->ijkl', state_appl, np.conj(state_appl)) - dens_matrix(state_appl)))
#print(np.sum(dm1 - dm))
epr_x, _ = erp_squeezing_correlations(dm)
# print('EPR_X:', epr_x)
epr_arr[p, n1, n2, n3, n4] = epr_x
epr_min_vs_phase = np.zeros(phase_grd, dtype=complex)
for i in range(phase_grd):
epr_min_vs_phase[i] = np.amin(epr_arr[i, :, :, :, :])
# plt.plot(phase_arr, np.real(epr_min_vs_phase))
# plt.show()
# epr=0.43764574, alpha = 1
# epr=0.43807441, alpha=0.5
# epr=0.43763398, alpha=0.1
# epr_min_vs_t4 = np.zeros(t_grd, dtype=complex)
# for n4 in range(t_grd):
# epr_min_vs_t4[n4] = np.amin(epr_arr[:, :, :, :, n4])
#
#
# plt.plot(t4_arr, np.real(epr_min_vs_t4))
# plt.show()
#
#
# #
# epr_min_vs_t1 = np.zeros(t_grd, dtype=complex)
# for n1 in range(t_grd):
# epr_min_vs_t1[n1] = np.amin(epr_arr[:, n1, :, :, :])
#
#
# plt.plot(t1_arr, np.real(epr_min_vs_t1))
# plt.show()
#
# np.min(epr_arr[5, :, :, :, :])
| [] |
2024-01-10 | entbappy/End-to-end-Medical-Chatbot-using-Llama2 | src~helper.py | from langchain.document_loaders import PyPDFLoader, DirectoryLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings
#Extract data from the PDF
def load_pdf(data):
loader = DirectoryLoader(data,
glob="*.pdf",
loader_cls=PyPDFLoader)
documents = loader.load()
return documents
#Create text chunks
def text_split(extracted_data):
text_splitter = RecursiveCharacterTextSplitter(chunk_size = 500, chunk_overlap = 20)
text_chunks = text_splitter.split_documents(extracted_data)
return text_chunks
#download embedding model
def download_hugging_face_embeddings():
embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
return embeddings | [] |
2024-01-10 | entbappy/End-to-end-Medical-Chatbot-using-Llama2 | store_index.py | from src.helper import load_pdf, text_split, download_hugging_face_embeddings
from langchain.vectorstores import Pinecone
import pinecone
from dotenv import load_dotenv
import os
load_dotenv()
PINECONE_API_KEY = os.environ.get('PINECONE_API_KEY')
PINECONE_API_ENV = os.environ.get('PINECONE_API_ENV')
# print(PINECONE_API_KEY)
# print(PINECONE_API_ENV)
extracted_data = load_pdf("data/")
text_chunks = text_split(extracted_data)
embeddings = download_hugging_face_embeddings()
#Initializing the Pinecone
pinecone.init(api_key=PINECONE_API_KEY,
environment=PINECONE_API_ENV)
index_name="medical-bot"
#Creating Embeddings for Each of The Text Chunks & storing
docsearch=Pinecone.from_texts([t.page_content for t in text_chunks], embeddings, index_name=index_name)
| [] |
2024-01-10 | Buhankoanon/OAI_API_Checker | OAI_API_Checker.py | # -*- coding: utf-8 -*-
import openai
import requests
from datetime import datetime, timedelta
import sys
import time
import threading
from concurrent.futures import ThreadPoolExecutor
import colorama
import logging
from math import ceil
colorama.init()
logging.basicConfig(filename='OAI_API_Checker_logs.log', level=logging.DEBUG, format='%(asctime)s %(levelname)s: %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
def log_and_print(message, log_level=logging.INFO):
print(message)
logging.log(log_level, message)
def list_models(api_key):
openai.api_key = api_key
models = openai.Model.list()
return [model.id for model in models['data']]
def filter_models(models, desired_models):
return [model for model in models if model in desired_models]
def try_complete(api_key):
openai.api_key = api_key
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
max_tokens=1,
messages=[{'role':'user', 'content': ''}]
)
RED = "\033[31m"
YELLOW = "\033[33m"
#GREEN = "\033[32m"
#BLINK = "\033[5m"
RESET = "\033[0m"
def check_key(api_key, retry_count=3):
result = f"{api_key}\n"
has_gpt_4_32k = False
model_ids = []
errors = []
models = list_models(api_key)
filtered_models = filter_models(models, desired_models)
if filtered_models:
for model_id in filtered_models:
result += f" - {model_id}\n"
model_ids.append(model_id)
else:
result += " No desired models available.\n"
has_gpt_4 = "gpt-4" in model_ids
has_gpt_4_32k = "gpt-4-32k" in model_ids
has_only_turbo = "gpt-3.5-turbo" in model_ids and not has_gpt_4
try:
for attempts in range(retry_count):
try:
try_complete(api_key)
break
except Exception as e:
error_message = str(e)
if "The server is overloaded or not ready yet" in error_message:
logging.info(f'Error encountered when generating a completion on attempt {attempts+1}: {error_message}. Retrying...')
time.sleep(5)
continue
else:
raise e
except Exception as e:
error_message = str(e)
if "You exceeded your current quota" in error_message:
result += f"{YELLOW} This key has exceeded its current quota{RESET}\n"
elif "Your account is not active" in error_message:
result += f"{RED} Error: Your account is not active, please check your billing details on our website.{RESET}\n"
else:
result += f"{RED} Unexpected Error at check_key: {error_message}{RESET}\n"
errors.append((api_key, error_message))
return result, has_gpt_4, has_gpt_4_32k, has_only_turbo, errors
def checkkeys(api_keys):
working_gpt_4_keys = set()
no_quota_gpt_4_keys = set()
working_gpt_4_32k_keys = set()
no_quota_gpt_4_32k_keys = set()
working_only_turbo_keys = set()
no_quota_only_turbo_keys = set()
result = ''
total_errors = []
with ThreadPoolExecutor(max_workers=100) as executor:
futures = [executor.submit(check_key, api_key) for api_key in api_keys]
for idx, future in enumerate(futures, start=1):
result += f"API Key {idx}:\n"
key = api_keys[idx - 1]
try:
key_result, has_gpt_4, has_gpt_4_32k, has_only_turbo, errors = future.result()
total_errors.extend(errors)
result += key_result
if has_only_turbo and "Error" not in key_result and "This key has exceeded its current quota" not in key_result and "This key is invalid or revoked" not in key_result:
working_only_turbo_keys.add(key)
if has_gpt_4 and not has_gpt_4_32k and "Error" not in key_result and "This key has exceeded its current quota" not in key_result and "This key is invalid or revoked" not in key_result:
working_gpt_4_keys.add(key)
if has_gpt_4_32k and "Error" not in key_result and "This key has exceeded its current quota" not in key_result and "This key is invalid or revoked" not in key_result:
working_gpt_4_32k_keys.add(key)
if has_only_turbo and "This key has exceeded its current quota" in key_result:
no_quota_only_turbo_keys.add(key)
if has_gpt_4 and "This key has exceeded its current quota" in key_result:
no_quota_gpt_4_keys.add(key)
if has_gpt_4_32k and "This key has exceeded its current quota" in key_result:
no_quota_gpt_4_32k_keys.add(key)
except Exception as e:
error_message = str(e)
if "Incorrect API key provided" in error_message:
result += f"{key}\n"
result += f"{RED} This key is invalid or revoked{RESET}\n"
elif "You must be a member of an organization to use the API" in error_message:
result += f"{key}\n"
result += f"{RED} Error: You must be a member of an organization to use the API. Please contact us through our help center at help.openai.com.{RESET}\n"
elif "This key is associated with a deactivated account" in error_message:
result += f"{key}\n"
result += f"{RED} Error: This key is associated with a deactivated account. If you feel this is an error, contact us through our help center at help.openai.com.{RESET}\n"
else:
result += f"{RED} Unexpected Error at checkkeys: {error_message}{RESET}\n"
total_errors.append((api_keys[idx - 1], error_message))
result += '\n'
with open('turbo.txt', 'w') as f:
if len(working_only_turbo_keys) > 0:
f.write('Working API keys with GPT-3.5-Turbo model:\n')
f.write('\n'.join(working_only_turbo_keys) + '\n\n')
if len(no_quota_only_turbo_keys) > 0:
f.write('Valid API keys with GPT-3.5-Turbo model and no quota left:\n')
f.write('\n'.join(no_quota_only_turbo_keys) + '\n\n')
with open('gpt4.txt', 'w') as f:
if len(working_gpt_4_32k_keys) > 0:
f.write('Working API keys with GPT-4-32k model:\n')
f.write('\n'.join(working_gpt_4_32k_keys) + '\n\n')
if len(no_quota_gpt_4_32k_keys) > 0:
f.write('Valid API keys with GPT-4-32k model and no quota left:\n')
f.write('\n'.join(no_quota_gpt_4_32k_keys) + '\n\n')
if len(working_gpt_4_keys) > 0:
f.write('Working API keys with GPT-4 model:\n')
f.write('\n'.join(working_gpt_4_keys) + '\n\n')
if len(no_quota_gpt_4_keys) > 0:
f.write('Valid API keys with GPT-4 model and no quota left:\n')
f.write('\n'.join(no_quota_gpt_4_keys) + '\n\n')
with open('unexpected_errors.txt', 'w') as f:
for i, (api_key, error) in enumerate(total_errors, start=1):
f.write(f"Error #{i}:\n")
f.write(f"API Key: {api_key}\n")
f.write(f"Error Message: {error}\n\n")
result += f"\nNumber of working API keys with only 'gpt-3.5-turbo' model: {len(working_only_turbo_keys)}\n"
for key in working_only_turbo_keys:
result += f"{key}\n"
result += f"\nNumber of working API keys with 'gpt-4' model: {len(working_gpt_4_keys)}\n"
for key in working_gpt_4_keys:
result += f"{key}\n"
result += f"\nNumber of working API keys with 'gpt-4-32k' model: {len(working_gpt_4_32k_keys)}\n"
for key in working_gpt_4_32k_keys:
result += f"{key}\n"
result += f"\nNumber of valid API keys with only 'gpt-3.5-turbo' model and NO quota left: {len(no_quota_only_turbo_keys)}\n"
for key in no_quota_only_turbo_keys:
result += f"{key}\n"
result += f"\nNumber of valid API keys with 'gpt-4' model and NO quota left: {len(no_quota_gpt_4_keys)}\n"
for key in no_quota_gpt_4_keys:
result += f"{key}\n"
result += f"\nNumber of valid API keys with 'gpt-4-32k' model and NO quota left: {len(no_quota_gpt_4_32k_keys)}\n"
for key in no_quota_gpt_4_32k_keys:
result += f"{key}\n"
return result
def animate_processing_request():
while not processing_done:
sys.stdout.write("\rProcessing... |")
time.sleep(0.1)
sys.stdout.write("\rProcessing... /")
time.sleep(0.1)
sys.stdout.write("\rProcessing... -")
time.sleep(0.1)
sys.stdout.write("\rProcessing... \\")
time.sleep(0.1)
sys.stdout.write("\rDone! \n")
if __name__ == '__main__':
api_keys = []
desired_models = ["gpt-3.5-turbo", "gpt-4", "gpt-4-32k"]
log_and_print("Enter the API keys (one key per line). Press Enter twice when you're done:")
while True:
try:
api_key = input()
except:
break
if not api_key:
break
api_keys.append(api_key.strip())
processing_done = False
animation_thread = threading.Thread(target=animate_processing_request)
animation_thread.start()
result = checkkeys(api_keys)
processing_done = True
animation_thread.join()
log_and_print("\n" + result)
input("Press Enter to exit...") | [] |
2024-01-10 | kense-lab/dify | api~core~completion.py | from typing import Optional, List, Union, Tuple
from langchain.callbacks import CallbackManager
from langchain.chat_models.base import BaseChatModel
from langchain.llms import BaseLLM
from langchain.schema import BaseMessage, BaseLanguageModel, HumanMessage
from core.constant import llm_constant
from core.callback_handler.llm_callback_handler import LLMCallbackHandler
from core.callback_handler.std_out_callback_handler import DifyStreamingStdOutCallbackHandler, \
DifyStdOutCallbackHandler
from core.conversation_message_task import ConversationMessageTask, ConversationTaskStoppedException
from core.llm.error import LLMBadRequestError
from core.llm.llm_builder import LLMBuilder
from core.chain.main_chain_builder import MainChainBuilder
from core.llm.streamable_chat_open_ai import StreamableChatOpenAI
from core.llm.streamable_open_ai import StreamableOpenAI
from core.memory.read_only_conversation_token_db_buffer_shared_memory import \
ReadOnlyConversationTokenDBBufferSharedMemory
from core.memory.read_only_conversation_token_db_string_buffer_shared_memory import \
ReadOnlyConversationTokenDBStringBufferSharedMemory
from core.prompt.prompt_builder import PromptBuilder
from core.prompt.prompt_template import OutLinePromptTemplate
from core.prompt.prompts import MORE_LIKE_THIS_GENERATE_PROMPT
from models.model import App, AppModelConfig, Account, Conversation, Message
class Completion:
@classmethod
def generate(cls, task_id: str, app: App, app_model_config: AppModelConfig, query: str, inputs: dict,
user: Account, conversation: Optional[Conversation], streaming: bool, is_override: bool = False):
"""
errors: ProviderTokenNotInitError
"""
cls.validate_query_tokens(app.tenant_id, app_model_config, query)
memory = None
if conversation:
# get memory of conversation (read-only)
memory = cls.get_memory_from_conversation(
tenant_id=app.tenant_id,
app_model_config=app_model_config,
conversation=conversation,
return_messages=False
)
inputs = conversation.inputs
conversation_message_task = ConversationMessageTask(
task_id=task_id,
app=app,
app_model_config=app_model_config,
user=user,
conversation=conversation,
is_override=is_override,
inputs=inputs,
query=query,
streaming=streaming
)
# build main chain include agent
main_chain = MainChainBuilder.to_langchain_components(
tenant_id=app.tenant_id,
agent_mode=app_model_config.agent_mode_dict,
memory=ReadOnlyConversationTokenDBStringBufferSharedMemory(memory=memory) if memory else None,
conversation_message_task=conversation_message_task
)
chain_output = ''
if main_chain:
chain_output = main_chain.run(query)
# run the final llm
try:
cls.run_final_llm(
tenant_id=app.tenant_id,
mode=app.mode,
app_model_config=app_model_config,
query=query,
inputs=inputs,
chain_output=chain_output,
conversation_message_task=conversation_message_task,
memory=memory,
streaming=streaming
)
except ConversationTaskStoppedException:
return
@classmethod
def run_final_llm(cls, tenant_id: str, mode: str, app_model_config: AppModelConfig, query: str, inputs: dict,
chain_output: str,
conversation_message_task: ConversationMessageTask,
memory: Optional[ReadOnlyConversationTokenDBBufferSharedMemory], streaming: bool):
final_llm = LLMBuilder.to_llm_from_model(
tenant_id=tenant_id,
model=app_model_config.model_dict,
streaming=streaming
)
# get llm prompt
prompt, stop_words = cls.get_main_llm_prompt(
mode=mode,
llm=final_llm,
pre_prompt=app_model_config.pre_prompt,
query=query,
inputs=inputs,
chain_output=chain_output,
memory=memory
)
final_llm.callback_manager = cls.get_llm_callback_manager(final_llm, streaming, conversation_message_task)
cls.recale_llm_max_tokens(
final_llm=final_llm,
prompt=prompt,
mode=mode
)
response = final_llm.generate([prompt], stop_words)
return response
@classmethod
def get_main_llm_prompt(cls, mode: str, llm: BaseLanguageModel, pre_prompt: str, query: str, inputs: dict,
chain_output: Optional[str],
memory: Optional[ReadOnlyConversationTokenDBBufferSharedMemory]) -> \
Tuple[Union[str | List[BaseMessage]], Optional[List[str]]]:
# disable template string in query
query_params = OutLinePromptTemplate.from_template(template=query).input_variables
if query_params:
for query_param in query_params:
if query_param not in inputs:
inputs[query_param] = '{' + query_param + '}'
pre_prompt = PromptBuilder.process_template(pre_prompt) if pre_prompt else pre_prompt
if mode == 'completion':
prompt_template = OutLinePromptTemplate.from_template(
template=("""Use the following CONTEXT as your learned knowledge:
[CONTEXT]
{context}
[END CONTEXT]
When answer to user:
- If you don't know, just say that you don't know.
- If you don't know when you are not sure, ask for clarification.
Avoid mentioning that you obtained the information from the context.
And answer according to the language of the user's question.
""" if chain_output else "")
+ (pre_prompt + "\n" if pre_prompt else "")
+ "{query}\n"
)
if chain_output:
inputs['context'] = chain_output
context_params = OutLinePromptTemplate.from_template(template=chain_output).input_variables
if context_params:
for context_param in context_params:
if context_param not in inputs:
inputs[context_param] = '{' + context_param + '}'
prompt_inputs = {k: inputs[k] for k in prompt_template.input_variables if k in inputs}
prompt_content = prompt_template.format(
query=query,
**prompt_inputs
)
if isinstance(llm, BaseChatModel):
# use chat llm as completion model
return [HumanMessage(content=prompt_content)], None
else:
return prompt_content, None
else:
messages: List[BaseMessage] = []
human_inputs = {
"query": query
}
human_message_prompt = ""
if pre_prompt:
pre_prompt_inputs = {k: inputs[k] for k in
OutLinePromptTemplate.from_template(template=pre_prompt).input_variables
if k in inputs}
if pre_prompt_inputs:
human_inputs.update(pre_prompt_inputs)
if chain_output:
human_inputs['context'] = chain_output
human_message_prompt += """Use the following CONTEXT as your learned knowledge.
[CONTEXT]
{context}
[END CONTEXT]
When answer to user:
- If you don't know, just say that you don't know.
- If you don't know when you are not sure, ask for clarification.
Avoid mentioning that you obtained the information from the context.
And answer according to the language of the user's question.
"""
if pre_prompt:
human_message_prompt += pre_prompt
query_prompt = "\nHuman: {query}\nAI: "
if memory:
# append chat histories
tmp_human_message = PromptBuilder.to_human_message(
prompt_content=human_message_prompt + query_prompt,
inputs=human_inputs
)
curr_message_tokens = memory.llm.get_messages_tokens([tmp_human_message])
rest_tokens = llm_constant.max_context_token_length[memory.llm.model_name] \
- memory.llm.max_tokens - curr_message_tokens
rest_tokens = max(rest_tokens, 0)
histories = cls.get_history_messages_from_memory(memory, rest_tokens)
# disable template string in query
histories_params = OutLinePromptTemplate.from_template(template=histories).input_variables
if histories_params:
for histories_param in histories_params:
if histories_param not in human_inputs:
human_inputs[histories_param] = '{' + histories_param + '}'
human_message_prompt += "\n\n" + histories
human_message_prompt += query_prompt
# construct main prompt
human_message = PromptBuilder.to_human_message(
prompt_content=human_message_prompt,
inputs=human_inputs
)
messages.append(human_message)
return messages, ['\nHuman:']
@classmethod
def get_llm_callback_manager(cls, llm: Union[StreamableOpenAI, StreamableChatOpenAI],
streaming: bool,
conversation_message_task: ConversationMessageTask) -> CallbackManager:
llm_callback_handler = LLMCallbackHandler(llm, conversation_message_task)
if streaming:
callback_handlers = [llm_callback_handler, DifyStreamingStdOutCallbackHandler()]
else:
callback_handlers = [llm_callback_handler, DifyStdOutCallbackHandler()]
return CallbackManager(callback_handlers)
@classmethod
def get_history_messages_from_memory(cls, memory: ReadOnlyConversationTokenDBBufferSharedMemory,
max_token_limit: int) -> \
str:
"""Get memory messages."""
memory.max_token_limit = max_token_limit
memory_key = memory.memory_variables[0]
external_context = memory.load_memory_variables({})
return external_context[memory_key]
@classmethod
def get_memory_from_conversation(cls, tenant_id: str, app_model_config: AppModelConfig,
conversation: Conversation,
**kwargs) -> ReadOnlyConversationTokenDBBufferSharedMemory:
# only for calc token in memory
memory_llm = LLMBuilder.to_llm_from_model(
tenant_id=tenant_id,
model=app_model_config.model_dict
)
# use llm config from conversation
memory = ReadOnlyConversationTokenDBBufferSharedMemory(
conversation=conversation,
llm=memory_llm,
max_token_limit=kwargs.get("max_token_limit", 2048),
memory_key=kwargs.get("memory_key", "chat_history"),
return_messages=kwargs.get("return_messages", True),
input_key=kwargs.get("input_key", "input"),
output_key=kwargs.get("output_key", "output"),
message_limit=kwargs.get("message_limit", 10),
)
return memory
@classmethod
def validate_query_tokens(cls, tenant_id: str, app_model_config: AppModelConfig, query: str):
llm = LLMBuilder.to_llm_from_model(
tenant_id=tenant_id,
model=app_model_config.model_dict
)
model_limited_tokens = llm_constant.max_context_token_length[llm.model_name]
max_tokens = llm.max_tokens
if model_limited_tokens - max_tokens - llm.get_num_tokens(query) < 0:
raise LLMBadRequestError("Query is too long")
@classmethod
def recale_llm_max_tokens(cls, final_llm: Union[StreamableOpenAI, StreamableChatOpenAI],
prompt: Union[str, List[BaseMessage]], mode: str):
# recalc max_tokens if sum(prompt_token + max_tokens) over model token limit
model_limited_tokens = llm_constant.max_context_token_length[final_llm.model_name]
max_tokens = final_llm.max_tokens
if mode == 'completion' and isinstance(final_llm, BaseLLM):
prompt_tokens = final_llm.get_num_tokens(prompt)
else:
prompt_tokens = final_llm.get_messages_tokens(prompt)
if prompt_tokens + max_tokens > model_limited_tokens:
max_tokens = max(model_limited_tokens - prompt_tokens, 16)
final_llm.max_tokens = max_tokens
@classmethod
def generate_more_like_this(cls, task_id: str, app: App, message: Message, pre_prompt: str,
app_model_config: AppModelConfig, user: Account, streaming: bool):
llm: StreamableOpenAI = LLMBuilder.to_llm(
tenant_id=app.tenant_id,
model_name='gpt-3.5-turbo',
streaming=streaming
)
# get llm prompt
original_prompt, _ = cls.get_main_llm_prompt(
mode="completion",
llm=llm,
pre_prompt=pre_prompt,
query=message.query,
inputs=message.inputs,
chain_output=None,
memory=None
)
original_completion = message.answer.strip()
prompt = MORE_LIKE_THIS_GENERATE_PROMPT
prompt = prompt.format(prompt=original_prompt, original_completion=original_completion)
if isinstance(llm, BaseChatModel):
prompt = [HumanMessage(content=prompt)]
conversation_message_task = ConversationMessageTask(
task_id=task_id,
app=app,
app_model_config=app_model_config,
user=user,
inputs=message.inputs,
query=message.query,
is_override=True if message.override_model_configs else False,
streaming=streaming
)
llm.callback_manager = cls.get_llm_callback_manager(llm, streaming, conversation_message_task)
cls.recale_llm_max_tokens(
final_llm=llm,
prompt=prompt,
mode='completion'
)
llm.generate([prompt])
| [
"\n",
"\n\nPLACEHOLDER",
"Use the following CONTEXT as your learned knowledge:\n[CONTEXT]\n{context}\n[END CONTEXT]\n\nWhen answer to user:\n- If you don't know, just say that you don't know.\n- If you don't know when you are not sure, ask for clarification. \nAvoid mentioning that you obtained the information from the context.\nAnd answer according to the language of the user's question.\n",
"Use the following CONTEXT as your learned knowledge:[CONTEXT]{context}[END CONTEXT]When answer to user:- If you don't know, just say that you don't know.- If you don't know when you are not sure, ask for clarification. Avoid mentioning that you obtained the information from the context.And answer according to the language of the user's question.PLACEHOLDER\n{query}\n",
"{query}\n",
"Use the following CONTEXT as your learned knowledge.\n[CONTEXT]\n{context}\n[END CONTEXT]\n\nWhen answer to user:\n- If you don't know, just say that you don't know.\n- If you don't know when you are not sure, ask for clarification. \nAvoid mentioning that you obtained the information from the context.\nAnd answer according to the language of the user's question.\n",
"\nHuman: {query}\nAI: "
] |
2024-01-10 | punnkam/domi | chatbot~ingest.py | """
Load question-answer content into Weaviate.
Currently this does a full dump-and-reload, but in future it should
continually and incrementally build the Weaviate cluster's database.
"""
# I created a Weaviate cluster in the following way:
#
# 1. Created an account at weaviate.io; verified my email.
# 2. Clicked "Create a cluster" in the weaviate.io UI.
# 3. Selected:
# subscription tier: sandbox
# weaviate version: v.1.17.3
# enable OIDC authentication: false (this data is not private)
def ingest_data(weaviate_url: str, openai_api_key: str, docs: list[str]):
import weaviate
from langchain.text_splitter import CharacterTextSplitter
#TODO: Remove
metadatas = [{"source": "https://thundergolfer.com/about"} for _ in docs]
text_splitter = CharacterTextSplitter(
separator="\n",
chunk_size=1000,
chunk_overlap=200,
length_function=len,
)
#TODO: Remove
documents = text_splitter.create_documents(docs, metadatas=metadatas)
client = weaviate.Client(
url=weaviate_url,
additional_headers={"X-OpenAI-Api-Key": openai_api_key},
)
client.schema.delete_all() # drop ALL data
client.schema.get()
schema = {
"classes": [
{
"class": "Paragraph",
"description": "A written paragraph",
"vectorizer": "text2vec-openai",
"moduleConfig": {
"text2vec-openai": {
"model": "ada",
"modelVersion": "002",
"type": "text",
}
},
"properties": [
{
"dataType": ["text"],
"description": "The content of the paragraph",
"moduleConfig": {
"text2vec-openai": {
"skip": False,
"vectorizePropertyName": False,
}
},
"name": "content",
},
{
"dataType": ["text"],
"description": "The link",
"moduleConfig": {
"text2vec-openai": {
"skip": True,
"vectorizePropertyName": False,
}
},
"name": "source",
},
],
},
]
}
client.schema.create(schema)
with client.batch as batch:
for text in documents:
batch.add_data_object(
{"content": text.page_content, "source": str(text.metadata["source"])},
"Paragraph",
)
def ingest_examples(weaviate_url: str, openai_api_key: str):
"""Ingest examples into Weaviate."""
import weaviate
import weaviate.exceptions
client = weaviate.Client(
url=weaviate_url,
additional_headers={"X-OpenAI-Api-Key": openai_api_key},
)
try:
client.schema.delete_class("Rephrase")
client.schema.delete_class("QA")
except weaviate.exceptions.UnexpectedStatusCodeException:
pass # Likely failed because classes didn't already exist.
client.schema.get()
schema = {
"classes": [
{
"class": "Rephrase",
"description": "Rephrase Examples",
"vectorizer": "text2vec-openai",
"moduleConfig": {
"text2vec-openai": {
"model": "ada",
"modelVersion": "002",
"type": "text",
}
},
"properties": [
{
"dataType": ["text"],
"moduleConfig": {
"text2vec-openai": {
"skip": False,
"vectorizePropertyName": False,
}
},
"name": "content",
},
{
"dataType": ["text"],
"description": "The link",
"moduleConfig": {
"text2vec-openai": {
"skip": True,
"vectorizePropertyName": False,
}
},
"name": "question",
},
{
"dataType": ["text"],
"description": "The link",
"moduleConfig": {
"text2vec-openai": {
"skip": True,
"vectorizePropertyName": False,
}
},
"name": "answer",
},
{
"dataType": ["text"],
"description": "The link",
"moduleConfig": {
"text2vec-openai": {
"skip": True,
"vectorizePropertyName": False,
}
},
"name": "chat_history",
},
],
},
]
}
client.schema.create(schema)
documents = [
{
"question": "how do i load those?",
"chat_history": "Human: What types of memory exist?\nAssistant: \n\nThere are a few different types of memory: Buffer, Summary, and Conversational Memory.",
"answer": "How do I load Buffer, Summary, and Conversational Memory",
},
{
"question": "how do i install this package?",
"chat_history": "",
"answer": "How do I install langchain?",
},
{
"question": "how do I set serpapi_api_key?",
"chat_history": "Human: can you write me a code snippet for that?\nAssistant: \n\nYes, you can create an Agent with a custom LLMChain in LangChain. Here is a [link](https://langchain.readthedocs.io/en/latest/modules/agents/examples/custom_agent.html) to the documentation that provides a code snippet for creating a custom Agent.",
"answer": "How do I set the serpapi_api_key?",
},
{
"question": "What are some methods for data augmented generation?",
"chat_history": "Human: List all methods of an Agent class please\nAssistant: \n\nTo answer your question, you can find a list of all the methods of the Agent class in the [API reference documentation](https://langchain.readthedocs.io/en/latest/modules/agents/reference.html).",
"answer": "What are some methods for data augmented generation?",
},
{
"question": "can you write me a code snippet for that?",
"chat_history": "Human: how do I create an agent with custom LLMChain?\nAssistant: \n\nTo create an Agent with a custom LLMChain in LangChain, you can use the [Custom Agent example](https://langchain.readthedocs.io/en/latest/modules/agents/examples/custom_agent.html). This example shows how to create a custom LLMChain and use an existing Agent class to parse the output. For more information on Agents and Tools, check out the [Key Concepts](https://langchain.readthedocs.io/en/latest/modules/agents/key_concepts.html) documentation.",
"answer": "Can you provide a code snippet for creating an Agent with a custom LLMChain?",
},
]
from langchain.prompts.example_selector.semantic_similarity import sorted_values
for d in documents:
d["content"] = " ".join(sorted_values(d))
with client.batch as batch:
for text in documents:
batch.add_data_object(
text,
"Rephrase",
)
client.schema.get()
schema = {
"classes": [
{
"class": "QA",
"description": "Rephrase Examples",
"vectorizer": "text2vec-openai",
"moduleConfig": {
"text2vec-openai": {
"model": "ada",
"modelVersion": "002",
"type": "text",
}
},
"properties": [
{
"dataType": ["text"],
"moduleConfig": {
"text2vec-openai": {
"skip": False,
"vectorizePropertyName": False,
}
},
"name": "content",
},
{
"dataType": ["text"],
"description": "The link",
"moduleConfig": {
"text2vec-openai": {
"skip": True,
"vectorizePropertyName": False,
}
},
"name": "question",
},
{
"dataType": ["text"],
"description": "The link",
"moduleConfig": {
"text2vec-openai": {
"skip": True,
"vectorizePropertyName": False,
}
},
"name": "answer",
},
{
"dataType": ["text"],
"description": "The link",
"moduleConfig": {
"text2vec-openai": {
"skip": True,
"vectorizePropertyName": False,
}
},
"name": "summaries",
},
{
"dataType": ["text"],
"description": "The link",
"moduleConfig": {
"text2vec-openai": {
"skip": True,
"vectorizePropertyName": False,
}
},
"name": "sources",
},
],
},
]
}
client.schema.create(schema)
documents = [
{
"question": "how do i install langchain?",
"answer": "```pip install langchain```",
"summaries": ">Example:\nContent:\n---------\nYou can pip install langchain package by running 'pip install langchain'\n----------\nSource: foo.html",
"sources": "foo.html",
},
{
"question": "how do i import an openai LLM?",
"answer": "```from langchain.llm import OpenAI```",
"summaries": ">Example:\nContent:\n---------\nyou can import the open ai wrapper (OpenAI) from the langchain.llm module\n----------\nSource: bar.html",
"sources": "bar.html",
},
]
from langchain.prompts.example_selector.semantic_similarity import sorted_values
for d in documents:
d["content"] = " ".join(sorted_values(d))
with client.batch as batch:
for text in documents:
batch.add_data_object(
text,
"QA",
) | [] |
2024-01-10 | DosakuNet/dosaku | dosaku~modules~openai~text_to_speech.py | import os
from typing import Optional
from openai import OpenAI
from dosaku import Config, Service
from dosaku.types import Audio
from dosaku.utils import ifnone
class OpenAITextToSpeech(Service):
name = 'OpenAITextToSpeech'
config = Config()
def __init__(self):
super().__init__()
self.client = OpenAI(api_key=self.config['API_KEYS']['OPENAI'])
self.model = 'tts-1'
self.voices = ['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer']
self.voice = 'alloy'
def set_voice(self, voice: str):
self.voice = voice
def text_to_speech(self, text: str, output_filename: Optional[str] = None, voice: Optional[str] = None) -> Audio:
voice = ifnone(voice, default=self.voice)
response = self.client.audio.speech.create(
model=self.model,
voice=voice,
input=text
)
if output_filename is not None:
response.stream_to_file(output_filename)
audio = Audio(filename=output_filename)
else:
output_filename = os.path.join(self.config['DIR_PATHS']['TEMP'], 'audio.mp3')
response.stream_to_file(output_filename)
audio = Audio(filename=output_filename)
return audio
OpenAITextToSpeech.register_action('text_to_speech')
| [] |
2024-01-10 | DosakuNet/dosaku | dosaku~modules~openai~interview_diarization.py | """OpenAI InterviewDiarization module."""
from math import ceil
import os
from openai import OpenAI
from pydub import AudioSegment
from dosaku import Service
from dosaku.modules import GPT
from dosaku.utils import ifnone
class OpenAIInterviewDiarization(Service):
"""OpenAI interview diarization class.
Example::
from dosaku.modules import OpenAIInterviewDiarization
transcriber = OpenAIInterviewDiarization()
audio_file = 'tests/resources/fridman_susskind.mp3'
text = transcriber.transcribe_interview(audio_file, interviewer='Lex Fridman', interviewee='Leonard Susskind')
print(text)
"""
whisper_instructions = (
'INTERVIEWER: So I was just thinking about the Roman Empire, as one does.\n'
'\n'
'INTERVIEWEE: Is that whole meme where all guys are thinking about the Roman Empire at least once a day?\n'
)
gpt_instructions = (
'You are an expert editor tasked with editing transcribed text from interviews. You will be given raw '
'interview text between an interviewer and an interviewee. The raw text will not have '
'any punctuation or speaker labels. Your task is to add speaker labels, proper punctuation, and remove any '
'extraneous "ums" or filler words. If you are given the names of the interviewer and interviewee use them in '
'your transcription; if the names are not given, use "INTERVIEWER" and "INTERVIEWEE".\n'
'\n'
'For example, given the text:\n'
'\n'
'Lex Fridman interviewing Elon Musk:\n'
'\n'
'so um I was just thinking about the roman empirer as one does is that whole meme where all guys are thinking '
'about the roman empire at least once a day and half the population is confused whether it’s true or not but '
'more seriously thinking about the wars going on in the world today and um as you know, sometimes, war and '
'military conquest has been a big parte of roman society and culture, and I think has been a big part of most '
'empires and dynasties throughout human history yeah they usually came as a result of conquest I mean like '
'there’s some like the hapsburg empire where there was just a lot of clever marriages\n'
'\n'
'You should respond with the following text:\n'
'\n'
'LEX FRIDMAN: So I was just thinking about the Roman Empire, as one does.\n'
'\n'
'ELON MUSK: Is that whole meme where all guys are thinking about the Roman Empire at least once a day?\n'
'\n'
'LEX FRIDMAN: And half the population is confused whether it’s true or not. But more seriously, thinking about '
'the wars going on in the world today, and as you know, war and military conquest has been a big part of Roman '
'society and culture, and I think has been a big part of most empires and dynasties throughout human history.\n'
'\n'
'ELON MUSK: Yeah, they usually came as a result of conquest. I mean, there’s some like the Hapsburg Empire '
'where there was just a lot of clever marriages.\n'
)
def __init__(
self,
**kwargs
):
super().__init__(**kwargs)
self.client = OpenAI(api_key=self.config['API_KEYS']['OPENAI'])
def save_chunks(self, raw_audio: AudioSegment, chunk_length: int, overwrite: bool = False):
temp_dir = self.config['DIR_PATHS']['TEMP']
num_chunks = ceil(len(raw_audio) / chunk_length)
filenames = []
for idx in range(num_chunks):
filename = os.path.join(temp_dir, f'audio_{idx}.mp3')
if overwrite is True or not os.path.exists(filename):
start = chunk_length * idx
end = min(chunk_length * (idx + 1), len(raw_audio) - 1)
audio_chunk = raw_audio[start:end]
audio_chunk.export(filename, format='mp3')
self.logger.debug(f'Exported audio chunk to {filename}')
filenames.append(filename)
return filenames
def transcribe_interview(
self,
audio_file: str,
chunk_length: int = 1200,
chunk_separater: str = '\n\n***GPT CHUNK BREAK***\n\n',
overwrite_files: bool = True,
interviewer: str = 'Interviewer',
interviewee: str = 'Interviewee'
):
"""Transcribe audio file with diarization (speak identification).
If the input file is too long it will be broken into separate chunks for processing.
Args:
audio_file: Path to the given mp3 file.
chunk_length: Maximum length of each audio chunk for processing, in seconds.
chunk_separater: Separater text placed between transcribed chunks.
overwrite_files: Whether to overwrite temp files found with the same name.
interviewer: The name of the interviewer.
interviewee: The name of the interviewee.
"""
chunk_length = chunk_length * 1000 # pydub measures time in ms
raw_audio = AudioSegment.from_mp3(audio_file)
files = self.save_chunks(raw_audio, chunk_length, overwrite=overwrite_files)
final_transcript = ''
for idx, audio_filename in enumerate(files):
text_filename = os.path.join(self.config['DIR_PATHS']['TEMP'], f'transcription_{idx}.txt')
gpt_text_filename = os.path.join(self.config['DIR_PATHS']['TEMP'], f'gpt_transcription_{idx}.txt')
if overwrite_files or not os.path.exists(text_filename):
with (
open(audio_filename, 'rb') as audio_file,
open(text_filename, 'w') as text_file
):
transcript = self.client.audio.transcriptions.create(
model='whisper-1',
file=audio_file,
prompt=self.whisper_instructions,
)
text_file.write(transcript.text)
self.logger.debug(f'Transcribed audio chunk {audio_filename} to {text_filename}')
if overwrite_files is True or not os.path.exists(gpt_text_filename):
with (
open(text_filename, 'r') as text_file,
open(gpt_text_filename, 'w') as gpt_file
):
interviewer = ifnone(interviewer, default='Interviewer')
interviewee = ifnone(interviewee, default='Interviewee')
text = f'{interviewer} interviewing {interviewee}:\n\n'
text += text_file.read()
gpt = GPT(instructions=self.gpt_instructions)
gpt_text = gpt.message(text)
gpt_file.write(gpt_text.message)
self.logger.debug(f'Corrected {text_filename} with GPT and saved the result to {gpt_text_filename}')
with open(gpt_text_filename, 'r') as gpt_file:
if len(final_transcript) > 0:
final_transcript += chunk_separater
final_transcript += gpt_file.read()
return final_transcript
OpenAIInterviewDiarization.register_action('save_chunks')
OpenAIInterviewDiarization.register_action('audio_to_text')
| [] |
2024-01-10 | DosakuNet/dosaku | apps~chat_sample.py | import os
from langchain.chat_models import ChatOpenAI
from langchain.schema import AIMessage, HumanMessage
import gradio as gr
from dosaku import Config
config = Config()
os.environ["OPENAI_API_KEY"] = config['API_KEYS']['OPENAI']
llm = ChatOpenAI(temperature=1.0, model='gpt-3.5-turbo-0613')
def predict(message, history):
history_langchain_format = []
for human, ai in history:
history_langchain_format.append(HumanMessage(content=human))
history_langchain_format.append(AIMessage(content=ai))
history_langchain_format.append(HumanMessage(content=message))
gpt_response = llm(history_langchain_format)
return gpt_response.content
gr.ChatInterface(predict).launch()
| [] |
2024-01-10 | TeamEpicProjects/Practical-LLM-and-GPT-Applications | GPT_API_without_embeddings.py | import streamlit as st
import os
import openai
openai.api_key = "Enter your OpenAI API Key here."
if "visibility" not in st.session_state:
st.session_state.visibility = "visible"
st.session_state.disabled = False
# Sidebar Design
with st.sidebar:
response=st.radio("Please choose an operation..",('Void',
'General Queries',
'Grammer and Spell Check',
'Summarize Text',
'Q&A',
'Language Translation',
'Language Detection',
'Detect and Translate',
'Code Explanation',
'Generate SQL Queries',
'Programming Language Conversion',
'Sentiment Analysis',
'Extract Keywords',
'Text Generator from keywords',
'Essay Outline Generator',
'Essay Generator'))
match response:
case 'Void':
st.write('You have not selected any operation yet!!!')
case 'General Queries':
st.write('You have selected general queries.')
case 'Grammer and Spell Check':
st.write('You have selected grammer and spell check.')
case 'Summarize Text':
st.write('You have selected for summarizing text.')
case 'Q&A':
st.write('You have selected for questionnaire.')
case 'Language Translation':
st.write('You have selected language translation.')
case 'Language Detection':
st.write('You have selected language detection.')
case 'Detect and Translate':
st.write('You have selected for language detection and translation.')
case 'Code Explanation':
st.write('You have selected for code explanation.')
case 'Generate SQL Queries':
st.write('You have selected for generating SQL queries.')
case 'Programming Language Conversion':
st.write('You have selected for converting a code snippet to another programming language.')
case 'Sentiment Analysis':
st.write('You have selected for sentiment analysis.')
case 'Extract Keywords':
st.write('You have selected for extracting keywords from text.')
case 'Text Generator from keywords':
st.write('You have selected for generating text from keywords')
case 'Essay Outline Generator':
st.write('You have selected for generating outline for an essay.')
case 'Essay Generator':
st.write('You have selected for generating an essay.')
def general(text):
response = openai.Completion.create(
model="text-davinci-003",
prompt=text,
temperature=0,
max_tokens=1000,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
return response['choices'][0]['text'].strip()
def grammer(text):
response = openai.Completion.create(
model="text-davinci-003",\
prompt="Correct this to standard English:"+text,
temperature=0,
max_tokens=1000,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
return response['choices'][0]['text'].strip()
def summary(text):
response = openai.Completion.create(
model="text-davinci-003",
prompt="Summarize this for a second-grade student:"+text,
temperature=0.01,
max_tokens=1000,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
return response['choices'][0]['text'].strip()
def questionnaire(question):
response = openai.Completion.create(
model="text-davinci-003",
prompt="Answer the question: "+question,
temperature=0,
max_tokens=140,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
return response['choices'][0]['text'].strip()
def translation(target, text):
response = openai.Completion.create(
model="text-davinci-003",
prompt="Translate "+text+" to "+target,
temperature=0,
max_tokens=140,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
return response['choices'][0]['text'].strip()
def identify_language(text):
response = openai.Completion.create(
model="text-davinci-003",
prompt="Detect the language of "+text,
temperature=0,
max_tokens=140,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
return response['choices'][0]['text'].strip()
def detect_translate(target, text):
result=[]
detected = identify_language(text)
result.append(detected)
trans = translation(target, text)
result.append(trans)
return result
def code_explain(code):
response = openai.Completion.create(
model="text-davinci-003",
prompt="Explain what the mentioned code is doing: "+code,
max_tokens=150,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
stop=["\"\"\""]
)
return response['choices'][0]['text'].strip()
def sql_queries(query,schema=""):
response = openai.Completion.create(
model="text-davinci-003",
prompt=schema+" An SQL query to "+query,
temperature=0,
max_tokens=150,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
stop=["#", ";"]
)
return response['choices'][0]['text'].strip()
def sentiment(text):
response = openai.Completion.create(
model="text-davinci-003",
prompt="Classify the sentiment of this text:"+text,
temperature=0,
max_tokens=500,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
return response['choices'][0]['text'].strip()
def keywords(text):
response = openai.Completion.create(
model="text-davinci-003",
prompt="Extract keywords from this text: "+text,
temperature=0,
max_tokens=500,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
return response['choices'][0]['text'].strip()
def text_generator(keywords, char):
response = openai.Completion.create(
model="text-davinci-003",
prompt="Generate a paragraph in "+char+" characters using keywords: "+keywords,
temperature=0,
max_tokens=500,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
return response['choices'][0]['text'].strip()
def essay_outline(topic):
response = openai.Completion.create(
model="text-davinci-003",
prompt="Create an outline for an essay about"+topic,
temperature=0,
max_tokens=3000,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
return response['choices'][0]['text'].strip()
def essay_generator(topic,outline="",limit="0"):
response = openai.Completion.create(
model="text-davinci-003",
prompt="Write an essay in "+limit+" words about "+topic+"using the outline"+outline,
temperature=0,
max_tokens=3000,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
return response['choices'][0]['text'].strip()
match response:
case 'Void':
st.header('This application is a one-stop solution for your NLP needs and more....')
case 'General Queries':
st.header('General Queries')
text = st.text_input(
"Enter your query here 👇*",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="1")
if text:
result=general(text)
st.subheader("Output:")
st.write(result)
case 'Grammer and Spell Check':
st.header('Grammer and Spell Check')
inputtext = st.text_input(
"Enter your text here 👇*",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="2")
if inputtext:
result=grammer(inputtext)
st.subheader("Output:")
st.write(result)
case 'Summarize Text':
st.header('Summarize Text')
article = st.text_input(
"Enter your article here 👇*",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="3")
if article:
output=summary(article)
st.subheader("Output:")
st.write(output)
case 'Q&A':
st.header('Questionnaire')
question = st.text_input(
"Enter your question here 👇*",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="4")
if question:
result=questionnaire(question)
st.subheader("Answer: ")
st.write(result)
case 'Language Translation':
st.header('Language Translation')
target = st.text_input(
"Enter your target language here 👇*",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="5")
text = st.text_input(
"Enter your text here 👇*",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="6")
if text and target:
output=translation(target, text)
st.subheader('Translated Text:')
st.write(output)
case 'Language Detection':
st.header('Language Detection')
text = st.text_input(
"Enter your text here 👇*",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="7")
if text:
output=identify_language(text)
st.subheader("Output:")
st.write(output)
case 'Detect and Translate':
st.header('Detect and Translate')
target = st.text_input(
"Enter your target language here 👇*",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="8")
text = st.text_input(
"Enter your text here 👇*",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="9")
if text and target:
st.subheader('Language: ')
output=detect_translate(target, text)
st.write(output[0])
st.subheader('Translation: ')
st.write(output[1])
case 'Code Explanation':
st.header('Code Explanation')
code = st.text_input(
"Enter your code snippet here 👇*",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="10")
if code:
result=code_explain(code)
st.subheader("Code explanation:")
st.write(result)
case 'Generate SQL Queries':
st.header('Generate SQL Queries')
query = st.text_input(
"Enter your query objective here 👇*",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="11")
schema= st.text_input(
"Enter your schema here 👇",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="12")
if query and schema:
output=sql_queries(query, schema)
st.subheader('Schema provided: ')
st.write(schema)
st.subheader('Query Objective: ')
st.write(query)
st.subheader('Query Generated: ')
st.write(output)
elif query:
output=sql_queries(query)
st.subheader('Query Objective: ')
st.write(query)
st.subheader('Query Generated: ')
st.write(output)
case 'Programming Language Conversion':
st.header('Convert Code Snippet from one Programming Language to another')
target = st.text_input(
"Enter your target here 👇*",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="13")
code = st.text_input(
"Enter your code here 👇*",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="14")
if target and code:
st.subheader('Generated Code: ')
result=translation(target, code)
st.write(result)
case 'Sentiment Analysis':
st.header('Sentiment Analysis')
text = st.text_input(
"Enter your text here 👇*",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="15")
if text:
output=sentiment(text)
st.subheader("Sentiment of the text:")
st.write(output)
case 'Extract Keywords':
st.header('Extract Keywords from text')
text = st.text_input(
"Enter your text here 👇*",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="16")
if text:
output=keywords(text)
st.subheader("Output:")
st.write(output)
case 'Text Generator from keywords':
st.header('Generate Text from keywords')
words = st.text_input(
"Enter your keywords here 👇*",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="17")
limit = st.text_input(
"Enter your limit here 👇*",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="18")
if words and limit:
output=text_generator(words, limit)
st.subheader("Generated Text:")
st.write(output)
case 'Essay Outline Generator':
st.header('Generate Outline for Essay')
topic = st.text_input(
"Enter your topic here 👇*",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="19")
if topic:
output=essay_outline(topic)
st.subheader("Essay Outline:")
st.write(output)
case 'Essay Generator':
st.header('Generate Essay')
topic = st.text_input(
"Enter your topic here 👇*",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="20")
outline = st.text_input(
"Enter your outline here 👇",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="21")
limit = st.text_input(
"Enter your limit here 👇",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
key="22")
if topic and outline:
if limit:
output=essay_generator(topic, outline=outline,limit=limit)
st.subheader('Generated Essay:')
st.write(output)
else:
output=essay_generator(topic,outline=outline)
st.subheader('Generated Essay:')
st.write(output)
elif topic:
if limit:
output=essay_generator(topic, limit=limit)
st.subheader('Generated Essay:')
st.write(output)
else:
output=essay_generator(topic)
st.subheader('Generated Essay:')
st.write(output) | [
"Translate PLACEHOLDER to PLACEHOLDER",
"Summarize this for a second-grade student:PLACEHOLDER",
"Correct this to standard English:PLACEHOLDER",
"PLACEHOLDER An SQL query to PLACEHOLDER",
"Classify the sentiment of this text:PLACEHOLDER",
"Generate a paragraph in PLACEHOLDER characters using keywords: PLACEHOLDER",
"Detect the language of PLACEHOLDER",
"Explain what the mentioned code is doing: PLACEHOLDER",
"Write an essay in PLACEHOLDER words about PLACEHOLDERusing the outlinePLACEHOLDER",
"Answer the question: PLACEHOLDER",
"Create an outline for an essay aboutPLACEHOLDER",
"Extract keywords from this text: PLACEHOLDER"
] |
2024-01-10 | TeamEpicProjects/Practical-LLM-and-GPT-Applications | SQL_Chain_app.py | import streamlit as st
import sqlite3
import tempfile
import os
from langchain.chains import SQLDatabaseSequentialChain
from langchain import OpenAI, SQLDatabase, SQLDatabaseChain
from langchain.prompts.prompt import PromptTemplate
os.environ['OPENAI_API_KEY'] = 'sk-***********************************************'
# Function to save file contents to a temporary file
def save_file_to_temp(file):
# Create a temporary file
temp_file = tempfile.NamedTemporaryFile(delete=False)
temp_file_path = temp_file.name
# Save the file contents to the temporary file
with open(temp_file_path, 'wb') as f:
f.write(file.read())
return temp_file_path
# Streamlit app code
def main():
# Display file uploader widget
st.header("Query your database using Natural Language.")
file = st.file_uploader("Upload a database file", type=["db"])
if file is not None:
# Save the file to a temporary file
temp_file_path = save_file_to_temp(file)
# Initialize SQLDatabaseSequentialChain from the temporary file
db = SQLDatabase.from_uri(f"sqlite:///{temp_file_path}")
# Perform operations on the database
try:
llm = OpenAI(temperature=0, verbose=True)
chain = SQLDatabaseSequentialChain.from_llm(llm, db, verbose=True, return_intermediate_steps=True)
question = st.text_input("Enter your query about the database.")
if question:
st.write(chain(question))
else:
print()
except:
print()
# Run the Streamlit app
if __name__ == "__main__":
main()
| [] |
2024-01-10 | apocas/restai | app~llms~gemini.py | from typing import Any, List, Mapping, Optional
from langchain.callbacks.manager import CallbackManagerForLLMRun
from langchain_core.language_models.llms import LLM
from vertexai.preview.generative_models import GenerativeModel, Part
class GeminiLLM(LLM):
top_p: Optional[float] = 1
max_output_tokens: Optional[int] = 2048
temperature: Optional[float] = 0.1
def __init__(self, **kwargs: Any):
super(GeminiLLM, self).__init__()
self.top_p = kwargs.get("top_p", self.top_p)
self.max_output_tokens = kwargs.get("max_output_tokens", self.max_output_tokens)
self.temperature = kwargs.get("temperature", self.temperature)
@property
def _llm_type(self) -> str:
return "GeminiLLM"
@property
def _get_model_default_parameters(self):
return {"top_p": self.top_p, "max_output_tokens": self.max_output_tokens, "temperature": self.temperature}
def _call(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> str:
params = {
**self._get_model_default_parameters,
**kwargs
}
model = GenerativeModel("gemini-pro")
responses = model.generate_content(
prompt,
generation_config=params,
)
return responses.text
@property
def _identifying_params(self) -> Mapping[str, Any]:
"""Get the identifying parameters."""
return {"top_p": self.top_p, "max_output_tokens": self.max_output_tokens, "temperature": self.temperature} | [] |
2024-01-10 | apocas/restai | app~project.py | import datetime
import json
import os
import shutil
import time
from app.chat import Chat
from app.models import ProjectModel
from llama_index.memory import ChatMemoryBuffer
from langchain.vectorstores import Chroma
from app.tools import FindEmbeddingsPath
from app.vectordb import vector_delete
class Project:
def __init__(self):
self.chats = []
self.db: None
self.model: ProjectModel
def boot(self, model: ProjectModel):
self.model = model
FindEmbeddingsPath(self.model.name)
def delete(self):
vector_delete(self)
def loadChat(self, chatModel):
current_time = datetime.datetime.now()
one_day_ago = current_time - datetime.timedelta(days=1)
self.chats = [chat for chat in self.chats if hasattr(chat, 'id') and chat.created >= one_day_ago]
for chat in self.chats:
if chat.id == chatModel.id:
return chat
chat = Chat(chatModel)
self.chats.append(chat)
return chat
| [] |
2024-01-10 | apocas/restai | app~llms~tools~refineimage.py | import base64
import io
from pydantic import BaseModel
from torch.multiprocessing import Process, set_start_method, Manager
from app.models import VisionModel
try:
set_start_method('spawn')
except RuntimeError:
pass
from langchain.tools import BaseTool
from diffusers import DiffusionPipeline
import torch
from PIL import Image
from typing import Optional
from langchain.callbacks.manager import (
CallbackManagerForToolRun,
)
def refine_worker(prompt, sharedmem):
refiner = DiffusionPipeline.from_pretrained(
"stabilityai/stable-diffusion-xl-refiner-1.0",
torch_dtype=torch.float16,
use_safetensors=True,
variant="fp16",
)
refiner.to("cuda")
image = refiner(
prompt=prompt,
num_inference_steps=5,
denoising_start=0.8,
image=Image.open(io.BytesIO(base64.b64decode(sharedmem["model"].image))),
).images[0]
image_data = io.BytesIO()
image.save(image_data, format="JPEG")
image_base64 = base64.b64encode(image_data.getvalue()).decode('utf-8')
sharedmem["image"] = image_base64
class RefineImage(BaseTool):
name = "Image refiner"
description = "use this tool when you need to refine an image."
return_direct = True
def _run(self, query: str, run_manager: Optional[CallbackManagerForToolRun] = None) -> str:
manager = Manager()
sharedmem = manager.dict()
sharedmem["model"] = run_manager.tags[0]
query = run_manager.tags[0].question
p = Process(target=refine_worker, args=(query, sharedmem))
p.start()
p.join()
return {"type": "refineimage", "image": sharedmem["image"], "prompt": query}
async def _arun(self, query: str) -> str:
raise NotImplementedError("N/A")
| [
"use this tool when you need to refine an image."
] |
2024-01-10 | apocas/restai | app~llms~tools~stablediffusion.py | import base64
import io
from torch.multiprocessing import Process, set_start_method, Manager
try:
set_start_method('spawn')
except RuntimeError:
pass
from langchain.tools import BaseTool
from langchain.chains import LLMChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from diffusers import DiffusionPipeline
import torch
from typing import Optional
from langchain.callbacks.manager import (
CallbackManagerForToolRun,
)
def sd_worker(prompt, sharedmem):
base = DiffusionPipeline.from_pretrained(
"stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16, variant="fp16", use_safetensors=True
)
base.to("cuda")
refiner = DiffusionPipeline.from_pretrained(
"stabilityai/stable-diffusion-xl-refiner-1.0",
text_encoder_2=base.text_encoder_2,
vae=base.vae,
torch_dtype=torch.float16,
use_safetensors=True,
variant="fp16",
)
refiner.to("cuda")
image = base(
prompt=prompt,
num_inference_steps=40,
denoising_end=0.8,
output_type="latent",
).images
image = refiner(
prompt=prompt,
num_inference_steps=40,
denoising_start=0.8,
image=image,
).images[0]
image_data = io.BytesIO()
image.save(image_data, format="JPEG")
image_base64 = base64.b64encode(image_data.getvalue()).decode('utf-8')
sharedmem["image"] = image_base64
class StableDiffusionImage(BaseTool):
name = "Stable Diffusion Image Generator"
description = "use this tool when you need to generate an image using Stable Diffusion."
return_direct = True
disableboost = False
def _run(self, query: str, run_manager: Optional[CallbackManagerForToolRun] = None) -> str:
if run_manager.tags[0].disableboost == False:
llm = OpenAI(temperature=0.9)
prompt = PromptTemplate(
input_variables=["image_desc"],
template="Generate a detailed prompt to generate an image based on the following description: {image_desc}",
)
chain = LLMChain(llm=llm, prompt=prompt)
fprompt = chain.run(query)
else:
fprompt = run_manager.tags[0].question
manager = Manager()
sharedmem = manager.dict()
p = Process(target=sd_worker, args=(fprompt, sharedmem))
p.start()
p.join()
return {"type": "stablediffusion", "image": sharedmem["image"], "prompt": fprompt}
async def _arun(self, query: str) -> str:
raise NotImplementedError("N/A") | [
"Generate a detailed prompt to generate an image based on the following description: {image_desc}",
"use this tool when you need to generate an image using Stable Diffusion.",
"image_desc"
] |
2024-01-10 | apocas/restai | app~llms~tools~dalle.py | import base64
from langchain.tools import BaseTool
from langchain.chains import LLMChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.utilities.dalle_image_generator import DallEAPIWrapper
import requests
from typing import Optional
from langchain.callbacks.manager import (
CallbackManagerForToolRun,
)
class DalleImage(BaseTool):
name = "Dall-E Image Generator"
description = "use this tool when you need to generate an image using Dall-E."
return_direct = True
def _run(self, query: str, run_manager: Optional[CallbackManagerForToolRun] = None) -> str:
if run_manager.tags[0].disableboost == False:
llm = OpenAI(temperature=0.9)
prompt = PromptTemplate(
input_variables=["image_desc"],
template="Generate a detailed prompt to generate an image based on the following description: {image_desc}",
)
chain = LLMChain(llm=llm, prompt=prompt)
prompt = chain.run(query)
else:
prompt = run_manager.tags[0].question
model = DallEAPIWrapper()
model.model_name = "dall-e-3"
image_url = model.run(prompt)
response = requests.get(image_url)
response.raise_for_status()
image_data = response.content
return {"type": "dalle", "image": base64.b64encode(image_data).decode('utf-8'), "prompt": prompt}
async def _arun(self, query: str) -> str:
raise NotImplementedError("N/A")
| [
"use this tool when you need to generate an image using Dall-E.",
"Generate a detailed prompt to generate an image based on the following description: {image_desc}",
"image_desc"
] |
2024-01-10 | apocas/restai | app~brain.py | import gc
import os
import threading
from llama_index import ServiceContext
from llama_index import (
get_response_synthesizer,
)
from llama_index.embeddings.langchain import LangchainEmbedding
from llama_index.retrievers import VectorIndexRetriever
from llama_index.query_engine import RetrieverQueryEngine
from llama_index.postprocessor import SimilarityPostprocessor
from llama_index.prompts import PromptTemplate
from llama_index.chat_engine.condense_plus_context import CondensePlusContextChatEngine
from langchain.agents import initialize_agent
import torch
from app.llms.llava import LlavaLLM
from app.llms.loader import localLoader
from app.llms.tools.dalle import DalleImage
from app.llms.tools.describeimage import DescribeImage
from app.llms.tools.refineimage import RefineImage
from app.llms.tools.stablediffusion import StableDiffusionImage
from app.model import Model
from app.models import ProjectModel, ProjectModelUpdate, QuestionModel, ChatModel
from app.project import Project
from app.vectordb import vector_init
from modules.embeddings import EMBEDDINGS
from modules.llms import LLMS
from app.database import dbc
from sqlalchemy.orm import Session
from llama_index.llms import LangChainLLM
from langchain.chat_models import ChatOpenAI
from modules.prompts import PROMPTS
class Brain:
def __init__(self):
self.projects = []
self.llmCache = {}
self.embeddingCache = {}
self.defaultCensorship = "This question is outside of my scope. Please ask another question."
self.defaultNegative = "I'm sorry, I don't know the answer to that."
self.defaultSystem = ""
self.loopFailsafe = 0
self.semaphore = threading.BoundedSemaphore()
def memoryModelsInfo(self):
models = []
for llmr, mr in self.llmCache.items():
if mr.privacy == "private":
models.append(llmr)
return models
def unloadLLMs(self):
unloaded = False
models_to_unload = []
for llmr, mr in self.llmCache.items():
if mr.model is not None or mr.tokenizer is not None or isinstance(mr.llm, LlavaLLM):
print("UNLOADING MODEL " + llmr)
models_to_unload.append(llmr)
for modelr in models_to_unload:
if isinstance(self.llmCache[modelr].llm, LlavaLLM):
self.llmCache[modelr].llm.model = None
self.llmCache[modelr].llm.processor = None
self.llmCache[modelr].llm = None
else:
self.llmCache[modelr].llm = None
self.llmCache[modelr].pipe = None
self.llmCache[modelr].tokenizer = None
self.llmCache[modelr].model = None
gc.collect()
torch.cuda.empty_cache()
if isinstance(self.llmCache[modelr].llm, LlavaLLM):
del self.llmCache[modelr].llm.model
del self.llmCache[modelr].llm.processor
del self.llmCache[modelr].llm
else:
del self.llmCache[modelr].llm
del self.llmCache[modelr].pipe
del self.llmCache[modelr].tokenizer
del self.llmCache[modelr].model
self.llmCache[modelr] = None
del self.llmCache[modelr]
gc.collect()
torch.cuda.empty_cache()
unloaded = True
return unloaded
def getLLM(self, llmModel, forced=False, **kwargs):
new = False
if llmModel in self.llmCache:
return self.llmCache[llmModel], False
else:
new = True
if forced == False:
self.semaphore.acquire()
unloaded = self.unloadLLMs()
if llmModel in LLMS:
llm_class, llm_args, prompt, privacy, description, typel, llm_node = LLMS[
llmModel]
if llm_class == localLoader:
print("LOADING MODEL " + llmModel)
llm, model, tokenizer, pipe = llm_class(
**llm_args, **kwargs)
m = Model(
llmModel,
llm,
prompt,
privacy,
model,
tokenizer,
pipe,
typel)
else:
if llm_class == LlavaLLM:
print("LOADING MODEL " + llmModel)
llm = llm_class(**llm_args, **kwargs)
m = Model(llmModel, llm, prompt, privacy, type=typel)
self.llmCache[llmModel] = m
return m, new
else:
raise Exception("Invalid LLM type.")
def getEmbedding(self, embeddingModel):
if embeddingModel in self.embeddingCache:
return self.embeddingCache[embeddingModel]
else:
if embeddingModel in EMBEDDINGS:
embedding_class, embedding_args, privacy, description = EMBEDDINGS[embeddingModel]
model = LangchainEmbedding(embedding_class(**embedding_args))
self.embeddingCache[embeddingModel] = model
return model
else:
raise Exception("Invalid Embedding type.")
def findProject(self, name, db):
for project in self.projects:
if project.model.name == name:
if os.environ["RESTAI_NODE"] != "node1":
p = dbc.get_project_by_name(db, name)
if p is None:
return None
proj = ProjectModel.model_validate(p)
project.model = proj
return project
p = dbc.get_project_by_name(db, name)
if p is None:
return None
proj = ProjectModel.model_validate(p)
if proj is not None:
project = Project()
project.model = proj
project.db = vector_init(self, project)
self.projects.append(project)
return project
def createProject(self, projectModel, db):
dbc.create_project(
db,
projectModel.name,
projectModel.embeddings,
projectModel.llm,
projectModel.system,
projectModel.sandboxed,
projectModel.censorship,
projectModel.vectorstore,
)
project = Project()
project.boot(projectModel)
project.db = vector_init(self, project)
self.projects.append(project)
return project
def editProject(self, name, projectModel: ProjectModelUpdate, db):
project = self.findProject(name, db)
if project is None:
return False
proj_db = dbc.get_project_by_name(db, name)
if proj_db is None:
raise Exception("Project not found")
changed = False
if projectModel.llm is not None and proj_db.llm != projectModel.llm:
proj_db.llm = projectModel.llm
changed = True
if projectModel.sandboxed is not None and proj_db.sandboxed != projectModel.sandboxed:
proj_db.sandboxed = projectModel.sandboxed
changed = True
if projectModel.system is not None and proj_db.system != projectModel.system:
proj_db.system = projectModel.system
changed = True
if projectModel.censorship is not None and proj_db.censorship != projectModel.censorship:
proj_db.censorship = projectModel.censorship
changed = True
if projectModel.k is not None and proj_db.k != projectModel.k:
proj_db.k = projectModel.k
changed = True
if projectModel.score is not None and proj_db.score != projectModel.score:
proj_db.score = projectModel.score
changed = True
if projectModel.sandbox_project is not None and proj_db.sandbox_project != projectModel.sandbox_project:
proj_db.sandbox_project = projectModel.sandbox_project
changed = True
if proj_db.sandboxed == True and projectModel.sandbox_project is None:
proj_db.sandbox_project = None
changed = True
if changed:
dbc.update_project(db)
project.model = ProjectModel.model_validate(proj_db)
return project
def deleteProject(self, name, db):
self.findProject(name, db)
dbc.delete_project(db, dbc.get_project_by_name(db, name))
proj = self.findProject(name, db)
if proj is not None:
proj.delete()
self.projects.remove(proj)
return True
def entryChat(self, projectName: str, input: ChatModel, db: Session):
self.loopFailsafe = 0
output = self.recursiveChat(projectName, input, db)
return output
def recursiveChat(
self,
projectName: str,
input: ChatModel,
db: Session,
chatR=None):
project = self.findProject(projectName, db)
if chatR:
chat = chatR
questionInput = QuestionModel(
question=input.question,
)
answer, docs, censored = self.questionContext(
project, questionInput)
output = {"source_documents": docs, "answer": answer}
else:
output, censored = self.chat(project, input)
if censored:
projectc = self.findProject(project.model.sandbox_project, db)
if projectc is not None:
if self.loopFailsafe >= 10:
return chat, {"source_documents": [],
"answer": self.defaultNegative}
self.loopFailsafe += 1
output = self.recursiveChat(
project.model.sandbox_project, input, db, chat)
return output
def chat(self, project, chatModel):
model, loaded = self.getLLM(project.model.llm)
chat = project.loadChat(chatModel)
threshold = chatModel.score or project.model.score or 0.2
k = chatModel.k or project.model.k or 1
prompt_template_txt = PROMPTS[model.prompt]
sysTemplate = project.model.system or self.defaultSystem
prompt_template = prompt_template_txt.format(
system=sysTemplate)
service_context = ServiceContext.from_defaults(
llm=LangChainLLM(llm=model.llm)
)
service_context.llm.query_wrapper_prompt = prompt_template
retriever = VectorIndexRetriever(
index=project.db,
similarity_top_k=k,
)
llm = LangChainLLM(model.llm)
#llm.query_wrapper_prompt = prompt_template
chat_engine = CondensePlusContextChatEngine(
retriever=retriever,
llm=llm,
node_postprocessors=[SimilarityPostprocessor(
similarity_cutoff=threshold)],
memory=chat.history,
verbose=True,
context_prompt=(
"You are a chatbot, able to have normal interactions, as well as talk about the provided context.\n"
"Here are the relevant documents for the context:\n"
"{context_str}"
"\nInstruction: Use the previous chat history, or the context above, to interact and help the user."
)
)
response = chat_engine.chat(chatModel.question)
if loaded == True:
self.semaphore.release()
output_nodes = []
for node in response.source_nodes:
output_nodes.append(
{"source": node.metadata["source"], "keywords": node.metadata["keywords"], "score": node.score, "id": node.node_id, "text": node.text})
output = {
"id": chat.id,
"question": chatModel.question,
"answer": response.response,
"sources": output_nodes,
"type": "chat"
}
censored = False
if project.model.sandboxed and len(response.source_nodes) == 0:
censored = True
output["answer"] = project.model.censorship or self.defaultCensorship
return output, censored
def entryQuestion(
self,
projectName: str,
input: QuestionModel,
db: Session):
self.loopFailsafe = 0
return self.recursiveQuestion(projectName, input, db)
def recursiveQuestion(
self,
projectName: str,
input: QuestionModel,
db: Session,
recursive=False):
project = self.findProject(projectName, db)
output, censored = self.questionContext(
project, input, recursive)
if censored:
projectc = self.findProject(project.model.sandbox_project, db)
if projectc is not None:
if self.loopFailsafe >= 10:
return self.defaultNegative, []
self.loopFailsafe += 1
output, censored = self.recursiveQuestion(
project.model.sandbox_project, input, db, True)
return output, censored
def questionContext(self, project, questionModel, child=False):
model, loaded = self.getLLM(project.model.llm)
prompt_template_txt = PROMPTS[model.prompt]
if child:
sysTemplate = project.model.system or self.defaultSystem
else:
sysTemplate = questionModel.system or project.model.system or self.defaultSystem
prompt_template = prompt_template_txt.format(system=sysTemplate)
#query_wrapper_prompt = PromptTemplate(prompt_template)
k = questionModel.k or project.model.k or 2
threshold = questionModel.score or project.model.score or 0.2
service_context = ServiceContext.from_defaults(
llm=LangChainLLM(llm=model.llm)
)
service_context.llm.query_wrapper_prompt = prompt_template
retriever = VectorIndexRetriever(
index=project.db,
similarity_top_k=k,
)
qa_prompt_tmpl = (
"Context information is below.\n"
"---------------------\n"
"{context_str}\n"
"---------------------\n"
"Given the context information and not prior knowledge, "
"answer the query.\n"
"Query: {query_str}\n"
"Answer: "
)
if isinstance(model.llm, ChatOpenAI):
qa_prompt_tmpl = sysTemplate + "\n" + qa_prompt_tmpl
qa_prompt = PromptTemplate(qa_prompt_tmpl)
response_synthesizer = get_response_synthesizer(
service_context=service_context, text_qa_template=qa_prompt)
query_engine = RetrieverQueryEngine(
retriever=retriever,
response_synthesizer=response_synthesizer,
node_postprocessors=[SimilarityPostprocessor(
similarity_cutoff=threshold)]
)
response = query_engine.query(questionModel.question)
if loaded == True:
self.semaphore.release()
output_nodes = []
for node in response.source_nodes:
output_nodes.append(
{"source": node.metadata["source"], "keywords": node.metadata["keywords"], "score": node.score, "id": node.node_id, "text": node.text})
output = {
"question": questionModel.question,
"answer": response.response,
"sources": output_nodes,
"type": "question"
}
censored = False
if project.model.sandboxed and len(response.source_nodes) == 0:
censored = True
output["answer"] = project.model.censorship or self.defaultCensorship
return output, censored
def entryVision(self, projectName, visionInput, db: Session):
image = None
output = ""
project = self.findProject(projectName, db)
if project is None:
raise Exception("Project not found")
tools = [
DalleImage(),
StableDiffusionImage(),
RefineImage(),
DescribeImage(),
]
model, loaded = self.getLLM("openai", True)
self.semaphore.acquire()
self.unloadLLMs()
agent = initialize_agent(
tools, model.llm, agent="zero-shot-react-description", verbose=True)
outputAgent = agent.run(visionInput.question, tags=[visionInput])
if isinstance(outputAgent, str):
output = outputAgent
else:
if outputAgent["type"] == "describeimage":
model, loaded = self.getLLM(project.model.llm, True)
prompt_template_txt = PROMPTS[model.prompt]
input = prompt_template_txt.format(
query_str=visionInput.question)
output = model.llm.llavaInference(input, visionInput.image)
else:
output = outputAgent["prompt"]
image = outputAgent["image"]
try:
self.semaphore.release()
except ValueError:
pass
return output, [], image
| [
"PLACEHOLDER\nqa_prompt_tmpl61fa4245-e49a-40d3-bf76-e1e7e81440e1",
"PLACEHOLDER\nPLACEHOLDER\nqa_prompt_tmpld2a65818-3850-4602-b204-dcd528e4a278",
"Context information is below.\n---------------------\n{context_str}\n---------------------\nGiven the context information and not prior knowledge, answer the query.\nQuery: {query_str}\nAnswer: "
] |
2024-01-10 | apocas/restai | modules~llms.py | from langchain.llms import GPT4All, LlamaCpp, OpenAI
from langchain.chat_models import ChatOpenAI, ChatVertexAI
from app.llms.gemini import GeminiLLM
from app.llms.llava import LlavaLLM
from app.llms.loader import localLoader
LLMS = {
# "name": (LOADER, {"args": "here"}, "Prompt (check prompts.py)", "Privacy (public/private)", "Description...", "type (text/vision)", "Execution node", "chat/qa/both"),
"openai": (OpenAI, {"temperature": 0, "model_name": "text-davinci-003"}, "openai", "public", "OpenAI Davinci", "chat", "node1"),
# "llama2_7b_cpp": (LlamaCpp, {"temperature": 0, "model_path": "./models/llama-2-7b.Q4_K_M.gguf"}, "llama", "private", "Llamacpp", "qa", "node1"),
"openai_gpt3.5": (ChatOpenAI, {"temperature": 0, "model_name": "gpt-3.5-turbo"}, "openai", "public", "OpenAI GPT-3.5 Turbo", "chat", "node1"),
"openai_gpt4": (ChatOpenAI, {"temperature": 0, "model_name": "gpt-4"}, "openai", "public", "OpenAI GPT-4 ", "chat", "node1"),
"openai_gpt4_turbo": (ChatOpenAI, {"temperature": 0, "model_name": "gpt-4-1106-preview"}, "openai", "public", "OpenAI GPT-4 Turbo", "chat", "node1"),
"google_vertexai_bison": (ChatVertexAI, {"model_name": "chat-bison@002", "max_output_tokens": 1000, "temperature": 0.1}, "openai", "public", "Google Vertex AI chat-bison@002", "qa", "node1"),
"google_geminipro": (GeminiLLM, {"max_output_tokens": 2048, "temperature": 0.6, "top_p": 1}, "gemini", "public", "Google Gemini Pro", "chat", "node1"),
# "llama13b_chat_gptq": (ChatOpenAI, {"temperature": 0.3, "openai_api_key": "na", "openai_api_base": "http://127.0.0.1:5000/v1"}, "llama", "private", "Llama 13B Chat GPTQ", "qa", "node1"),
"mistral7b_gptq": (localLoader, {"type": "gptq", "model": "TheBloke/Mistral-7B-OpenOrca-GPTQ"}, "openai", "private", "https://huggingface.co/TheBloke/Mistral-7B-OpenOrca-GPTQ", "qa", "node1"),
"llama13b_chat_gptq": (localLoader, {"type": "gptq", "model": "TheBloke/Llama-2-13B-chat-GPTQ"}, "llama", "private", "https://huggingface.co/TheBloke/Llama-2-13B-chat-GPTQ", "qa", "node1"),
"wizardlm13b_gptq": (localLoader, {"type": "gptq", "model": "TheBloke/WizardLM-13B-V1.2-GPTQ"}, "vicuna", "private", "https://huggingface.co/TheBloke/WizardLM-13B-V1.2-GPTQ", "qa", "node1"),
"spicyboros13b_gptq": (localLoader, {"type": "gptq", "model": "TheBloke/Spicyboros-13B-2.2-GPTQ"}, "spicy", "private", "https://huggingface.co/TheBloke/Spicyboros-13B-2.2-GPTQ", "qa", "node1"),
"llava_1.5_13b": (LlavaLLM, {"model": "llava-hf/llava-1.5-13b-hf"}, "llava", "private", "https://huggingface.co/llava-hf/llava-1.5-13b-hf", "vision", "node1"),
"bakllava_v1": (LlavaLLM, {"model": "llava-hf/bakLlava-v1-hf"}, "llava", "private", "https://huggingface.co/llava-hf/bakLlava-v1-hf", "vision", "node1"),
"mixtral8x7b_instruct_gptq": (localLoader, {"type": "gptq", "model": "TheBloke/Mixtral-8x7B-Instruct-v0.1-GPTQ", "temperature": 0.7}, "mistral", "private", "https://huggingface.co/TheBloke/Mixtral-8x7B-Instruct-v0.1-GPTQ", "qa", "node2"),
"llama2_70b_chat_gptq": (localLoader, {"type": "gptq", "model": "TheBloke/Llama-2-70B-Chat-GPTQ"}, "llama", "private", "https://huggingface.co/TheBloke/Llama-2-70B-Chat-GPTQ", "qa", "node2"),
}
| [] |
2024-01-10 | apocas/restai | app~llms~tools~describeimage.py | from langchain.tools import BaseTool
class DescribeImage(BaseTool):
name = "Describe Image"
description = "use this tool to describe an image."
return_direct = True
def _run(self, query: str) -> str:
return {"type": "describeimage", "image": None, "prompt": query}
async def _arun(self, query: str) -> str:
raise NotImplementedError("N/A")
| [
"use this tool to describe an image."
] |
2024-01-10 | apocas/restai | app~llms~loader.py | def localLoader(type, model, temperature=0.0001):
if type == "gptq":
return loadTransformers(model, temperature)
else:
raise Exception("Invalid LLM type.")
def loadTransformers(modelName, temp):
from langchain.llms.huggingface_pipeline import HuggingFacePipeline
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline, logging
model = AutoModelForCausalLM.from_pretrained(
modelName, device_map="auto", trust_remote_code=False, revision="main")
# logging.set_verbosity(logging.CRITICAL)
tokenizer = AutoTokenizer.from_pretrained(modelName, use_fast=True)
pipe = pipeline(
"text-generation",
model=model,
tokenizer=tokenizer,
return_full_text=False,
max_new_tokens=512,
do_sample=True,
temperature=temp or 0.0001,
top_p=0.95,
top_k=40,
repetition_penalty=1.15
)
return HuggingFacePipeline(pipeline=pipe), model, tokenizer, pipe
| [] |
2024-01-10 | Chad-Wyck/codeinterpreter-api | codeinterpreterapi~chains~rm_dl_link.py | from langchain.base_language import BaseLanguageModel
from langchain.chat_models.openai import ChatOpenAI
from langchain.schema import AIMessage, OutputParserException
from codeinterpreterapi.prompts import remove_dl_link_prompt
def remove_download_link(
input_response: str,
llm: BaseLanguageModel,
) -> str:
messages = remove_dl_link_prompt.format_prompt(
input_response=input_response
).to_messages()
message = llm.predict_messages(messages)
if not isinstance(message, AIMessage):
raise OutputParserException("Expected an AIMessage")
return message.content
async def aremove_download_link(
input_response: str,
llm: BaseLanguageModel,
) -> str:
messages = remove_dl_link_prompt.format_prompt(
input_response=input_response
).to_messages()
message = await llm.apredict_messages(messages)
if not isinstance(message, AIMessage):
raise OutputParserException("Expected an AIMessage")
return message.content
def test():
llm = ChatOpenAI(model="gpt-3.5-turbo-0613") # type: ignore
example = (
"I have created the plot to your dataset.\n\n"
"Link to the file [here](sandbox:/plot.png)."
)
print(remove_download_link(example, llm))
if __name__ == "__main__":
from dotenv import load_dotenv
load_dotenv()
test()
| [] |
2024-01-10 | Chad-Wyck/codeinterpreter-api | codeinterpreterapi~parser.py | from __future__ import annotations
import re
from typing import Union
from langchain.agents import AgentOutputParser
from langchain.chat_models.base import BaseChatModel
from langchain.output_parsers.json import parse_json_markdown
from langchain.schema import AgentAction, AgentFinish, OutputParserException
from codeinterpreterapi.chains import extract_python_code
class CodeAgentOutputParser(AgentOutputParser):
ai_prefix: str = "AI"
def get_format_instructions(self) -> str:
from langchain.agents.conversational.prompt import FORMAT_INSTRUCTIONS
return FORMAT_INSTRUCTIONS
def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
if f"{self.ai_prefix}:" in text:
return AgentFinish(
{"output": text.split(f"{self.ai_prefix}:")[-1].strip()}, text
)
regex = r"Action: (.*?)[\n]*Action Input: (.*)"
match = re.search(regex, text)
if not match:
raise OutputParserException(f"Could not parse LLM output: `{text}`")
action = match.group(1)
action_input = match.group(2)
return AgentAction(action.strip(), action_input.strip(" ").strip('"'), text)
@property
def _type(self) -> str:
return "conversational"
class CodeChatAgentOutputParser(AgentOutputParser):
def get_format_instructions(self) -> str:
from langchain.agents.conversational_chat.prompt import FORMAT_INSTRUCTIONS
return FORMAT_INSTRUCTIONS
def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
raise NotImplementedError
async def aparse(
self, text: str, llm: BaseChatModel
) -> Union[AgentAction, AgentFinish]:
try:
response = parse_json_markdown(text)
action, action_input = response["action"], response["action_input"]
if action == "Final Answer":
return AgentFinish({"output": action_input}, text)
else:
return AgentAction(action, action_input, text)
except Exception:
if '"action": "python"' in text:
# extract python code from text with prompt
text = extract_python_code(text, llm=llm) or ""
match = re.search(r"```python\n(.*?)```", text)
if match:
code = match.group(1).replace("\\n", "; ")
return AgentAction("python", code, text)
raise OutputParserException(f"Could not parse LLM output: `{text}`")
@property
def _type(self) -> str:
return "conversational_chat"
| [] |
2024-01-10 | Chad-Wyck/codeinterpreter-api | codeinterpreterapi~session.py | import base64
import re
import traceback
from io import BytesIO
from os import getenv
from typing import Optional
from uuid import UUID, uuid4
from codeboxapi import CodeBox # type: ignore
from codeboxapi.schema import CodeBoxOutput # type: ignore
from langchain.agents import (
AgentExecutor,
BaseSingleActionAgent,
ConversationalAgent,
ConversationalChatAgent,
)
from langchain.chat_models import AzureChatOpenAI, ChatAnthropic, ChatOpenAI
from langchain.chat_models.base import BaseChatModel
from langchain.memory import ConversationBufferMemory
from langchain.memory.chat_message_histories import (
ChatMessageHistory,
PostgresChatMessageHistory,
RedisChatMessageHistory,
)
from langchain.prompts.chat import MessagesPlaceholder
from langchain.schema import BaseChatMessageHistory, BaseLanguageModel
from langchain.tools import BaseTool, StructuredTool
from codeinterpreterapi.agents import OpenAIFunctionsAgent
from codeinterpreterapi.chains import (
aget_file_modifications,
aremove_download_link,
get_file_modifications,
remove_download_link,
)
from codeinterpreterapi.chat_history import CodeBoxChatMessageHistory
from codeinterpreterapi.config import settings
from codeinterpreterapi.parser import CodeAgentOutputParser, CodeChatAgentOutputParser
from codeinterpreterapi.prompts import code_interpreter_system_message
from codeinterpreterapi.schema import (
CodeInput,
CodeInterpreterResponse,
File,
SessionStatus,
UserRequest,
)
class CodeInterpreterSession:
def __init__(
self,
llm: Optional[BaseLanguageModel] = None,
additional_tools: list[BaseTool] = [],
**kwargs,
) -> None:
self.codebox = CodeBox()
self.verbose = kwargs.get("verbose", settings.VERBOSE)
self.tools: list[BaseTool] = self._tools(additional_tools)
self.llm: BaseLanguageModel = llm or self._choose_llm(**kwargs)
self.agent_executor: Optional[AgentExecutor] = None
self.input_files: list[File] = []
self.output_files: list[File] = []
self.code_log: list[tuple[str, str]] = []
@classmethod
def from_id(cls, session_id: UUID, **kwargs) -> "CodeInterpreterSession":
session = cls(**kwargs)
session.codebox = CodeBox.from_id(session_id)
session.agent_executor = session._agent_executor()
return session
@property
def session_id(self) -> Optional[UUID]:
return self.codebox.session_id
def start(self) -> SessionStatus:
status = SessionStatus.from_codebox_status(self.codebox.start())
self.agent_executor = self._agent_executor()
return status
async def astart(self) -> SessionStatus:
status = SessionStatus.from_codebox_status(await self.codebox.astart())
self.agent_executor = self._agent_executor()
return status
def _tools(self, additional_tools: list[BaseTool]) -> list[BaseTool]:
return additional_tools + [
StructuredTool(
name="python",
description="Input a string of code to a ipython interpreter. "
"Write the entire code in a single string. This string can "
"be really long, so you can use the `;` character to split lines. "
"Variables are preserved between runs. ",
func=self._run_handler,
coroutine=self._arun_handler,
args_schema=CodeInput,
),
]
def _choose_llm(
self, model: str = "gpt-4", openai_api_key: Optional[str] = None, **kwargs
) -> BaseChatModel:
if "gpt" in model:
openai_api_key = (
openai_api_key
or settings.OPENAI_API_KEY
or getenv("OPENAI_API_KEY", None)
)
if openai_api_key is None:
raise ValueError(
"OpenAI API key missing. Set OPENAI_API_KEY env variable "
"or pass `openai_api_key` to session."
)
openai_api_version = getenv("OPENAI_API_VERSION")
openai_api_base = getenv("OPENAI_API_BASE")
deployment_name = getenv("DEPLOYMENT_NAME")
openapi_type = getenv("OPENAI_API_TYPE")
if (
openapi_type == "azure"
and openai_api_version
and openai_api_base
and deployment_name
):
return AzureChatOpenAI(
temperature=0.03,
openai_api_base=openai_api_base,
openai_api_version=openai_api_version,
deployment_name=deployment_name,
openai_api_key=openai_api_key,
max_retries=3,
request_timeout=60 * 3,
) # type: ignore
else:
return ChatOpenAI(
temperature=0.03,
model=model,
openai_api_key=openai_api_key,
max_retries=3,
request_timeout=60 * 3,
) # type: ignore
elif "claude" in model:
return ChatAnthropic(model=model)
else:
raise ValueError(f"Unknown model: {model} (expected gpt or claude model)")
def _choose_agent(self) -> BaseSingleActionAgent:
return (
OpenAIFunctionsAgent.from_llm_and_tools(
llm=self.llm,
tools=self.tools,
system_message=code_interpreter_system_message,
extra_prompt_messages=[
MessagesPlaceholder(variable_name="chat_history")
],
)
if isinstance(self.llm, ChatOpenAI)
else ConversationalChatAgent.from_llm_and_tools(
llm=self.llm,
tools=self.tools,
system_message=code_interpreter_system_message.content,
output_parser=CodeChatAgentOutputParser(),
)
if isinstance(self.llm, BaseChatModel)
else ConversationalAgent.from_llm_and_tools(
llm=self.llm,
tools=self.tools,
prefix=code_interpreter_system_message.content,
output_parser=CodeAgentOutputParser(),
)
)
def _history_backend(self) -> BaseChatMessageHistory:
return (
CodeBoxChatMessageHistory(codebox=self.codebox)
if settings.HISTORY_BACKEND == "codebox"
else RedisChatMessageHistory(
session_id=str(self.session_id),
url=settings.REDIS_URL,
)
if settings.HISTORY_BACKEND == "redis"
else PostgresChatMessageHistory(
session_id=str(self.session_id),
connection_string=settings.POSTGRES_URL,
)
if settings.HISTORY_BACKEND == "postgres"
else ChatMessageHistory()
)
def _agent_executor(self) -> AgentExecutor:
return AgentExecutor.from_agent_and_tools(
agent=self._choose_agent(),
max_iterations=9,
tools=self.tools,
verbose=self.verbose,
memory=ConversationBufferMemory(
memory_key="chat_history",
return_messages=True,
chat_memory=self._history_backend(),
),
)
def show_code(self, code: str) -> None:
if self.verbose:
print(code)
async def ashow_code(self, code: str) -> None:
"""Callback function to show code to the user."""
if self.verbose:
print(code)
def _run_handler(self, code: str):
"""Run code in container and send the output to the user"""
self.show_code(code)
output: CodeBoxOutput = self.codebox.run(code)
self.code_log.append((code, output.content))
if not isinstance(output.content, str):
raise TypeError("Expected output.content to be a string.")
if output.type == "image/png":
filename = f"image-{uuid4()}.png"
file_buffer = BytesIO(base64.b64decode(output.content))
file_buffer.name = filename
self.output_files.append(File(name=filename, content=file_buffer.read()))
return f"Image {filename} got send to the user."
elif output.type == "error":
if "ModuleNotFoundError" in output.content:
if package := re.search(
r"ModuleNotFoundError: No module named '(.*)'", output.content
):
self.codebox.install(package.group(1))
return (
f"{package.group(1)} was missing but "
"got installed now. Please try again."
)
else:
# TODO: preanalyze error to optimize next code generation
pass
if self.verbose:
print("Error:", output.content)
elif modifications := get_file_modifications(code, self.llm):
for filename in modifications:
if filename in [file.name for file in self.input_files]:
continue
fileb = self.codebox.download(filename)
if not fileb.content:
continue
file_buffer = BytesIO(fileb.content)
file_buffer.name = filename
self.output_files.append(
File(name=filename, content=file_buffer.read())
)
return output.content
async def _arun_handler(self, code: str):
"""Run code in container and send the output to the user"""
await self.ashow_code(code)
output: CodeBoxOutput = await self.codebox.arun(code)
self.code_log.append((code, output.content))
if not isinstance(output.content, str):
raise TypeError("Expected output.content to be a string.")
if output.type == "image/png":
filename = f"image-{uuid4()}.png"
file_buffer = BytesIO(base64.b64decode(output.content))
file_buffer.name = filename
self.output_files.append(File(name=filename, content=file_buffer.read()))
return f"Image {filename} got send to the user."
elif output.type == "error":
if "ModuleNotFoundError" in output.content:
if package := re.search(
r"ModuleNotFoundError: No module named '(.*)'", output.content
):
await self.codebox.ainstall(package.group(1))
return (
f"{package.group(1)} was missing but "
"got installed now. Please try again."
)
else:
# TODO: preanalyze error to optimize next code generation
pass
if self.verbose:
print("Error:", output.content)
elif modifications := await aget_file_modifications(code, self.llm):
for filename in modifications:
if filename in [file.name for file in self.input_files]:
continue
fileb = await self.codebox.adownload(filename)
if not fileb.content:
continue
file_buffer = BytesIO(fileb.content)
file_buffer.name = filename
self.output_files.append(
File(name=filename, content=file_buffer.read())
)
return output.content
def _input_handler(self, request: UserRequest) -> None:
"""Callback function to handle user input."""
if not request.files:
return
if not request.content:
request.content = (
"I uploaded, just text me back and confirm that you got the file(s)."
)
request.content += "\n**The user uploaded the following files: **\n"
for file in request.files:
self.input_files.append(file)
request.content += f"[Attachment: {file.name}]\n"
self.codebox.upload(file.name, file.content)
request.content += "**File(s) are now available in the cwd. **\n"
async def _ainput_handler(self, request: UserRequest):
# TODO: variables as context to the agent
# TODO: current files as context to the agent
if not request.files:
return
if not request.content:
request.content = (
"I uploaded, just text me back and confirm that you got the file(s)."
)
request.content += "\n**The user uploaded the following files: **\n"
for file in request.files:
self.input_files.append(file)
request.content += f"[Attachment: {file.name}]\n"
await self.codebox.aupload(file.name, file.content)
request.content += "**File(s) are now available in the cwd. **\n"
def _output_handler(self, final_response: str) -> CodeInterpreterResponse:
"""Embed images in the response"""
for file in self.output_files:
if str(file.name) in final_response:
# rm  from the response
final_response = re.sub(r"\n\n!\[.*\]\(.*\)", "", final_response)
if self.output_files and re.search(r"\n\[.*\]\(.*\)", final_response):
try:
final_response = remove_download_link(final_response, self.llm)
except Exception as e:
if self.verbose:
print("Error while removing download links:", e)
output_files = self.output_files
code_log = self.code_log
self.output_files = []
self.code_log = []
return CodeInterpreterResponse(
content=final_response, files=output_files, code_log=code_log
)
async def _aoutput_handler(self, final_response: str) -> CodeInterpreterResponse:
"""Embed images in the response"""
for file in self.output_files:
if str(file.name) in final_response:
# rm  from the response
final_response = re.sub(r"\n\n!\[.*\]\(.*\)", "", final_response)
if self.output_files and re.search(r"\n\[.*\]\(.*\)", final_response):
try:
final_response = await aremove_download_link(final_response, self.llm)
except Exception as e:
if self.verbose:
print("Error while removing download links:", e)
output_files = self.output_files
code_log = self.code_log
self.output_files = []
self.code_log = []
return CodeInterpreterResponse(
content=final_response, files=output_files, code_log=code_log
)
def generate_response_sync(
self,
user_msg: str,
files: list[File] = [],
detailed_error: bool = False,
) -> CodeInterpreterResponse:
"""Generate a Code Interpreter response based on the user's input."""
user_request = UserRequest(content=user_msg, files=files)
try:
self._input_handler(user_request)
assert self.agent_executor, "Session not initialized."
response = self.agent_executor.run(input=user_request.content)
return self._output_handler(response)
except Exception as e:
if self.verbose:
traceback.print_exc()
if detailed_error:
return CodeInterpreterResponse(
content="Error in CodeInterpreterSession: "
f"{e.__class__.__name__} - {e}"
)
else:
return CodeInterpreterResponse(
content="Sorry, something went while generating your response."
"Please try again or restart the session."
)
async def generate_response(
self,
user_msg: str,
files: list[File] = [],
detailed_error: bool = False,
) -> CodeInterpreterResponse:
print(
"DEPRECATION WARNING: Use agenerate_response for async generation.\n"
"This function will be converted to sync in the future.\n"
"You can use generate_response_sync for now.",
)
return await self.agenerate_response(
user_msg=user_msg,
files=files,
detailed_error=detailed_error,
)
async def agenerate_response(
self,
user_msg: str,
files: list[File] = [],
detailed_error: bool = False,
) -> CodeInterpreterResponse:
"""Generate a Code Interpreter response based on the user's input."""
user_request = UserRequest(content=user_msg, files=files)
try:
await self._ainput_handler(user_request)
assert self.agent_executor, "Session not initialized."
response = await self.agent_executor.arun(input=user_request.content)
return await self._aoutput_handler(response)
except Exception as e:
if self.verbose:
traceback.print_exc()
if detailed_error:
return CodeInterpreterResponse(
content="Error in CodeInterpreterSession: "
f"{e.__class__.__name__} - {e}"
)
else:
return CodeInterpreterResponse(
content="Sorry, something went while generating your response."
"Please try again or restart the session."
)
def is_running(self) -> bool:
return self.codebox.status() == "running"
async def ais_running(self) -> bool:
return await self.codebox.astatus() == "running"
def stop(self) -> SessionStatus:
return SessionStatus.from_codebox_status(self.codebox.stop())
async def astop(self) -> SessionStatus:
return SessionStatus.from_codebox_status(await self.codebox.astop())
def __enter__(self) -> "CodeInterpreterSession":
self.start()
return self
def __exit__(self, exc_type, exc_value, traceback) -> None:
self.stop()
async def __aenter__(self) -> "CodeInterpreterSession":
await self.astart()
return self
async def __aexit__(self, exc_type, exc_value, traceback) -> None:
await self.astop()
| [] |
2024-01-10 | Chad-Wyck/codeinterpreter-api | codeinterpreterapi~agents~functions_agent.py | """Module implements an agent that uses OpenAI's APIs function enabled API."""
import json
from dataclasses import dataclass
from json import JSONDecodeError
from typing import Any, List, Optional, Sequence, Tuple, Union
from langchain.agents import BaseSingleActionAgent
from langchain.callbacks.base import BaseCallbackManager
from langchain.callbacks.manager import Callbacks
from langchain.chat_models.openai import ChatOpenAI
from langchain.prompts.chat import (
BaseMessagePromptTemplate,
ChatPromptTemplate,
HumanMessagePromptTemplate,
MessagesPlaceholder,
)
from langchain.schema import (
AgentAction,
AgentFinish,
BasePromptTemplate,
OutputParserException,
)
from langchain.schema.language_model import BaseLanguageModel
from langchain.schema.messages import (
AIMessage,
BaseMessage,
FunctionMessage,
SystemMessage,
)
from langchain.tools import BaseTool
from langchain.tools.convert_to_openai import format_tool_to_openai_function
from pydantic import root_validator
@dataclass
class _FunctionsAgentAction(AgentAction):
message_log: List[BaseMessage]
def _convert_agent_action_to_messages(
agent_action: AgentAction, observation: str
) -> List[BaseMessage]:
"""Convert an agent action to a message.
This code is used to reconstruct the original AI message from the agent action.
Args:
agent_action: Agent action to convert.
Returns:
AIMessage that corresponds to the original tool invocation.
"""
if isinstance(agent_action, _FunctionsAgentAction):
return agent_action.message_log + [
_create_function_message(agent_action, observation)
]
else:
return [AIMessage(content=agent_action.log)]
def _create_function_message(
agent_action: AgentAction, observation: str
) -> FunctionMessage:
"""Convert agent action and observation into a function message.
Args:
agent_action: the tool invocation request from the agent
observation: the result of the tool invocation
Returns:
FunctionMessage that corresponds to the original tool invocation
"""
if not isinstance(observation, str):
try:
content = json.dumps(observation, ensure_ascii=False)
except Exception:
content = str(observation)
else:
content = observation
return FunctionMessage(
name=agent_action.tool,
content=content,
)
def _format_intermediate_steps(
intermediate_steps: List[Tuple[AgentAction, str]],
) -> List[BaseMessage]:
"""Format intermediate steps.
Args:
intermediate_steps: Steps the LLM has taken to date, along with observations
Returns:
list of messages to send to the LLM for the next prediction
"""
messages = []
for intermediate_step in intermediate_steps:
agent_action, observation = intermediate_step
messages.extend(_convert_agent_action_to_messages(agent_action, observation))
return messages
def _parse_ai_message(message: BaseMessage) -> Union[AgentAction, AgentFinish]:
"""Parse an AI message."""
if not isinstance(message, AIMessage):
raise TypeError(f"Expected an AI message got {type(message)}")
function_call = message.additional_kwargs.get("function_call", {})
if function_call:
function_name = function_call["name"]
try:
_tool_input = json.loads(function_call["arguments"])
except JSONDecodeError:
if function_name == "python":
code = function_call["arguments"]
_tool_input = {
"code": code,
}
else:
raise OutputParserException(
f"Could not parse tool input: {function_call} because "
f"the `arguments` is not valid JSON."
)
# HACK HACK HACK:
# The code that encodes tool input into Open AI uses a special variable
# name called `__arg1` to handle old style tools that do not expose a
# schema and expect a single string argument as an input.
# We unpack the argument here if it exists.
# Open AI does not support passing in a JSON array as an argument.
if "__arg1" in _tool_input:
tool_input = _tool_input["__arg1"]
else:
tool_input = _tool_input
content_msg = "responded: {content}\n" if message.content else "\n"
return _FunctionsAgentAction(
tool=function_name,
tool_input=tool_input,
log=f"\nInvoking: `{function_name}` with `{tool_input}`\n{content_msg}\n",
message_log=[message],
)
return AgentFinish(return_values={"output": message.content}, log=message.content)
class OpenAIFunctionsAgent(BaseSingleActionAgent):
"""An Agent driven by OpenAIs function powered API.
Args:
llm: This should be an instance of ChatOpenAI, specifically a model
that supports using `functions`.
tools: The tools this agent has access to.
prompt: The prompt for this agent, should support agent_scratchpad as one
of the variables. For an easy way to construct this prompt, use
`OpenAIFunctionsAgent.create_prompt(...)`
"""
llm: BaseLanguageModel
tools: Sequence[BaseTool]
prompt: BasePromptTemplate
def get_allowed_tools(self) -> List[str]:
"""Get allowed tools."""
return list([t.name for t in self.tools])
@root_validator
def validate_llm(cls, values: dict) -> dict:
if not isinstance(values["llm"], ChatOpenAI):
raise ValueError("Only supported with ChatOpenAI models.")
return values
@root_validator
def validate_prompt(cls, values: dict) -> dict:
prompt: BasePromptTemplate = values["prompt"]
if "agent_scratchpad" not in prompt.input_variables:
raise ValueError(
"`agent_scratchpad` should be one of the variables in the prompt, "
f"got {prompt.input_variables}"
)
return values
@property
def input_keys(self) -> List[str]:
"""Get input keys. Input refers to user input here."""
return ["input"]
@property
def functions(self) -> List[dict]:
return [dict(format_tool_to_openai_function(t)) for t in self.tools]
def plan(
self,
intermediate_steps: List[Tuple[AgentAction, str]],
callbacks: Callbacks = None,
with_functions: bool = True,
**kwargs: Any,
) -> Union[AgentAction, AgentFinish]:
"""Given input, decided what to do.
Args:
intermediate_steps: Steps the LLM has taken to date, along with observations
**kwargs: User inputs.
Returns:
Action specifying what tool to use.
"""
agent_scratchpad = _format_intermediate_steps(intermediate_steps)
selected_inputs = {
k: kwargs[k] for k in self.prompt.input_variables if k != "agent_scratchpad"
}
full_inputs = dict(**selected_inputs, agent_scratchpad=agent_scratchpad)
prompt = self.prompt.format_prompt(**full_inputs)
messages = prompt.to_messages()
if with_functions:
predicted_message = self.llm.predict_messages(
messages,
functions=self.functions,
callbacks=callbacks,
)
else:
predicted_message = self.llm.predict_messages(
messages,
callbacks=callbacks,
)
agent_decision = _parse_ai_message(predicted_message)
return agent_decision
async def aplan(
self,
intermediate_steps: List[Tuple[AgentAction, str]],
callbacks: Callbacks = None,
**kwargs: Any,
) -> Union[AgentAction, AgentFinish]:
"""Given input, decided what to do.
Args:
intermediate_steps: Steps the LLM has taken to date,
along with observations
**kwargs: User inputs.
Returns:
Action specifying what tool to use.
"""
agent_scratchpad = _format_intermediate_steps(intermediate_steps)
selected_inputs = {
k: kwargs[k] for k in self.prompt.input_variables if k != "agent_scratchpad"
}
full_inputs = dict(**selected_inputs, agent_scratchpad=agent_scratchpad)
prompt = self.prompt.format_prompt(**full_inputs)
messages = prompt.to_messages()
predicted_message = await self.llm.apredict_messages(
messages, functions=self.functions, callbacks=callbacks
)
agent_decision = _parse_ai_message(predicted_message)
return agent_decision
def return_stopped_response(
self,
early_stopping_method: str,
intermediate_steps: List[Tuple[AgentAction, str]],
**kwargs: Any,
) -> AgentFinish:
"""Return response when agent has been stopped due to max iterations."""
if early_stopping_method == "force":
# `force` just returns a constant string
return AgentFinish(
{"output": "Agent stopped due to iteration limit or time limit."}, ""
)
elif early_stopping_method == "generate":
# Generate does one final forward pass
agent_decision = self.plan(
intermediate_steps, with_functions=False, **kwargs
)
if type(agent_decision) == AgentFinish: # noqa: E721
return agent_decision
else:
raise ValueError(
f"got AgentAction with no functions provided: {agent_decision}"
)
else:
raise ValueError(
"early_stopping_method should be one of `force` or `generate`, "
f"got {early_stopping_method}"
)
@classmethod
def create_prompt(
cls,
system_message: Optional[SystemMessage] = SystemMessage(
content="You are a helpful AI assistant."
),
extra_prompt_messages: Optional[List[BaseMessagePromptTemplate]] = None,
) -> BasePromptTemplate:
"""Create prompt for this agent.
Args:
system_message: Message to use as the system message that will be the
first in the prompt.
extra_prompt_messages: Prompt messages that will be placed between the
system message and the new human input.
Returns:
A prompt template to pass into this agent.
"""
_prompts = extra_prompt_messages or []
messages: List[Union[BaseMessagePromptTemplate, BaseMessage]]
if system_message:
messages = [system_message]
else:
messages = []
messages.extend(
[
*_prompts,
HumanMessagePromptTemplate.from_template("{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad"),
]
)
return ChatPromptTemplate(messages=messages) # type: ignore
@classmethod
def from_llm_and_tools(
cls,
llm: BaseLanguageModel,
tools: Sequence[BaseTool],
callback_manager: Optional[BaseCallbackManager] = None,
extra_prompt_messages: Optional[List[BaseMessagePromptTemplate]] = None,
system_message: Optional[SystemMessage] = SystemMessage(
content="You are a helpful AI assistant."
),
**kwargs: Any,
) -> BaseSingleActionAgent:
"""Construct an agent from an LLM and tools."""
if not isinstance(llm, ChatOpenAI):
raise ValueError("Only supported with ChatOpenAI models.")
prompt = cls.create_prompt(
extra_prompt_messages=extra_prompt_messages,
system_message=system_message,
)
return cls( # type: ignore
llm=llm,
prompt=prompt,
tools=tools,
callback_manager=callback_manager, # type: ignore
**kwargs,
)
| [
"You are a helpful AI assistant.",
"{input}"
] |
2024-01-10 | djordjethai/Embeddings | Priprema.py | import streamlit as st
st.set_page_config(page_title="Embeddings", page_icon="📔", layout="wide")
import pinecone
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import UnstructuredFileLoader, UnstructuredPDFLoader
import os
from myfunc.mojafunkcija import (
st_style,
pinecone_stats,
positive_login,
show_logo,
)
from time import sleep
from tqdm.auto import tqdm
from uuid import uuid4
import openai
import json
import datetime
import Pinecone_Utility
import Scrapper
import PyPDF2
import io
import re
from io import StringIO
version = "05.11.23. (Streamlit, Pinecone, LangChain)"
st_style()
client=(openai.OpenAI(api_key=os.environ.get("OPENAI_API_KEY")))
def def_chunk():
with st.sidebar:
chunk_size = st.slider(
"Zadati veličinu chunk-ova (200 - 8000).",
200,
8000,
1500,
step=100,
help="Veličina chunka određuje veličinu indeksiranog dokumenta. Veći chunk obezbeđuje bolji kontekst, dok manji chunk omogućava precizniji odgovor.",
)
chunk_overlap = st.slider(
"Zadati preklapanje chunk-ova (0 - 1000); vrednost mora biti manja od veličine chunk-ova.",
0,
1000,
0,
step=10,
help="Određuje veličinu preklapanja uzastopnih sardžaja dokumenta. U opštem slučaju, veće preklapanje će obezbediti bolji prenos konteksta.",
)
return chunk_size, chunk_overlap
def main():
show_logo()
chunk_size, chunk_overlap = def_chunk()
st.markdown(
f"<p style='font-size: 10px; color: grey;'>{version}</p>",
unsafe_allow_html=True,
)
st.subheader("Izaberite operaciju za Embeding")
with st.expander("Pročitajte uputstvo:"):
st.caption(
"""
Prethodni korak bio je kreiranje pitanja. To smo radili pomoću besplatnog ChatGPT modela. Iz svake oblasti (ili iz dokumenta)
zamolimo ChatGPT da kreira relevantna pitanja. Na pitanja mozemo da odgovorimo sami ili se odgovori mogu izvuci iz dokumenta.\n
Ukoliko zelite da vam model kreira odgovore, odaberite ulazni fajl sa pitanjma iz prethodnog koraka.
Opciono, ako je za odgovore potreban izvor, odaberite i fajl sa izvorom. Unesite sistemsku poruku (opis ponašanja modela)
i naziv FT modela. Kliknite na Submit i sačekajte da se obrada završi.
Fajl sa odgovorima ćete kasnije korisiti za kreiranje FT modela.\n
Pre prelaska na sledeću fazu OBAVEZNO pregledajte izlazni dokument sa odgovorima i korigujte ga po potrebi.
"""
)
if "podeli_button" not in st.session_state:
st.session_state["podeli_button"] = False
if "manage_button" not in st.session_state:
st.session_state["manage_button"] = False
if "kreiraj_button" not in st.session_state:
st.session_state["kreiraj_button"] = False
if "stats_button" not in st.session_state:
st.session_state["stats_button"] = False
if "screp_button" not in st.session_state:
st.session_state["screp_button"] = False
if "submit_b" not in st.session_state:
st.session_state["submit_b"] = False
if "submit_b2" not in st.session_state:
st.session_state["submit_b2"] = False
if "nesto" not in st.session_state:
st.session_state["nesto"] = 0
col1, col2, col3, col4, col5 = st.columns(5)
with col1:
with st.form(key="podeli", clear_on_submit=False):
st.session_state.podeli_button = st.form_submit_button(
label="Pripremi Dokument",
use_container_width=True,
help="Podela dokumenta na delove za indeksiranje",
)
if st.session_state.podeli_button:
st.session_state.nesto = 1
with col3:
with st.form(key="kreiraj", clear_on_submit=False):
st.session_state.kreiraj_button = st.form_submit_button(
label="Kreiraj Embeding",
use_container_width=True,
help="Kreiranje Pinecone Indeksa",
)
if st.session_state.kreiraj_button:
st.session_state.nesto = 2
with col4:
with st.form(key="manage", clear_on_submit=False):
st.session_state.manage_button = st.form_submit_button(
label="Upravljaj sa Pinecone",
use_container_width=True,
help="Manipulacije sa Pinecone Indeksom",
)
if st.session_state.manage_button:
st.session_state.nesto = 3
with col5:
with st.form(key="stats", clear_on_submit=False):
index = pinecone.Index("embedings1")
st.session_state.stats_button = st.form_submit_button(
label="Pokaži Statistiku",
use_container_width=True,
help="Statistika Pinecone Indeksa",
)
if st.session_state.stats_button:
st.session_state.nesto = 4
with col2:
with st.form(key="screp", clear_on_submit=False):
st.session_state.screp_button = st.form_submit_button(
label="Pripremi Websajt", use_container_width=True, help="Scrape URL"
)
if st.session_state.screp_button:
st.session_state.nesto = 5
st.divider()
phmain = st.empty()
if st.session_state.nesto == 1:
with phmain.container():
prepare_embeddings(chunk_size, chunk_overlap)
elif st.session_state.nesto == 2:
with phmain.container():
do_embeddings()
elif st.session_state.nesto == 3:
with phmain.container():
Pinecone_Utility.main()
elif st.session_state.nesto == 4:
with phmain.container():
index = pinecone.Index("embedings1")
api_key = os.getenv("PINECONE_API_KEY")
env = os.getenv("PINECONE_API_ENV")
openai_api_key = os.environ.get("OPENAI_API_KEY")
index_name = "embedings1"
pinecone.init(api_key=api_key, environment=env)
index = pinecone.Index(index_name)
pinecone_stats(index, index_name)
elif st.session_state.nesto == 5:
with phmain.container():
Scrapper.main(chunk_size, chunk_overlap)
def prepare_embeddings(chunk_size, chunk_overlap):
skinuto = False
napisano = False
file_name = "chunks.json"
with st.form(key="my_form_prepare", clear_on_submit=False):
st.subheader("Učitajte dokumenta i metadata za Pinecone Indeks")
dokum = st.file_uploader(
"Izaberite dokument/e", key="upload_file", type=["txt", "pdf", "docx"]
)
# prefix moze da se definise i dinamicki
text_prefix = st.text_input(
"Unesite prefiks za tekst: ",
help="Prefiks se dodaje na početak teksta pre podela na delove za indeksiranje",
)
add_schema = st.radio(
"Da li želite da dodate Schema Data (može značajno produžiti vreme potrebno za kreiranje): ",
("Da", "Ne"),
key="add_schema_doc",
help="Schema Data se dodaje na početak teksta",
)
st.session_state.submit_b = st.form_submit_button(
label="Submit",
help="Pokreće podelu dokumenta na delove za indeksiranje",
)
st.info(f"Chunk veličina: {chunk_size}, chunk preklapanje: {chunk_overlap}")
if len(text_prefix) > 0:
text_prefix = text_prefix + " "
if dokum is not None and st.session_state.submit_b == True:
with io.open(dokum.name, "wb") as file:
file.write(dokum.getbuffer())
if ".pdf" in dokum.name:
pdf_reader = PyPDF2.PdfReader(dokum)
num_pages = len(pdf_reader.pages)
text_content = ""
for page in range(num_pages):
page_obj = pdf_reader.pages[page]
text_content += page_obj.extract_text()
text_content = text_content.replace("•", "")
text_content = re.sub(r"(?<=\b\w) (?=\w\b)", "", text_content)
with io.open("temp.txt", "w", encoding="utf-8") as f:
f.write(text_content)
loader = UnstructuredFileLoader("temp.txt", encoding="utf-8")
else:
# Creating a file loader object
loader = UnstructuredFileLoader(dokum.name, encoding="utf-8")
data = loader.load()
# Split the document into smaller parts
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=chunk_size, chunk_overlap=chunk_overlap
)
texts = text_splitter.split_documents(data)
#
###############
#
# dodati mogucnost za prefix i sufix na embeddinge
#
###############
# # Ask the user if they want to do OpenAI embeddings
# # Create the OpenAI embeddings
st.write(f"Učitano {len(texts)} tekstova")
# Define a custom method to convert Document to a JSON-serializable format
output_json_list = []
# Loop through the Document objects and convert them to JSON
i = 0
for document in texts:
i += 1
try:
if add_schema == "Da":
document.page_content = Scrapper.add_schema_data(
document.page_content
)
with st.expander(
f"Obrađeni tekst: {i} od {len(texts)} ", expanded=False
):
st.write(document.page_content)
except Exception as e:
st.error(f"Schema nije na raspolaganju za ovaj chunk. {e}")
output_dict = {
"id": str(uuid4()),
"chunk": i,
"text": text_prefix + document.page_content,
"source": document.metadata.get("source", ""),
"date": datetime.datetime.now().strftime("%d.%m.%Y")
}
output_json_list.append(output_dict)
# # Specify the file name where you want to save the JSON data
json_string = (
"["
+ ",\n".join(
json.dumps(d, ensure_ascii=False) for d in output_json_list
)
+ "]"
)
# Now, json_string contains the JSON data as a string
napisano = st.info(
"Tekstovi su sačuvani u JSON obliku, downloadujte ih na svoj računar"
)
if napisano:
file_name = os.path.splitext(dokum.name)[0]
skinuto = st.download_button(
"Download JSON",
data=json_string,
file_name=f"{file_name}.json",
mime="application/json",
)
if skinuto:
st.success(f"Tekstovi sačuvani na {file_name} su sada spremni za Embeding")
def do_embeddings():
with st.form(key="my_form_do", clear_on_submit=False):
err_log = ""
# Read the texts from the .txt file
chunks = []
dokum = st.file_uploader(
"Izaberite dokument/e",
key="upload_json_file",
type=[".json"],
help="Izaberite dokument koji ste podelili na delove za indeksiranje",
)
# Now, you can use stored_texts as your texts
# with st.form(key="my_form2", clear_on_submit=False):
namespace = st.text_input(
"Unesi naziv namespace-a: ",
help="Naziv namespace-a je obavezan za kreiranje Pinecone Indeksa",
)
submit_b2 = st.form_submit_button(
label="Submit", help="Pokreće kreiranje Pinecone Indeksa"
)
if submit_b2 and dokum and namespace:
stringio = StringIO(dokum.getvalue().decode("utf-8"))
# To read file as string:
file = stringio.read()
json_string = json.dumps(json.loads(file), ensure_ascii=False)
data = json.loads(json_string)
with st.expander("Prikaži tekstove", expanded=False):
st.write(data)
# file = dokum.getbuffer()
# for line in data:
# # Remove leading/trailing whitespace and add to the list
# chunks.append(line)
# Initialize OpenAI and Pinecone API key
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
PINECONE_API_KEY = os.environ.get("PINECONE_API_KEY")
PINECONE_API_ENV = os.environ.get("PINECONE_API_ENV")
# initializing openai and pinecone
embeddings = OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY)
pinecone.init(api_key=PINECONE_API_KEY, environment=PINECONE_API_ENV)
index_name = "embedings1"
# # embedding start !!!
# Set the embedding model name
embed_model = "text-embedding-ada-002"
# Initialize the Pinecone index
index = pinecone.Index(index_name)
batch_size = 100 # how many embeddings we create and insert at once
progress_text2 = "Insertovanje u Pinecone je u toku."
progress_bar2 = st.progress(0.0, text=progress_text2)
# Now, 'data' contains the contents of the JSON file as a Python data structure (usually a dictionary or a list, depending on the JSON structure)
# You can access the data and work with it as needed
# For example, if 'data' is a list of dictionaries, you can iterate through it like this:
ph2 = st.empty()
for i in tqdm(range(0, len(data), batch_size)):
# find end of batch
i_end = min(len(data), i + batch_size)
meta_batch = data[i:i_end]
# get texts to encode
ids_batch = [x["id"] for x in meta_batch]
texts = [x["text"] for x in meta_batch]
# create embeddings (try-except added to avoid RateLimitError)
try:
res = client.embeddings.create(input=texts, model=embed_model)
except Exception as e:
done = False
print(e)
while not done:
sleep(5)
try:
res = client.embeddings.create(input=texts, model=embed_model)
done = True
except:
pass
cleaned_meta_batch = [] # To store records without [nan] embeddings
embeds = [item.embedding for item in res.data]
# Check for [nan] embeddings
if len(embeds) > 0:
to_upsert = list(zip(ids_batch, embeds, meta_batch))
else:
err_log += f"Greška: {meta_batch}\n"
# upsert to Pinecone
err_log += f"Upserting {len(to_upsert)} embeddings\n"
with open("err_log.txt", "w", encoding="utf-8") as file:
file.write(err_log)
print("upsert")
index.upsert(vectors=to_upsert, namespace=namespace)
stodva = len(data)
if i_end > i:
deo = i_end
else:
deo = i
progress = deo / stodva
l = int(deo / stodva * 100)
ph2.text(f"Učitano je {deo} od {stodva} linkova što je {l} %")
progress_bar2.progress(progress, text=progress_text2)
# gives stats about index
st.info("Napunjen Pinecone")
index = pinecone.Index(index_name)
st.success(f"Sačuvano u Pinecone-u")
pinecone_stats(index, index_name)
# Koristi se samo za deploy na streamlit.io
deployment_environment = os.environ.get("DEPLOYMENT_ENVIRONMENT")
if deployment_environment == "Streamlit":
name, authentication_status, username = positive_login(main, " ")
else:
if __name__ == "__main__":
main()
| [] |
2024-01-10 | djordjethai/Embeddings | PripremaHybrid.py | import streamlit as st
st.set_page_config(page_title="Embeddings", page_icon="📔", layout="wide")
import pinecone
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain.document_loaders import UnstructuredFileLoader
import os
from myfunc.mojafunkcija import (
st_style,
positive_login,
show_logo,
pinecone_stats,
def_chunk,
)
import Pinecone_Utility
import ScrapperH
import PyPDF2
import io
import re
from langchain.retrievers import PineconeHybridSearchRetriever
from pinecone_text.sparse import BM25Encoder
import datetime
import json
from uuid import uuid4
from io import StringIO
version = "14.11.23. Hybrid"
st_style()
def main():
show_logo()
chunk_size, chunk_overlap = def_chunk()
#chunk_size = 50
st.markdown(
f"<p style='font-size: 10px; color: grey;'>{version}</p>",
unsafe_allow_html=True,
)
st.subheader("Izaberite operaciju za Embeding HYBRID Method")
with st.expander("Pročitajte uputstvo:"):
st.caption(
"""
Prethodni korak bio je kreiranje pitanja. To smo radili pomoću besplatnog ChatGPT modela. Iz svake oblasti (ili iz dokumenta)
zamolimo ChatGPT da kreira relevantna pitanja. Na pitanja mozemo da odgovorimo sami ili se odgovori mogu izvuci iz dokumenta.\n
Ukoliko zelite da vam model kreira odgovore, odaberite ulazni fajl sa pitanjma iz prethodnog koraka.
Opciono, ako je za odgovore potreban izvor, odaberite i fajl sa izvorom. Unesite sistemsku poruku (opis ponašanja modela)
i naziv FT modela. Kliknite na Submit i sačekajte da se obrada završi.
Fajl sa odgovorima ćete kasnije korisiti za kreiranje FT modela.\n
Pre prelaska na sledeću fazu OBAVEZNO pregledajte izlazni dokument sa odgovorima i korigujte ga po potrebi.
"""
)
if "podeli_button" not in st.session_state:
st.session_state["podeli_button"] = False
if "manage_button" not in st.session_state:
st.session_state["manage_button"] = False
if "kreiraj_button" not in st.session_state:
st.session_state["kreiraj_button"] = False
if "stats_button" not in st.session_state:
st.session_state["stats_button"] = False
if "screp_button" not in st.session_state:
st.session_state["screp_button"] = False
if "submit_b" not in st.session_state:
st.session_state["submit_b"] = False
if "submit_b2" not in st.session_state:
st.session_state["submit_b2"] = False
if "nesto" not in st.session_state:
st.session_state["nesto"] = 0
col1, col2, col3, col4, col5 = st.columns(5)
with col1:
with st.form(key="podeli", clear_on_submit=False):
st.session_state.podeli_button = st.form_submit_button(
label="Pripremi Dokument",
use_container_width=True,
help="Podela dokumenta na delove za indeksiranje",
)
if st.session_state.podeli_button:
st.session_state.nesto = 1
with col3:
with st.form(key="kreiraj", clear_on_submit=False):
st.session_state.kreiraj_button = st.form_submit_button(
label="Kreiraj Embeding",
use_container_width=True,
help="Kreiranje Pinecone Indeksa",
)
if st.session_state.kreiraj_button:
st.session_state.nesto = 2
with col4:
# st.write("Nije dostupno za Hybrid Embeding ")
with st.form(key="manage", clear_on_submit=False):
st.session_state.manage_button = st.form_submit_button(
label="Upravljaj sa Pinecone",
use_container_width=True,
help="Manipulacije sa Pinecone Indeksom",
)
if st.session_state.manage_button:
st.session_state.nesto = 3
with col5:
with st.form(key="stats", clear_on_submit=False):
index = pinecone.Index("embedings1")
st.session_state.stats_button = st.form_submit_button(
label="Pokaži Statistiku",
use_container_width=True,
help="Statistika Pinecone Indeksa",
)
if st.session_state.stats_button:
st.session_state.nesto = 4
with col2:
# st.write("Nije dostupno za Hybrid Embeding ")
with st.form(key="screp", clear_on_submit=False):
st.session_state.screp_button = st.form_submit_button(
label="Pripremi Websajt", use_container_width=True, help="Scrape URL"
)
if st.session_state.screp_button:
st.session_state.nesto = 5
st.divider()
phmain = st.empty()
if st.session_state.nesto == 1:
with phmain.container():
prepare_embeddings(chunk_size, chunk_overlap)
elif st.session_state.nesto == 2:
with phmain.container():
do_embeddings()
elif st.session_state.nesto == 3:
with phmain.container():
Pinecone_Utility.main()
elif st.session_state.nesto == 4:
with phmain.container():
index = pinecone.Index("positive")
api_key = os.getenv("PINECONE_API_KEY_POS")
env = os.getenv("PINECONE_ENVIRONMENT_POS")
openai_api_key = os.environ.get("OPENAI_API_KEY")
index_name = "positive"
pinecone.init(api_key=api_key, environment=env)
index = pinecone.Index(index_name)
pinecone_stats(index, index_name)
elif st.session_state.nesto == 5:
with phmain.container():
ScrapperH.main(chunk_size, chunk_overlap)
def prepare_embeddings(chunk_size, chunk_overlap):
skinuto = False
napisano = False
file_name = "chunks.json"
with st.form(key="my_form_prepare", clear_on_submit=False):
st.subheader("Učitajte dokumenta i metadata za Pinecone Indeks")
dokum = st.file_uploader(
"Izaberite dokument/e", key="upload_file", type=["txt", "pdf", "docx"]
)
# define delimiter
text_delimiter = st.text_input(
"Unesite delimiter: ",
help="Delimiter se koristi za podelu dokumenta na delove za indeksiranje. Prazno za paragraf",
)
# define prefix
text_prefix = st.text_input(
"Unesite prefiks za tekst: ",
help="Prefiks se dodaje na početak teksta pre podela na delove za indeksiranje",
)
add_schema = st.radio(
"Da li želite da dodate Schema Data (može značajno produžiti vreme potrebno za kreiranje): ",
("Da", "Ne"),
key="add_schema_doc",
help="Schema Data se dodaje na početak teksta",
)
st.session_state.submit_b = st.form_submit_button(
label="Submit",
help="Pokreće podelu dokumenta na delove za indeksiranje",
)
st.info(f"Chunk veličina: {chunk_size}, chunk preklapanje: {chunk_overlap}")
if len(text_prefix) > 0:
text_prefix = text_prefix + " "
if dokum is not None and st.session_state.submit_b == True:
with io.open(dokum.name, "wb") as file:
file.write(dokum.getbuffer())
if text_delimiter == "":
text_delimiter = "\n\n"
if ".pdf" in dokum.name:
pdf_reader = PyPDF2.PdfReader(dokum)
num_pages = len(pdf_reader.pages)
text_content = ""
for page in range(num_pages):
page_obj = pdf_reader.pages[page]
text_content += page_obj.extract_text()
text_content = text_content.replace("•", "")
text_content = re.sub(r"(?<=\b\w) (?=\w\b)", "", text_content)
with io.open("temp.txt", "w", encoding="utf-8") as f:
f.write(text_content)
loader = UnstructuredFileLoader("temp.txt", encoding="utf-8")
else:
# Creating a file loader object
loader = UnstructuredFileLoader(dokum.name, encoding="utf-8")
data = loader.load()
# Split the document into smaller parts, the separator should be the word "Chapter"
text_splitter = CharacterTextSplitter(
separator=text_delimiter,
chunk_size=chunk_size,
chunk_overlap=chunk_overlap,
)
texts = text_splitter.split_documents(data)
# # Create the OpenAI embeddings
st.write(f"Učitano {len(texts)} tekstova")
# Define a custom method to convert Document to a JSON-serializable format
output_json_list = []
# Loop through the Document objects and convert them to JSON
i = 0
for document in texts:
i += 1
try:
if add_schema == "Da":
document.page_content = ScrapperH.add_schema_data(
document.page_content
)
with st.expander(
f"Obrađeni tekst: {i} od {len(texts)} ", expanded=False
):
st.write(document.page_content)
except Exception as e:
st.error("Schema nije na raspolaganju za ovaj chunk. {e}")
# # Specify the file name where you want to save the data
output_dict = {
"id": str(uuid4()),
"chunk": i,
"text": text_prefix + document.page_content,
"source": document.metadata.get("source", ""),
"date": datetime.datetime.now().strftime("%d.%m.%Y")
}
output_json_list.append(output_dict)
# # Specify the file name where you want to save the JSON data
json_string = (
"["
+ ",\n".join(
json.dumps(d, ensure_ascii=False) for d in output_json_list
)
+ "]"
)
# Now, json_string contains the JSON data as a string
napisano = st.info(
"Tekstovi su sačuvani u JSON obliku, downloadujte ih na svoj računar"
)
if napisano:
file_name = os.path.splitext(dokum.name)[0]
skinuto = st.download_button(
"Download JSON",
data=json_string,
file_name=f"{file_name}.json",
mime="application/json",
)
if skinuto:
st.success(f"Tekstovi sačuvani na {file_name} su sada spremni za Embeding")
def do_embeddings():
with st.form(key="my_form_do", clear_on_submit=False):
err_log = ""
# Read the texts from the .txt file
chunks = []
dokum = st.file_uploader(
"Izaberite dokument/e",
key="upload_json_file",
type=[".json"],
help="Izaberite dokument koji ste podelili na delove za indeksiranje",
)
# Now, you can use stored_texts as your texts
# with st.form(key="my_form2", clear_on_submit=False):
namespace = st.text_input(
"Unesi naziv namespace-a: ",
help="Naziv namespace-a je obavezan za kreiranje Pinecone Indeksa",
)
submit_b2 = st.form_submit_button(
label="Submit", help="Pokreće kreiranje Pinecone Indeksa"
)
if submit_b2 and dokum and namespace:
stringio = StringIO(dokum.getvalue().decode("utf-8"))
# Directly load the JSON data from file content
data = json.load(stringio)
# Initialize lists outside the loop
my_list = []
my_meta = []
# Process each JSON object in the data
for item in data:
# Append the text to my_list
my_list.append(item['text'])
# Append other data to my_meta
meta_data = {key: value for key, value in item.items() if key != 'text'}
my_meta.append(meta_data)
# Initialize OpenAI and Pinecone API key
api_key = os.getenv("PINECONE_API_KEY_POS")
env = os.getenv("PINECONE_ENVIRONMENT_POS")
openai_api_key = os.environ.get("OPENAI_API_KEY")
index_name = "positive"
pinecone.init(api_key=api_key, environment=env)
index = pinecone.Index(index_name)
embeddings = OpenAIEmbeddings()
# upsert data
bm25_encoder = BM25Encoder()
# fit tf-idf values on your corpus
bm25_encoder.fit(my_list)
retriever = PineconeHybridSearchRetriever(
embeddings=embeddings,
sparse_encoder=bm25_encoder,
index=index,
)
retriever.add_texts(texts=my_list, metadatas=my_meta, namespace=namespace)
# gives stats about index
st.info("Napunjen Pinecone")
st.success(f"Sačuvano u Pinecone-u")
pinecone_stats(index, index_name)
# Koristi se samo za deploy na streamlit.io
deployment_environment = os.environ.get("DEPLOYMENT_ENVIRONMENT")
if deployment_environment == "Streamlit":
name, authentication_status, username = positive_login(main, " ")
else:
if __name__ == "__main__":
main()
| [] |
2024-01-10 | djordjethai/Embeddings | PripremaZakon.py | import streamlit as st
st.set_page_config(page_title="Embeddings", page_icon="📔", layout="wide")
import pinecone
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain.document_loaders import UnstructuredFileLoader
import os
from myfunc.mojafunkcija import (
st_style,
pinecone_stats,
positive_login,
show_logo,
)
from time import sleep
from tqdm.auto import tqdm
from uuid import uuid4
import openai
import json
import Pinecone_Utility
import Scrapper
import PyPDF2
import io
import re
from io import StringIO
version = "09.10.23. Zakon"
st_style()
def def_chunk():
with st.sidebar:
chunk_size = st.slider(
"Zadati veličinu chunk-ova (200 - 8000).",
50,
8000,
1500,
step=100,
help="Veličina chunka određuje veličinu indeksiranog dokumenta. Veći chunk obezbeđuje bolji kontekst, dok manji chunk omogućava precizniji odgovor.",
)
chunk_overlap = st.slider(
"Zadati preklapanje chunk-ova (0 - 1000); vrednost mora biti manja od veličine chunk-ova.",
0,
1000,
0,
step=10,
help="Određuje veličinu preklapanja uzastopnih sardžaja dokumenta. U opštem slučaju, veće preklapanje će obezbediti bolji prenos konteksta.",
)
return chunk_size, chunk_overlap
def main():
show_logo()
chunk_size, chunk_overlap = def_chunk()
st.markdown(
f"<p style='font-size: 10px; color: grey;'>{version}</p>",
unsafe_allow_html=True,
)
st.subheader("Izaberite operaciju za Embeding")
with st.expander("Pročitajte uputstvo:"):
st.caption(
"""
Prethodni korak bio je kreiranje pitanja. To smo radili pomoću besplatnog ChatGPT modela. Iz svake oblasti (ili iz dokumenta)
zamolimo ChatGPT da kreira relevantna pitanja. Na pitanja mozemo da odgovorimo sami ili se odgovori mogu izvuci iz dokumenta.\n
Ukoliko zelite da vam model kreira odgovore, odaberite ulazni fajl sa pitanjma iz prethodnog koraka.
Opciono, ako je za odgovore potreban izvor, odaberite i fajl sa izvorom. Unesite sistemsku poruku (opis ponašanja modela)
i naziv FT modela. Kliknite na Submit i sačekajte da se obrada završi.
Fajl sa odgovorima ćete kasnije korisiti za kreiranje FT modela.\n
Pre prelaska na sledeću fazu OBAVEZNO pregledajte izlazni dokument sa odgovorima i korigujte ga po potrebi.
"""
)
if "podeli_button" not in st.session_state:
st.session_state["podeli_button"] = False
if "manage_button" not in st.session_state:
st.session_state["manage_button"] = False
if "kreiraj_button" not in st.session_state:
st.session_state["kreiraj_button"] = False
if "stats_button" not in st.session_state:
st.session_state["stats_button"] = False
if "screp_button" not in st.session_state:
st.session_state["screp_button"] = False
if "submit_b" not in st.session_state:
st.session_state["submit_b"] = False
if "submit_b2" not in st.session_state:
st.session_state["submit_b2"] = False
if "nesto" not in st.session_state:
st.session_state["nesto"] = 0
col1, col2, col3, col4, col5 = st.columns(5)
with col1:
with st.form(key="podeli", clear_on_submit=False):
st.session_state.podeli_button = st.form_submit_button(
label="Pripremi Dokument",
use_container_width=True,
help="Podela dokumenta na delove za indeksiranje",
)
if st.session_state.podeli_button:
st.session_state.nesto = 1
with col3:
with st.form(key="kreiraj", clear_on_submit=False):
st.session_state.kreiraj_button = st.form_submit_button(
label="Kreiraj Embeding",
use_container_width=True,
help="Kreiranje Pinecone Indeksa",
)
if st.session_state.kreiraj_button:
st.session_state.nesto = 2
with col4:
with st.form(key="manage", clear_on_submit=False):
st.session_state.manage_button = st.form_submit_button(
label="Upravljaj sa Pinecone",
use_container_width=True,
help="Manipulacije sa Pinecone Indeksom",
)
if st.session_state.manage_button:
st.session_state.nesto = 3
with col5:
with st.form(key="stats", clear_on_submit=False):
index = pinecone.Index("embedings1")
st.session_state.stats_button = st.form_submit_button(
label="Pokaži Statistiku",
use_container_width=True,
help="Statistika Pinecone Indeksa",
)
if st.session_state.stats_button:
st.session_state.nesto = 4
with col2:
with st.form(key="screp", clear_on_submit=False):
st.session_state.screp_button = st.form_submit_button(
label="Pripremi Websajt", use_container_width=True, help="Scrape URL"
)
if st.session_state.screp_button:
st.session_state.nesto = 5
st.divider()
phmain = st.empty()
if st.session_state.nesto == 1:
with phmain.container():
prepare_embeddings(chunk_size, chunk_overlap)
elif st.session_state.nesto == 2:
with phmain.container():
do_embeddings()
elif st.session_state.nesto == 3:
with phmain.container():
Pinecone_Utility.main()
elif st.session_state.nesto == 4:
with phmain.container():
index = pinecone.Index("embedings1")
api_key = os.getenv("PINECONE_API_KEY")
env = os.getenv("PINECONE_API_ENV")
openai_api_key = os.environ.get("OPENAI_API_KEY")
index_name = "embedings1"
pinecone.init(api_key=api_key, environment=env)
index = pinecone.Index(index_name)
pinecone_stats(index, index_name)
elif st.session_state.nesto == 5:
with phmain.container():
Scrapper.main(chunk_size, chunk_overlap)
def prepare_embeddings(chunk_size, chunk_overlap):
skinuto = False
napisano = False
file_name = "chunks.json"
with st.form(key="my_form_prepare", clear_on_submit=False):
st.subheader("Učitajte dokumenta i metadata za Pinecone Indeks")
dokum = st.file_uploader(
"Izaberite dokument/e", key="upload_file", type=["txt", "pdf", "docx"]
)
# define delimiter
text_delimiter = st.text_input(
"Unesite delimiter: ",
help="Delimiter se koristi za podelu dokumenta na delove za indeksiranje. Prazno za paragraf",
)
# define prefix
text_prefix = st.text_input(
"Unesite prefiks za tekst: ",
help="Prefiks se dodaje na početak teksta pre podela na delove za indeksiranje",
)
add_schema = st.radio(
"Da li želite da dodate Schema Data (može značajno produžiti vreme potrebno za kreiranje): ",
("Da", "Ne"),
key="add_schema_doc",
help="Schema Data se dodaje na početak teksta",
)
st.session_state.submit_b = st.form_submit_button(
label="Submit",
help="Pokreće podelu dokumenta na delove za indeksiranje",
)
st.info(f"Chunk veličina: {chunk_size}, chunk preklapanje: {chunk_overlap}")
if len(text_prefix) > 0:
text_prefix = text_prefix + " "
if dokum is not None and st.session_state.submit_b == True:
with io.open(dokum.name, "wb") as file:
file.write(dokum.getbuffer())
if text_delimiter == "":
text_delimiter = "\n\n"
if ".pdf" in dokum.name:
pdf_reader = PyPDF2.PdfReader(dokum)
num_pages = len(pdf_reader.pages)
text_content = ""
for page in range(num_pages):
page_obj = pdf_reader.pages[page]
text_content += page_obj.extract_text()
text_content = text_content.replace("•", "")
text_content = re.sub(r"(?<=\b\w) (?=\w\b)", "", text_content)
with io.open("temp.txt", "w", encoding="utf-8") as f:
f.write(text_content)
loader = UnstructuredFileLoader("temp.txt", encoding="utf-8")
else:
# Creating a file loader object
loader = UnstructuredFileLoader(dokum.name, encoding="utf-8")
data = loader.load()
# Split the document into smaller parts, the separator should be the word "Chapter"
text_splitter = CharacterTextSplitter(
separator=text_delimiter,
chunk_size=chunk_size,
chunk_overlap=chunk_overlap,
)
texts = text_splitter.split_documents(data)
#
###############
#
# dodati mogucnost za prefix i sufix na embeddinge
#
###############
# # Ask the user if they want to do OpenAI embeddings
# # Create the OpenAI embeddings
st.write(f"Učitano {len(texts)} tekstova")
# Define a custom method to convert Document to a JSON-serializable format
output_json_list = []
# Loop through the Document objects and convert them to JSON
i = 0
for document in texts:
i += 1
try:
if add_schema == "Da":
document.page_content = Scrapper.add_schema_data(
document.page_content
)
with st.expander(
f"Obrađeni tekst: {i} od {len(texts)} ", expanded=False
):
st.write(document.page_content)
except Exception as e:
st.error("Prefiks nije na raspolaganju za ovaj chunk. {e}")
output_dict = {
"id": str(uuid4()),
"text": text_prefix + document.page_content,
"source": document.metadata.get("source", ""),
}
output_json_list.append(output_dict)
# # Specify the file name where you want to save the JSON data
json_string = (
"["
+ ",\n".join(
json.dumps(d, ensure_ascii=False) for d in output_json_list
)
+ "]"
)
# Now, json_string contains the JSON data as a string
napisano = st.info(
"Tekstovi su sačuvani u JSON obliku, downloadujte ih na svoj računar"
)
if napisano:
skinuto = st.download_button(
"Download JSON",
data=json_string,
file_name=f"{dokum.name}.json",
mime="application/json",
)
if skinuto:
st.success(f"Tekstovi sačuvani na {file_name} su sada spremni za Embeding")
def do_embeddings():
with st.form(key="my_form_do", clear_on_submit=False):
err_log = ""
# Read the texts from the .txt file
chunks = []
dokum = st.file_uploader(
"Izaberite dokument/e",
key="upload_json_file",
type=[".json"],
help="Izaberite dokument koji ste podelili na delove za indeksiranje",
)
# Now, you can use stored_texts as your texts
# with st.form(key="my_form2", clear_on_submit=False):
namespace = st.text_input(
"Unesi naziv namespace-a: ",
help="Naziv namespace-a je obavezan za kreiranje Pinecone Indeksa",
)
submit_b2 = st.form_submit_button(
label="Submit", help="Pokreće kreiranje Pinecone Indeksa"
)
if submit_b2 and dokum and namespace:
stringio = StringIO(dokum.getvalue().decode("utf-8"))
# To read file as string:
file = stringio.read()
json_string = json.dumps(json.loads(file), ensure_ascii=False)
data = json.loads(json_string)
with st.expander("Prikaži tekstove", expanded=False):
st.write(data)
# file = dokum.getbuffer()
for line in data:
# Remove leading/trailing whitespace and add to the list
chunks.append(line)
# Initialize OpenAI and Pinecone API key
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
PINECONE_API_KEY = os.environ.get("PINECONE_API_KEY")
PINECONE_API_ENV = os.environ.get("PINECONE_API_ENV")
# initializing openai and pinecone
embeddings = OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY)
pinecone.init(api_key=PINECONE_API_KEY, environment=PINECONE_API_ENV)
index_name = "embedings1"
# # embedding start !!!
# Set the embedding model name
embed_model = "text-embedding-ada-002"
# Set the index name and namespace
index_name = "embedings1"
# Initialize the Pinecone index
index = pinecone.Index(index_name)
batch_size = 100 # how many embeddings we create and insert at once
progress_text2 = "Insertovanje u Pinecone je u toku."
progress_bar2 = st.progress(0.0, text=progress_text2)
# Now, 'data' contains the contents of the JSON file as a Python data structure (usually a dictionary or a list, depending on the JSON structure)
# You can access the data and work with it as needed
# For example, if 'data' is a list of dictionaries, you can iterate through it like this:
ph2 = st.empty()
for i in tqdm(range(0, len(data), batch_size)):
# find end of batch
i_end = min(len(chunks), i + batch_size)
meta_batch = data[i:i_end]
# get texts to encode
ids_batch = [x["id"] for x in meta_batch]
texts = [x["text"] for x in meta_batch]
# create embeddings (try-except added to avoid RateLimitError)
try:
res = openai.Embedding.create(input=texts, engine=embed_model)
except:
done = False
while not done:
sleep(5)
try:
res = openai.Embedding.create(
input=texts, engine=embed_model
)
done = True
except:
pass
# cleanup metadata
cleaned_meta_batch = [] # To store records without [nan] embeddings
embeds = [record["embedding"] for record in res["data"]]
# Check for [nan] embeddings
if embeds:
to_upsert = list(zip(ids_batch, embeds, meta_batch))
else:
err_log += f"Greška: {meta_batch}\n"
# upsert to Pinecone
err_log += f"Upserting {len(to_upsert)} embeddings\n"
with open("err_log.txt", "w", encoding="utf-8") as file:
file.write(err_log)
index.upsert(vectors=to_upsert, namespace=namespace)
stodva = len(data)
if i_end > i:
deo = i_end
else:
deo = i
progress = deo / stodva
l = int(deo / stodva * 100)
ph2.text(f"Učitano je {deo} od {stodva} linkova što je {l} %")
progress_bar2.progress(progress, text=progress_text2)
# gives stats about index
st.info("Napunjen Pinecone")
index = pinecone.Index(index_name)
st.success(f"Sačuvano u Pinecone-u")
pinecone_stats(index, index_name)
# Koristi se samo za deploy na streamlit.io
deployment_environment = os.environ.get("DEPLOYMENT_ENVIRONMENT")
if deployment_environment == "Streamlit":
name, authentication_status, username = positive_login(main, " ")
else:
if __name__ == "__main__":
main()
| [] |
2024-01-10 | djordjethai/Embeddings | Scrapper.py | # This code scrapes a website, splits the text into chunks, and embeds them using OpenAI and Pinecone.
from tqdm.auto import tqdm
from uuid import uuid4
from langchain.text_splitter import RecursiveCharacterTextSplitter
import os
import re
import html
from urllib.parse import urljoin
from urllib.parse import urlparse
from bs4 import BeautifulSoup
import requests
import openai
import pinecone
from bs4 import BeautifulSoup
import sys
import streamlit as st
from myfunc.mojafunkcija import st_style
import json
from langchain.chat_models import ChatOpenAI
from langchain.chains import create_extraction_chain
import datetime
st_style()
# Define a function to scrape a given URL
def scrape(url: str):
global headers, sajt, err_log, tiktoken_len, vrsta
# Send a GET request to the URL
res = requests.get(url, headers=headers)
# Check the response status code
if res.status_code != 200:
# If the status code is not 200 (OK), write the status code and return None
err_log += f"{res.status_code} for {url}\n"
return None
# If the status code is 200, initialize BeautifulSoup with the response text
soup = BeautifulSoup(res.text, "html.parser")
# soup = BeautifulSoup(res.text, 'lxml')
# Find all links to local pages on the website
local_links = []
for link in soup.find_all("a", href=True):
if (
link["href"].startswith(sajt)
or link["href"].startswith("/")
or link["href"].startswith("./")
):
href = link["href"]
base_url, extension = os.path.splitext(href)
if not extension and not "mailto" in href and not "tel" in href:
local_links.append(urljoin(sajt, href))
# Find the main content using CSS selectors
try:
# main_content_list = soup.select('body main')
main_content_list = soup.select(vrsta)
# Check if 'main_content_list' is not empty
if main_content_list:
main_content = main_content_list[0]
# Extract the plaintext of the main content
main_content_text = main_content.get_text()
# Remove all HTML tags
main_content_text = re.sub(r"<[^>]+>", "", main_content_text)
# Remove extra white space
main_content_text = " ".join(main_content_text.split())
# Replace HTML entities with their corresponding characters
main_content_text = html.unescape(main_content_text)
else:
# Handle the case when 'main_content_list' is empty
main_content_text = "error"
err_log += f"Error in page structure, use body instead\n"
st.error(err_log)
sys.exit()
except Exception as e:
err_log += f"Error while discovering page content\n"
return None
# return as json
return {"url": url, "text": main_content_text}, local_links
# Now you can work with the parsed content using Beautiful Soup
def add_schema_data(line):
openai_api_key = os.getenv("OPENAI_API_KEY")
# Create an instance of ChatOpenAI
llm = ChatOpenAI(temperature=0, model="gpt-4", openai_api_key=openai_api_key)
# mogu da se definisu bilo koji delovi kao JSON schema
schema = {
"properties": {
"title": {"type": "string"},
"keyword": {"type": "string"},
},
"required": ["title", "keyword"],
}
# moze da se ucita bilo koji fajl (ili dokument ili scrapeovan websajt recimo) kao txt ili json
# chunking treba raditi bez overlapa
# moze da se razdvoji title i keyword u jedan index,
# title i text u drugi index, onda imamo i duzi i kraci index
chain = create_extraction_chain(schema, llm)
result = chain.run(line)
for item in result:
title = item["title"]
keyword = item["keyword"]
# ovo treba da postane jedan chunk, na koji se daodaju metadata i onda upsertuje u index
# prakticno umesto prefix-a tj ovo je dinamicki prefix
# if title and keyword and text:
# st.write(f"{title}: keyword: {keyword} -> {text}\n")
added_schema_data = f"Title: {title} <- Keyword: {keyword} -> Text: {line}"
return added_schema_data
# else:
# st.write("No title or keyword or text")
# na kraju se upsertuje u index svaka linija
# opciono moze da se ponovo sacuja u txt ili json fajl
# Define a function to scrape a given URL
def main(chunk_size, chunk_overlap):
skinuto = False
napisano = False
file_name = "chunks.json"
with st.form(key="my_form_scrape", clear_on_submit=False):
global res, err_log, headers, sajt, source, vrsta
st.subheader("Pinecone Scraping")
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"
}
# Set the domain URL
# with st.form(key="my_form", clear_on_submit=False):
sajt = st.text_input("Unesite sajt : ")
# prefix moze da se definise i dinamicki
text_prefix = st.text_input(
"Unesite prefiks za tekst: ",
help="Prefiks se dodaje na početak teksta pre podela na delove za indeksiranje",
)
vrsta = st.radio(
"Unesite vrstu (default je body main): ", ("body main", "body")
)
add_schema = st.radio(
"Da li želite da dodate Schema Data (može značajno produžiti vreme potrebno za kreiranje): ",
("Da", "Ne"),
help="Schema Data se dodaje na početak teksta",
key="add_schema_web",
)
# chunk_size, chunk_overlap = def_chunk()
submit_button = st.form_submit_button(label="Submit")
st.info(f"Chunk veličina: {chunk_size}, chunk preklapanje: {chunk_overlap}")
if len(text_prefix) > 0:
text_prefix = text_prefix + " "
if submit_button and not sajt == "":
res = requests.get(sajt, headers=headers)
err_log = ""
# Read OpenAI API key from file
openai.api_key = os.environ.get("OPENAI_API_KEY")
# # Retrieving API keys from files
# PINECONE_API_KEY = os.environ.get("PINECONE_API_KEY")
# # Setting the environment for Pinecone API
# PINECONE_API_ENV = os.environ.get("PINECONE_API_ENV")
# pinecone.init(api_key=PINECONE_API_KEY, environment=PINECONE_API_ENV)
# Initialize BeautifulSoup with the response text
soup = BeautifulSoup(res.text, "html.parser")
# soup = BeautifulSoup(res.text, 'html5lib')
# Define a function to scrape a given URL
links = [sajt]
scraped = set()
data = []
i = 0
placeholder = st.empty()
with st.spinner(f"Scraping "):
while True:
# while i < 2:
i += 1
if len(links) == 0:
st.success("URL lista je kompletirana")
break
url = links[0]
# st.write(f'{url}, ">>", {i}')
placeholder.text(f"Obrađujem link broj {i}")
try:
res = scrape(url)
err_log += f" OK scraping {url}: {i}\n"
except Exception as e:
err_log += f"An error occurred while scraping {url}: page can not be scraped.\n"
scraped.add(url)
if res is not None:
page_content, local_links = res
data.append(page_content)
# add new links to links list
links.extend(local_links)
# remove duplicates
links = list(set(links))
# remove links already scraped
links = [link for link in links if link not in scraped]
# Initialize RecursiveCharacterTextSplitter
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=chunk_size, chunk_overlap=chunk_overlap
)
chunks = []
progress_text = "Podaci za Embeding se trenutno kreiraju. Molimo sačekajte."
progress_bar = st.progress(0.0, text=progress_text)
ph = st.empty()
progress_barl = st.progress(0.0, text=progress_text)
ph2 = st.empty()
ph3 = st.empty()
# Iterate over data records
with st.spinner(f"Kreiranje podataka za Embeding"):
for idx, record in enumerate(tqdm(data)):
# Split the text into chunks using the text splitter
texts = text_splitter.split_text(record["text"])
sto = len(data)
odsto = idx + 1
procenat = odsto / sto
k = int(odsto / sto * 100)
progress_bar.progress(procenat, text=progress_text)
ph.text(f"Učitano {odsto} od {sto} linkova što je {k} % ")
# Create a list of chunks for each text
# ovde moze da se doda dinamicko dadavanje prefixa
for il in range(len(texts)):
stol = len(texts)
odstol = il + 1
procenatl = odstol / stol
kl = int(odstol / stol * 100)
progress_barl.progress(procenatl, text=progress_text)
ph2.text(f"Učitano {odstol} od {stol} chunkova što je {kl} % ")
try:
if add_schema == "Da":
texts[il] = add_schema_data(texts[il])
with st.expander(
f"Obrađeni tekst, link: {odsto} deo: {odstol}"
):
st.write(texts[il])
except Exception as e:
st.error("Prefiks nije na raspolaganju za ovaj chunk.")
chunks.append(
{
"id": str(uuid4()),
"text": f"{text_prefix} {texts[il]}",
"source": record["url"],
"date": datetime.datetime.now().strftime("%d.%m.%Y")
}
)
# Generate JSON strings for each chunk and join them with newline characters
json_strings = [
json.dumps(chunk, ensure_ascii=False) for chunk in chunks
]
json_string = ",\n".join(json_strings)
# Add "[" at the beginning and "]" at the end of the entire JSON string
json_string = "[" + json_string + "]"
# Assuming 'chunks' is your list of dictionaries
# Now, json_string contains the JSON data as a string
napisano = st.info(
"Tekstovi su sačuvani u JSON obliku, downloadujte ih na svoj računar"
)
# Specify the file name where you want to save the JSON data
parsed_url = urlparse(sajt)
# Get the netloc (which includes the website name)
website_name = parsed_url.netloc
# Remove any potential "www." prefix
if website_name.startswith("www."):
website_name = website_name[4:]
parts = website_name.split(".")
if len(parts) > 1:
website_name = parts[0]
if napisano:
skinuto = st.download_button(
"Download JSON",
data=json_string,
file_name=f"{website_name}.json",
mime="application/json",
)
if skinuto:
st.success(f"Tekstovi sačuvani na {file_name} su sada spremni za Embeding")
# if __name__ == "__main__":
# main()
| [] |
2024-01-10 | djordjethai/Embeddings | Priprema_self.py | import streamlit as st
st.set_page_config(page_title="Embeddings", page_icon="📔", layout="wide")
import pinecone
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain.document_loaders import UnstructuredFileLoader
import os
from myfunc.mojafunkcija import (
st_style,
pinecone_stats,
positive_login,
show_logo,
)
from time import sleep
from tqdm.auto import tqdm
from uuid import uuid4
import openai
import json
import Pinecone_Utility
import Scrapper
import PyPDF2
import io
import re
from io import StringIO
version = "14.10.23. Self Query"
st_style()
def def_chunk():
with st.sidebar:
chunk_size = st.slider(
"Zadati veličinu chunk-ova (200 - 8000).",
200,
8000,
1500,
step=100,
help="Veličina chunka određuje veličinu indeksiranog dokumenta. Veći chunk obezbeđuje bolji kontekst, dok manji chunk omogućava precizniji odgovor.",
)
chunk_overlap = st.slider(
"Zadati preklapanje chunk-ova (0 - 1000); vrednost mora biti manja od veličine chunk-ova.",
0,
1000,
0,
step=10,
help="Određuje veličinu preklapanja uzastopnih sardžaja dokumenta. U opštem slučaju, veće preklapanje će obezbediti bolji prenos konteksta.",
)
return chunk_size, chunk_overlap
def main():
show_logo()
chunk_size, chunk_overlap = def_chunk()
st.markdown(
f"<p style='font-size: 10px; color: grey;'>{version}</p>",
unsafe_allow_html=True,
)
st.subheader("Izaberite operaciju za Embeding")
with st.expander("Pročitajte uputstvo:"):
st.caption(
"""
Prethodni korak bio je kreiranje pitanja. To smo radili pomoću besplatnog ChatGPT modela. Iz svake oblasti (ili iz dokumenta)
zamolimo ChatGPT da kreira relevantna pitanja. Na pitanja mozemo da odgovorimo sami ili se odgovori mogu izvuci iz dokumenta.\n
Ukoliko zelite da vam model kreira odgovore, odaberite ulazni fajl sa pitanjma iz prethodnog koraka.
Opciono, ako je za odgovore potreban izvor, odaberite i fajl sa izvorom. Unesite sistemsku poruku (opis ponašanja modela)
i naziv FT modela. Kliknite na Submit i sačekajte da se obrada završi.
Fajl sa odgovorima ćete kasnije korisiti za kreiranje FT modela.\n
Pre prelaska na sledeću fazu OBAVEZNO pregledajte izlazni dokument sa odgovorima i korigujte ga po potrebi.
"""
)
if "podeli_button" not in st.session_state:
st.session_state["podeli_button"] = False
if "manage_button" not in st.session_state:
st.session_state["manage_button"] = False
if "kreiraj_button" not in st.session_state:
st.session_state["kreiraj_button"] = False
if "stats_button" not in st.session_state:
st.session_state["stats_button"] = False
if "screp_button" not in st.session_state:
st.session_state["screp_button"] = False
if "submit_b" not in st.session_state:
st.session_state["submit_b"] = False
if "submit_b2" not in st.session_state:
st.session_state["submit_b2"] = False
if "nesto" not in st.session_state:
st.session_state["nesto"] = 0
col1, col2, col3, col4, col5 = st.columns(5)
with col1:
with st.form(key="podeli", clear_on_submit=False):
st.session_state.podeli_button = st.form_submit_button(
label="Pripremi Dokument",
use_container_width=True,
help="Podela dokumenta na delove za indeksiranje",
)
if st.session_state.podeli_button:
st.session_state.nesto = 1
with col3:
with st.form(key="kreiraj", clear_on_submit=False):
st.session_state.kreiraj_button = st.form_submit_button(
label="Kreiraj Embeding",
use_container_width=True,
help="Kreiranje Pinecone Indeksa",
)
if st.session_state.kreiraj_button:
st.session_state.nesto = 2
with col4:
with st.form(key="manage", clear_on_submit=False):
st.session_state.manage_button = st.form_submit_button(
label="Upravljaj sa Pinecone",
use_container_width=True,
help="Manipulacije sa Pinecone Indeksom",
)
if st.session_state.manage_button:
st.session_state.nesto = 3
with col5:
with st.form(key="stats", clear_on_submit=False):
index = pinecone.Index("embedings1")
st.session_state.stats_button = st.form_submit_button(
label="Pokaži Statistiku",
use_container_width=True,
help="Statistika Pinecone Indeksa",
)
if st.session_state.stats_button:
st.session_state.nesto = 4
with col2:
with st.form(key="screp", clear_on_submit=False):
st.session_state.screp_button = st.form_submit_button(
label="Pripremi Websajt", use_container_width=True, help="Scrape URL"
)
if st.session_state.screp_button:
st.session_state.nesto = 5
st.divider()
phmain = st.empty()
if st.session_state.nesto == 1:
with phmain.container():
prepare_embeddings(chunk_size, chunk_overlap)
elif st.session_state.nesto == 2:
with phmain.container():
do_embeddings()
elif st.session_state.nesto == 3:
with phmain.container():
Pinecone_Utility.main()
elif st.session_state.nesto == 4:
with phmain.container():
index = pinecone.Index("embedings1")
api_key = os.getenv("PINECONE_API_KEY")
env = os.getenv("PINECONE_API_ENV")
openai_api_key = os.environ.get("OPENAI_API_KEY")
index_name = "embedings1"
pinecone.init(api_key=api_key, environment=env)
index = pinecone.Index(index_name)
pinecone_stats(index, index_name)
elif st.session_state.nesto == 5:
with phmain.container():
Scrapper.main(chunk_size, chunk_overlap)
def prepare_embeddings(chunk_size, chunk_overlap):
skinuto = False
napisano = False
file_name = "chunks.json"
with st.form(key="my_form_prepare", clear_on_submit=False):
st.subheader("Učitajte dokumenta i metadata za Pinecone Indeks")
dokum = st.file_uploader(
"Izaberite dokument/e", key="upload_file", type=["txt", "pdf", "docx"]
)
# define delimiter
text_delimiter = st.text_input(
"Unesite delimiter: ",
help="Delimiter se koristi za podelu dokumenta na delove za indeksiranje. Prazno za paragraf",
)
# define prefix
st.session_state.submit_b = st.form_submit_button(
label="Submit",
help="Pokreće podelu dokumenta na delove za indeksiranje",
)
st.info(f"Chunk veličina: {chunk_size}, chunk preklapanje: {chunk_overlap}")
# if len(text_prefix) > 0:
# text_prefix = text_prefix + " "
if dokum is not None and st.session_state.submit_b == True:
with io.open(dokum.name, "wb") as file:
file.write(dokum.getbuffer())
if text_delimiter == "":
text_delimiter = "\n\n"
if ".pdf" in dokum.name:
pdf_reader = PyPDF2.PdfReader(dokum)
num_pages = len(pdf_reader.pages)
text_content = ""
for page in range(num_pages):
page_obj = pdf_reader.pages[page]
text_content += page_obj.extract_text()
text_content = text_content.replace("•", "")
text_content = re.sub(r"(?<=\b\w) (?=\w\b)", "", text_content)
with io.open("temp.txt", "w", encoding="utf-8") as f:
f.write(text_content)
loader = UnstructuredFileLoader("temp.txt", encoding="utf-8")
else:
# Creating a file loader object
loader = UnstructuredFileLoader(dokum.name, encoding="utf-8")
data = loader.load()
# Split the document into smaller parts, the separator should be the word "Chapter"
text_splitter = CharacterTextSplitter(
separator=text_delimiter,
chunk_size=chunk_size,
chunk_overlap=chunk_overlap,
)
texts = text_splitter.split_documents(data)
# Create the OpenAI embeddings
st.write(f"Učitano {len(texts)} tekstova")
# Define a custom method to convert Document to a JSON-serializable format
output_json_list = []
# Loop through the Document objects and convert them to JSON
for document in texts:
output_dict = {
"id": str(uuid4()),
"text": document.page_content,
"source": document.metadata.get("source", ""),
"title": "some title",
"keyword": "some keyword",
}
output_json_list.append(output_dict)
# # Specify the file name where you want to save the JSON data
json_string = (
"["
+ ",\n".join(
json.dumps(d, ensure_ascii=False) for d in output_json_list
)
+ "]"
)
# Now, json_string contains the JSON data as a string
napisano = st.info(
"Tekstovi su sačuvani u JSON obliku, downloadujte ih na svoj računar"
)
if napisano:
skinuto = st.download_button(
"Download JSON",
data=json_string,
file_name=f"{dokum.name}.json",
mime="application/json",
)
if skinuto:
st.success(f"Tekstovi sačuvani na {file_name} su sada spremni za Embeding")
def do_embeddings():
with st.form(key="my_form_do", clear_on_submit=False):
err_log = ""
# Read the texts from the .txt file
chunks = []
dokum = st.file_uploader(
"Izaberite dokument/e",
key="upload_json_file",
type=[".json"],
help="Izaberite dokument koji ste podelili na delove za indeksiranje",
)
# Now, you can use stored_texts as your texts
# with st.form(key="my_form2", clear_on_submit=False):
namespace = st.text_input(
"Unesi naziv namespace-a: ",
help="Naziv namespace-a je obavezan za kreiranje Pinecone Indeksa",
)
submit_b2 = st.form_submit_button(
label="Submit", help="Pokreće kreiranje Pinecone Indeksa"
)
if submit_b2 and dokum and namespace:
stringio = StringIO(dokum.getvalue().decode("utf-8"))
# To read file as string:
file = stringio.read()
json_string = json.dumps(json.loads(file), ensure_ascii=False)
data = json.loads(json_string)
with st.expander("Prikaži tekstove", expanded=False):
st.write(data)
# file = dokum.getbuffer()
for line in data:
# Remove leading/trailing whitespace and add to the list
chunks.append(line)
# Initialize OpenAI and Pinecone API key
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
PINECONE_API_KEY = os.environ.get("PINECONE_API_KEY")
PINECONE_API_ENV = os.environ.get("PINECONE_API_ENV")
# initializing openai and pinecone
embeddings = OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY)
pinecone.init(api_key=PINECONE_API_KEY, environment=PINECONE_API_ENV)
index_name = "embedings1"
# # embedding start !!!
# Set the embedding model name
embed_model = "text-embedding-ada-002"
# Set the index name and namespace
index_name = "embedings1"
# Initialize the Pinecone index
index = pinecone.Index(index_name)
batch_size = 100 # how many embeddings we create and insert at once
progress_text2 = "Insertovanje u Pinecone je u toku."
progress_bar2 = st.progress(0.0, text=progress_text2)
# Now, 'data' contains the contents of the JSON file as a Python data structure (usually a dictionary or a list, depending on the JSON structure)
# You can access the data and work with it as needed
# For example, if 'data' is a list of dictionaries, you can iterate through it like this:
ph2 = st.empty()
for i in tqdm(range(0, len(data), batch_size)):
# find end of batch
i_end = min(len(chunks), i + batch_size)
meta_batch = data[i:i_end]
# get texts to encode
ids_batch = [x["id"] for x in meta_batch]
texts = [x["text"] for x in meta_batch]
# create embeddings (try-except added to avoid RateLimitError)
try:
res = openai.Embedding.create(input=texts, engine=embed_model)
except:
done = False
while not done:
sleep(5)
try:
res = openai.Embedding.create(
input=texts, engine=embed_model
)
done = True
except:
pass
# cleanup metadata
cleaned_meta_batch = [] # To store records without [nan] embeddings
embeds = [record["embedding"] for record in res["data"]]
# Check for [nan] embeddings
if embeds:
to_upsert = list(zip(ids_batch, embeds, meta_batch))
else:
err_log += f"Greška: {meta_batch}\n"
# upsert to Pinecone
err_log += f"Upserting {len(to_upsert)} embeddings\n"
with open("err_log.txt", "w", encoding="utf-8") as file:
file.write(err_log)
index.upsert(vectors=to_upsert, namespace=namespace)
stodva = len(data)
if i_end > i:
deo = i_end
else:
deo = i
progress = deo / stodva
l = int(deo / stodva * 100)
ph2.text(f"Učitano je {deo} od {stodva} linkova što je {l} %")
progress_bar2.progress(progress, text=progress_text2)
# gives stats about index
st.info("Napunjen Pinecone")
index = pinecone.Index(index_name)
st.success(f"Sačuvano u Pinecone-u")
pinecone_stats(index, index_name)
# Koristi se samo za deploy na streamlit.io
deployment_environment = os.environ.get("DEPLOYMENT_ENVIRONMENT")
if deployment_environment == "Streamlit":
name, authentication_status, username = positive_login(main, " ")
else:
if __name__ == "__main__":
main()
| [] |
2024-01-10 | djordjethai/Embeddings | PripremaHybridSELF.py | import streamlit as st
st.set_page_config(page_title="Embeddings", page_icon="📔", layout="wide")
import pinecone
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain.document_loaders import UnstructuredFileLoader
import os
from myfunc.mojafunkcija import (
st_style,
positive_login,
show_logo,
pinecone_stats,
def_chunk,
)
import random
import Pinecone_Utility
import ScrapperH
import PyPDF2
import io
import re
from langchain.retrievers import PineconeHybridSearchRetriever
from pinecone_text.sparse import BM25Encoder
import datetime
import json
from uuid import uuid4
from io import StringIO
version = "14.11.23. Hybrid"
st_style()
def main():
show_logo()
chunk_size, chunk_overlap = def_chunk()
#chunk_size = 50
st.markdown(
f"<p style='font-size: 10px; color: grey;'>{version}</p>",
unsafe_allow_html=True,
)
st.subheader("Izaberite operaciju za Embeding HYBRID Method")
with st.expander("Pročitajte uputstvo:"):
st.caption(
"""
Prethodni korak bio je kreiranje pitanja. To smo radili pomoću besplatnog ChatGPT modela. Iz svake oblasti (ili iz dokumenta)
zamolimo ChatGPT da kreira relevantna pitanja. Na pitanja mozemo da odgovorimo sami ili se odgovori mogu izvuci iz dokumenta.\n
Ukoliko zelite da vam model kreira odgovore, odaberite ulazni fajl sa pitanjma iz prethodnog koraka.
Opciono, ako je za odgovore potreban izvor, odaberite i fajl sa izvorom. Unesite sistemsku poruku (opis ponašanja modela)
i naziv FT modela. Kliknite na Submit i sačekajte da se obrada završi.
Fajl sa odgovorima ćete kasnije korisiti za kreiranje FT modela.\n
Pre prelaska na sledeću fazu OBAVEZNO pregledajte izlazni dokument sa odgovorima i korigujte ga po potrebi.
"""
)
if "podeli_button" not in st.session_state:
st.session_state["podeli_button"] = False
if "manage_button" not in st.session_state:
st.session_state["manage_button"] = False
if "kreiraj_button" not in st.session_state:
st.session_state["kreiraj_button"] = False
if "stats_button" not in st.session_state:
st.session_state["stats_button"] = False
if "screp_button" not in st.session_state:
st.session_state["screp_button"] = False
if "submit_b" not in st.session_state:
st.session_state["submit_b"] = False
if "submit_b2" not in st.session_state:
st.session_state["submit_b2"] = False
if "nesto" not in st.session_state:
st.session_state["nesto"] = 0
col1, col2, col3, col4, col5 = st.columns(5)
with col1:
with st.form(key="podeli", clear_on_submit=False):
st.session_state.podeli_button = st.form_submit_button(
label="Pripremi Dokument",
use_container_width=True,
help="Podela dokumenta na delove za indeksiranje",
)
if st.session_state.podeli_button:
st.session_state.nesto = 1
with col3:
with st.form(key="kreiraj", clear_on_submit=False):
st.session_state.kreiraj_button = st.form_submit_button(
label="Kreiraj Embeding",
use_container_width=True,
help="Kreiranje Pinecone Indeksa",
)
if st.session_state.kreiraj_button:
st.session_state.nesto = 2
with col4:
# st.write("Nije dostupno za Hybrid Embeding ")
with st.form(key="manage", clear_on_submit=False):
st.session_state.manage_button = st.form_submit_button(
label="Upravljaj sa Pinecone",
use_container_width=True,
help="Manipulacije sa Pinecone Indeksom",
)
if st.session_state.manage_button:
st.session_state.nesto = 3
with col5:
with st.form(key="stats", clear_on_submit=False):
index = pinecone.Index("embedings1")
st.session_state.stats_button = st.form_submit_button(
label="Pokaži Statistiku",
use_container_width=True,
help="Statistika Pinecone Indeksa",
)
if st.session_state.stats_button:
st.session_state.nesto = 4
with col2:
# st.write("Nije dostupno za Hybrid Embeding ")
with st.form(key="screp", clear_on_submit=False):
st.session_state.screp_button = st.form_submit_button(
label="Pripremi Websajt", use_container_width=True, help="Scrape URL"
)
if st.session_state.screp_button:
st.session_state.nesto = 5
st.divider()
phmain = st.empty()
if st.session_state.nesto == 1:
with phmain.container():
prepare_embeddings(chunk_size, chunk_overlap)
elif st.session_state.nesto == 2:
with phmain.container():
do_embeddings()
elif st.session_state.nesto == 3:
with phmain.container():
Pinecone_Utility.main()
elif st.session_state.nesto == 4:
with phmain.container():
index = pinecone.Index("positive")
api_key = os.getenv("PINECONE_API_KEY_POS")
env = os.getenv("PINECONE_ENVIRONMENT_POS")
openai_api_key = os.environ.get("OPENAI_API_KEY")
index_name = "positive"
pinecone.init(api_key=api_key, environment=env)
index = pinecone.Index(index_name)
pinecone_stats(index, index_name)
elif st.session_state.nesto == 5:
with phmain.container():
ScrapperH.main(chunk_size, chunk_overlap)
def prepare_embeddings(chunk_size, chunk_overlap):
skinuto = False
napisano = False
file_name = "chunks.json"
with st.form(key="my_form_prepare", clear_on_submit=False):
st.subheader("Učitajte dokumenta i metadata za Pinecone Indeks")
dokum = st.file_uploader(
"Izaberite dokument/e", key="upload_file", type=["txt", "pdf", "docx"]
)
# define delimiter
text_delimiter = st.text_input(
"Unesite delimiter: ",
help="Delimiter se koristi za podelu dokumenta na delove za indeksiranje. Prazno za paragraf",
)
# define prefix
text_prefix = st.text_input(
"Unesite prefiks za tekst: ",
help="Prefiks se dodaje na početak teksta pre podela na delove za indeksiranje",
)
add_schema = st.radio(
"Da li želite da dodate Schema Data (može značajno produžiti vreme potrebno za kreiranje): ",
("Da", "Ne"),
key="add_schema_doc",
help="Schema Data se dodaje na početak teksta",
)
st.session_state.submit_b = st.form_submit_button(
label="Submit",
help="Pokreće podelu dokumenta na delove za indeksiranje",
)
st.info(f"Chunk veličina: {chunk_size}, chunk preklapanje: {chunk_overlap}")
if len(text_prefix) > 0:
text_prefix = text_prefix + " "
if dokum is not None and st.session_state.submit_b == True:
with io.open(dokum.name, "wb") as file:
file.write(dokum.getbuffer())
if text_delimiter == "":
text_delimiter = "\n\n"
if ".pdf" in dokum.name:
pdf_reader = PyPDF2.PdfReader(dokum)
num_pages = len(pdf_reader.pages)
text_content = ""
for page in range(num_pages):
page_obj = pdf_reader.pages[page]
text_content += page_obj.extract_text()
text_content = text_content.replace("•", "")
text_content = re.sub(r"(?<=\b\w) (?=\w\b)", "", text_content)
with io.open("temp.txt", "w", encoding="utf-8") as f:
f.write(text_content)
loader = UnstructuredFileLoader("temp.txt", encoding="utf-8")
else:
# Creating a file loader object
loader = UnstructuredFileLoader(dokum.name, encoding="utf-8")
data = loader.load()
# Split the document into smaller parts, the separator should be the word "Chapter"
text_splitter = CharacterTextSplitter(
separator=text_delimiter,
chunk_size=chunk_size,
chunk_overlap=chunk_overlap,
)
texts = text_splitter.split_documents(data)
# # Create the OpenAI embeddings
st.write(f"Učitano {len(texts)} tekstova")
# Define a custom method to convert Document to a JSON-serializable format
output_json_list = []
# Loop through the Document objects and convert them to JSON
# Define your lists
names = ["Miljan", "Goran", "Darko", "Nemanja"]
topics = ["RAG indeksi", "AI asistenti", "Epic", "Positive doo"]
i = 0
for document in texts:
i += 1
# Randomly assign a name and a topic
person_name = random.choice(names)
topic = random.choice(topics)
output_dict = {
"id": str(uuid4()),
"chunk": i,
"text": text_prefix + document.page_content,
"source": document.metadata.get("source", ""),
"date": datetime.datetime.now().strftime("%d.%m.%Y"),
"person_name": person_name,
"topic": topic,
}
output_json_list.append(output_dict)
# # Specify the file name where you want to save the JSON data
json_string = (
"["
+ ",\n".join(
json.dumps(d, ensure_ascii=False) for d in output_json_list
)
+ "]"
)
# Now, json_string contains the JSON data as a string
napisano = st.info(
"Tekstovi su sačuvani u JSON obliku, downloadujte ih na svoj računar"
)
if napisano:
file_name = os.path.splitext(dokum.name)[0]
skinuto = st.download_button(
"Download JSON",
data=json_string,
file_name=f"{file_name}.json",
mime="application/json",
)
if skinuto:
st.success(f"Tekstovi sačuvani na {file_name} su sada spremni za Embeding")
def do_embeddings():
with st.form(key="my_form_do", clear_on_submit=False):
err_log = ""
# Read the texts from the .txt file
chunks = []
dokum = st.file_uploader(
"Izaberite dokument/e",
key="upload_json_file",
type=[".json"],
help="Izaberite dokument koji ste podelili na delove za indeksiranje",
)
# Now, you can use stored_texts as your texts
# with st.form(key="my_form2", clear_on_submit=False):
namespace = st.text_input(
"Unesi naziv namespace-a: ",
help="Naziv namespace-a je obavezan za kreiranje Pinecone Indeksa",
)
submit_b2 = st.form_submit_button(
label="Submit", help="Pokreće kreiranje Pinecone Indeksa"
)
if submit_b2 and dokum and namespace:
stringio = StringIO(dokum.getvalue().decode("utf-8"))
# Directly load the JSON data from file content
data = json.load(stringio)
# Initialize lists outside the loop
my_list = []
my_meta = []
# Process each JSON object in the data
for item in data:
# Append the text to my_list
my_list.append(item['text'])
# Append other data to my_meta
meta_data = {key: value for key, value in item.items() if key != 'text'}
my_meta.append(meta_data)
# Initialize OpenAI and Pinecone API key
api_key = os.getenv("PINECONE_API_KEY_POS")
env = os.getenv("PINECONE_ENVIRONMENT_POS")
openai_api_key = os.environ.get("OPENAI_API_KEY")
index_name = "positive"
pinecone.init(api_key=api_key, environment=env)
index = pinecone.Index(index_name)
embeddings = OpenAIEmbeddings()
# upsert data
bm25_encoder = BM25Encoder()
# fit tf-idf values on your corpus
bm25_encoder.fit(my_list)
retriever = PineconeHybridSearchRetriever(
embeddings=embeddings,
sparse_encoder=bm25_encoder,
index=index,
)
retriever.add_texts(texts=my_list, metadatas=my_meta, namespace=namespace)
# gives stats about index
st.info("Napunjen Pinecone")
st.success(f"Sačuvano u Pinecone-u")
pinecone_stats(index, index_name)
# Koristi se samo za deploy na streamlit.io
deployment_environment = os.environ.get("DEPLOYMENT_ENVIRONMENT")
if deployment_environment == "Streamlit":
name, authentication_status, username = positive_login(main, " ")
else:
if __name__ == "__main__":
main()
| [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.