prefix
stringlengths 82
32.6k
| middle
stringlengths 5
470
| suffix
stringlengths 0
81.2k
| file_path
stringlengths 6
168
| repo_name
stringlengths 16
77
| context
listlengths 5
5
| lang
stringclasses 4
values | ground_truth
stringlengths 5
470
|
|---|---|---|---|---|---|---|---|
from rdkit.Chem import Mol, MolFromMolBlock, MolToSmiles
from rdfreader.chem.mol import Molecule
def assert_molecule_from_mol_block(mol: Molecule, mol_block: str):
"""Assert that a molecule object created from a mol block string has the
correct properties."""
assert mol.rd_mol is not None
assert mol.mol_block == mol_block
def test_molecule_from_mol_block(sample_mol_block):
"""Test that the Molecule.from_mol_block method works, creating a Molecule
object from a mol block string and correctly creates class attributes."""
mol = Molecule.from_mol_block(sample_mol_block)
assert_molecule_from_mol_block(mol, sample_mol_block)
def test_molecule_init_from_mol_block(sample_mol_block):
"""Test we can init a molecule object directly by passing a mol block
string."""
mol = Molecule(sample_mol_block)
assert_molecule_from_mol_block(mol, sample_mol_block)
def test_create_empty_molecule():
"""Test that a Molecule object can be created without a mol block
string."""
mol = Molecule()
assert mol. | mol_block is None |
def test_molecule_to_rdkit_mol(sample_molecule, sample_mol_block):
"""Test the Molecule.rd_mol property."""
rd_mol: Mol = sample_molecule.rd_mol
# can't directly compare Mol objects, so we'll just check that it is of
# the right type and is not None
assert rd_mol is not None
assert isinstance(rd_mol, Mol)
def test_molecule_to_smiles(sample_molecule, sample_mol_block):
"""Test the output of the Molecule.smiles property.
Verifies the smiles matches that output by RDKit.
"""
rd_mol: Mol = MolFromMolBlock(sample_mol_block)
rd_smiles: str = MolToSmiles(rd_mol)
assert sample_molecule.smiles == rd_smiles
def test_molecule_metadata(sample_molecule, sample_molecule_metadata):
"""Test the Molecule.metadata property."""
assert sample_molecule.metadata == sample_molecule_metadata
def test_molecule_from_smiles():
"""Test the Molecule.from_smiles method."""
smiles = "OCO"
mol = Molecule.from_smiles(smiles)
assert mol.rd_mol is not None
assert mol.smiles == smiles
| test/test_molecule.py | deepmatterltd-rdfreader-a811645 | [
{
"filename": "test/test_parse_rxn_block.py",
"retrieved_chunk": " product_count: int = 1\n reactants, products = mol_blocks_from_rxn_block(sample_rxn_block, reactant_count, product_count)\n # verify that the correct number of mol_blocks are returned\n assert len(products) == product_count\n assert len(reactants) == reactant_count\n # verify that the mol_blocks can be parsed\n for molecules in [reactants, products]:\n for mol_block in molecules:\n rd_mol = MolFromMolBlock(mol_block)\n assert rd_mol is not None",
"score": 0.8212230205535889
},
{
"filename": "test/conftest.py",
"retrieved_chunk": " mol.mol_block = get_sample_mol_block()\n return mol\n@pytest.fixture\ndef sample_molecule_metadata() -> dict[str, Any]:\n \"\"\"Return the sample mol block metadata.\"\"\"\n return dict(\n molecule_name=\"sample name\",\n user_initials=\"II\",\n program_name=\"PPPPPPPP\",\n date_time=datetime.datetime(22, 5, 24, 14, 23),",
"score": 0.8129161596298218
},
{
"filename": "rdfreader/chem/mol.py",
"retrieved_chunk": " def _from_mol_block(self, mol_block: str, properties: dict[str, Any] = dict()) -> None:\n \"\"\"Initialize the molecule object with a mol block string.\n Parameters\n ----------\n mol_block : str\n A mol block string.\n \"\"\"\n self.properties.update(properties)\n self._mol_block = mol_block\n if self.except_on_invalid_molecule:",
"score": 0.8043546676635742
},
{
"filename": "test/test_parse_rxn_block.py",
"retrieved_chunk": " rxn block.\"\"\"\n assert validate_rxn_block(sample_rxn_block)\ndef test_validate_rxn_block_invalid():\n \"\"\"Test that the validate_rxn_block function correctly validates the sample\n rxn block.\"\"\"\n assert not validate_rxn_block(\"invalid rxn block\")\ndef test_mol_blocks_from_rxn_block(sample_rxn_block):\n \"\"\"Test that the mol_blocks_from_rxn_block function correctly parses the\n sample rxn block.\"\"\"\n reactant_count: int = 3",
"score": 0.8033246994018555
},
{
"filename": "rdfreader/chem/mol.py",
"retrieved_chunk": "from typing import Any\nfrom rdkit.Chem import Mol, MolFromMolBlock, MolFromSmiles, MolToMolBlock, MolToSmiles\nfrom rdfreader.exceptions import InvalidMoleculeError\nfrom rdfreader.parse.molblock import get_mol_block_metadata\nclass Molecule:\n def __init__(\n self,\n mol_block: str = None,\n properties: dict[str, Any] = dict(),\n except_on_invalid_molecule: bool = True,",
"score": 0.7992233633995056
}
] | python | mol_block is None |
"""Module for testing dataset sequence packing"""
import unittest
from pathlib import Path
from datasets import Dataset, load_dataset
from transformers import AutoTokenizer
from axolotl.datasets import ConstantLengthDataset, TokenizedPromptDataset
from axolotl.prompt_tokenizers import AlpacaPromptTokenizingStrategy
from axolotl.prompters import AlpacaPrompter
class TestPacking(unittest.TestCase):
"""
Test class for packing dataset sequences
"""
def setUp(self) -> None:
# pylint: disable=duplicate-code
self.tokenizer = AutoTokenizer.from_pretrained("huggyllama/llama-7b")
self.tokenizer.add_special_tokens(
{
"bos_token": "<s>",
"eos_token": "</s>",
"unk_token": "<unk>",
}
)
def test_resets_attention(self):
prompter = AlpacaPrompter("chat")
strat = AlpacaPromptTokenizingStrategy(
prompter,
self.tokenizer,
False,
2048,
)
dateset = load_dataset(
"json",
data_files=str(Path(__file__).parent / "fixtures/alpaca/alpaca.json"),
)["train"]
dataset = Dataset. | from_list(list(TokenizedPromptDataset(strat, dateset))) |
constant_len_dataset = ConstantLengthDataset(
self.tokenizer,
[dataset],
seq_length=2048,
)
packed_dataset = Dataset.from_list(list(constant_len_dataset))
example = packed_dataset[0]
next_bos_index = (
example["input_ids"][1:].index(self.tokenizer.bos_token_id) + 1
) # add one since we sliced
# first example doesn't have mask reset
assert example["input_ids"][0] == self.tokenizer.bos_token_id
assert example["attention_mask"][0] == 1
# but subsequent one does
assert example["input_ids"][next_bos_index] == self.tokenizer.bos_token_id
assert example["attention_mask"][next_bos_index] == 0
if __name__ == "__main__":
unittest.main()
| tests/test_packed_dataset.py | OpenAccess-AI-Collective-axolotl-2c37bf6 | [
{
"filename": "tests/test_prompt_tokenizers.py",
"retrieved_chunk": " strat = AlpacaPromptTokenizingStrategy(\n prompter,\n self.tokenizer,\n False,\n 2048,\n )\n sample = {\n \"instruction\": \"hello cruel. lorem ipsum dolor sit amet.\",\n \"output\": \"world!\",\n }",
"score": 0.8749980330467224
},
{
"filename": "src/axolotl/utils/data.py",
"retrieved_chunk": "from axolotl.datasets import ConstantLengthDataset, TokenizedPromptDataset\nfrom axolotl.prompt_strategies import load\nfrom axolotl.prompt_tokenizers import (\n AlpacaMultipleChoicePromptTokenizingStrategy,\n AlpacaPromptTokenizingStrategy,\n AlpacaReflectionPTStrategy,\n CompletionPromptTokenizingStrategy,\n GPTeacherPromptTokenizingStrategy,\n JeopardyPromptTokenizingStrategy,\n OpenAssistantPromptTokenizingStrategy,",
"score": 0.8643407821655273
},
{
"filename": "tests/test_prompt_tokenizers.py",
"retrieved_chunk": " strat = AlpacaPromptTokenizingStrategy(\n prompter,\n self.tokenizer,\n False,\n 2048,\n )\n sample = {\"instruction\": \"hello!\", \"output\": \"Hi! How can I help?\"}\n example = strat.tokenize_prompt(sample)\n world_idx = example[\"input_ids\"].index(6324)\n assert example[\"labels\"][world_idx] == 6324",
"score": 0.8515662550926208
},
{
"filename": "src/axolotl/utils/data.py",
"retrieved_chunk": " ds_strategy = AlpacaReflectionPTStrategy(\n ReflectAlpacaPrompter(d_prompt_style),\n tokenizer,\n cfg.train_on_inputs,\n cfg.sequence_len,\n )\n ds_wrapper = TokenizedPromptDataset(ds_strategy, ds)\n datasets.append(ds_wrapper)\n elif d_base_type == \"sharegpt\":\n ds_strategy = ShareGPTPromptTokenizingStrategy(",
"score": 0.8422785997390747
},
{
"filename": "tests/test_prompt_tokenizers.py",
"retrieved_chunk": " \"bos_token\": \"<s>\",\n \"eos_token\": \"</s>\",\n \"unk_token\": \"<unk>\",\n }\n )\n def test_system_alpaca(self):\n prompter = SystemDataPrompter(PromptStyle.CHAT.value)\n strat = InstructionWSystemPromptTokenizingStrategy(\n prompter,\n self.tokenizer,",
"score": 0.841081976890564
}
] | python | from_list(list(TokenizedPromptDataset(strat, dateset))) |
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
# import fvcore.nn.weight_init as weight_init
from functools import partial
from MCCL.config import Config
config = Config()
class ResBlk(nn.Module):
def __init__(self, channel_in=64, channel_out=64, groups=0):
super(ResBlk, self).__init__()
self.conv_in = nn.Conv2d(channel_in, 64, 3, 1, 1)
self.relu_in = nn.ReLU(inplace=True)
if config.dec_att == 'ASPP':
self.dec_att = ASPP(channel_in=64)
self.conv_out = nn.Conv2d(64, channel_out, 3, 1, 1)
if config.use_bn:
self.bn_in = nn.BatchNorm2d(64)
self.bn_out = nn.BatchNorm2d(channel_out)
def forward(self, x):
x = self.conv_in(x)
if config.use_bn:
x = self.bn_in(x)
x = self.relu_in(x)
if config.dec_att:
x = self.dec_att(x)
x = self.conv_out(x)
if config.use_bn:
x = self.bn_out(x)
return x
class _ASPPModule(nn.Module):
def __init__(self, channel_in, planes, kernel_size, padding, dilation):
super(_ASPPModule, self).__init__()
self.atrous_conv = nn.Conv2d(channel_in, planes, kernel_size=kernel_size,
stride=1, padding=padding, dilation=dilation, bias=False)
self.bn = nn.BatchNorm2d(planes)
self.relu = nn.ReLU(inplace=True)
def forward(self, x):
x = self.atrous_conv(x)
x = self.bn(x)
return self.relu(x)
class ASPP(nn.Module):
def __init__(self, channel_in=64, output_stride=16):
super(ASPP, self).__init__()
self.down_scale = 1
self.channel_inter = 256 // self.down_scale
if output_stride == 16:
dilations = [1, 6, 12, 18]
elif output_stride == 8:
dilations = [1, 12, 24, 36]
else:
raise NotImplementedError
self.aspp1 = _ASPPModule(channel_in, self.channel_inter, 1, padding=0, dilation=dilations[0])
self.aspp2 = _ASPPModule(channel_in, self.channel_inter, 3, padding=dilations[1], dilation=dilations[1])
self.aspp3 = _ASPPModule(channel_in, self.channel_inter, 3, padding=dilations[2], dilation=dilations[2])
self.aspp4 = _ASPPModule(channel_in, self.channel_inter, 3, padding=dilations[3], dilation=dilations[3])
self.global_avg_pool = nn.Sequential(nn.AdaptiveAvgPool2d((1, 1)),
nn.Conv2d(channel_in, self.channel_inter, 1, stride=1, bias=False),
nn.BatchNorm2d(self.channel_inter),
nn.ReLU(inplace=True))
self.conv1 = nn.Conv2d(self.channel_inter * 5, channel_in, 1, bias=False)
self.bn1 = nn.BatchNorm2d(channel_in)
self.relu = nn.ReLU(inplace=True)
self.dropout = nn.Dropout(0.5)
def forward(self, x):
x1 = self.aspp1(x)
x2 = self.aspp2(x)
x3 = self.aspp3(x)
x4 = self.aspp4(x)
x5 = self.global_avg_pool(x)
x5 = F.interpolate(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)
x = torch.cat((x1, x2, x3, x4, x5), dim=1)
x = self.conv1(x)
x = self.bn1(x)
x = self.relu(x)
return self.dropout(x)
class CoAttLayer(nn.Module):
def __init__(self, channel_in=512):
super(CoAttLayer, self).__init__()
self.all_attention = GCAM(channel_in)
def forward(self, x):
if self.training:
if config. | loadN > 1: |
channel_per_class = x.shape[0] // config.loadN
x_per_class_corr_list = []
for idx in range(0, x.shape[0], channel_per_class):
x_per_class = x[idx:idx+channel_per_class]
x_new_per_class = self.all_attention(x_per_class)
x_per_class_proto = torch.mean(x_new_per_class, (0, 2, 3), True).view(1, -1)
x_per_class_proto = x_per_class_proto.unsqueeze(-1).unsqueeze(-1) # 1, C, 1, 1
x_per_class_corr = x_per_class * x_per_class_proto
x_per_class_corr_list.append(x_per_class_corr)
weighted_x = torch.cat(x_per_class_corr_list, dim=0)
else:
x_new = self.all_attention(x)
x_proto = torch.mean(x_new, (0, 2, 3), True).view(1, -1)
x_proto = x_proto.unsqueeze(-1).unsqueeze(-1) # 1, C, 1, 1
weighted_x = x * x_proto
else:
x_new = self.all_attention(x)
x_proto = torch.mean(x_new, (0, 2, 3), True).view(1, -1)
x_proto = x_proto.unsqueeze(-1).unsqueeze(-1) # 1, C, 1, 1
weighted_x = x * x_proto
return weighted_x
class GCAM(nn.Module):
def __init__(self, channel_in=512):
super(GCAM, self).__init__()
self.query_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.key_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.scale = 1.0 / (channel_in ** 0.5)
self.conv6 = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
# for layer in [self.query_transform, self.key_transform, self.conv6]:
# weight_init.c2_msra_fill(layer)
def forward(self, x):
# x: B,C,H,W
# x_query: B,C,HW
B, C, H5, W5 = x.size()
x_query = self.query_transform(x).view(B, C, -1)
# x_query: B,HW,C
x_query = torch.transpose(x_query, 1, 2).contiguous().view(-1, C) # BHW, C
# x_key: B,C,HW
x_key = self.key_transform(x).view(B, C, -1)
x_key = torch.transpose(x_key, 0, 1).contiguous().view(C, -1) # C, BHW
# W = Q^T K: B,HW,HW
x_w = torch.matmul(x_query, x_key) #* self.scale # BHW, BHW
x_w = x_w.view(B*H5*W5, B, H5*W5)
x_w = torch.max(x_w, -1).values # BHW, B
x_w = x_w.mean(-1)
#x_w = torch.mean(x_w, -1).values # BHW
x_w = x_w.view(B, -1) * self.scale # B, HW
x_w = F.softmax(x_w, dim=-1) # B, HW
x_w = x_w.view(B, H5, W5).unsqueeze(1) # B, 1, H, W
x = x * x_w
x = self.conv6(x)
return x
| MCCL/models/modules.py | ZhengPeng7-CoSOD_fps_collection-bee3764 | [
{
"filename": "GCoNet_plus/models/modules.py",
"retrieved_chunk": " return x\nclass CoAttLayer(nn.Module):\n def __init__(self, channel_in=512):\n super(CoAttLayer, self).__init__()\n self.all_attention = eval(Config().relation_module + '(channel_in)')\n self.conv_output = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0) \n self.conv_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0) \n self.fc_transform = nn.Linear(channel_in, channel_in)\n # for layer in [self.conv_output, self.conv_transform, self.fc_transform]:\n # weight_init.c2_msra_fill(layer)",
"score": 0.9142999053001404
},
{
"filename": "GCoNet/models/GCoNet.py",
"retrieved_chunk": " return x5\nclass CoAttLayer(nn.Module):\n def __init__(self, input_channels=512):\n super(CoAttLayer, self).__init__()\n self.all_attention = AllAttLayer(input_channels)\n self.conv_output = Conv2d(input_channels, input_channels, kernel_size=1, stride=1, padding=0) \n self.conv_transform = Conv2d(input_channels, input_channels, kernel_size=1, stride=1, padding=0) \n self.fc_transform = nn.Linear(input_channels, input_channels)\n # for layer in [self.conv_output, self.conv_transform, self.fc_transform]:\n # weight_init.c2_msra_fill(layer)",
"score": 0.8781577348709106
},
{
"filename": "DCFM/models/main.py",
"retrieved_chunk": " nn.ReLU(inplace=True),\n )\n self.predlayer = nn.Sequential(\n nn.Conv2d(int(in_channel/4), 1, kernel_size=1, stride=1, padding=0)) #, nn.Sigmoid())\n def forward(self, x):\n x = self.enlayer(x)\n x = self.predlayer(x)\n return x\nclass AugAttentionModule(nn.Module):\n def __init__(self, input_channels=512):",
"score": 0.8608227968215942
},
{
"filename": "GCoNet_plus/models/modules.py",
"retrieved_chunk": " self.bn2 = nn.BatchNorm2d(64)\n self.pred_bn = nn.BatchNorm2d(channel_out)\n def forward(self, x):\n x = self.conv1(x)\n if config.use_bn:\n x = self.bn1(x)\n x = self.relu1(x)\n x = self.conv2(x)\n if config.use_bn:\n x = self.bn2(x)",
"score": 0.8447147607803345
},
{
"filename": "GCoNet_plus/models/modules.py",
"retrieved_chunk": " x = self.relu_in(x)\n x = self.conv_out(x)\n if config.use_bn:\n x = self.bn_out(x)\n return x\nclass DSLayer(nn.Module):\n def __init__(self, channel_in=64, channel_out=1, activation_out='relu'):\n super(DSLayer, self).__init__()\n self.activation_out = activation_out\n self.conv1 = nn.Conv2d(channel_in, 64, kernel_size=3, stride=1, padding=1)",
"score": 0.8429064750671387
}
] | python | loadN > 1: |
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
# import fvcore.nn.weight_init as weight_init
from GCoNet_plus.config import Config
config = Config()
class ResBlk(nn.Module):
def __init__(self, channel_in=64, channel_out=64):
super(ResBlk, self).__init__()
self.conv_in = nn.Conv2d(channel_in, 64, 3, 1, 1)
self.relu_in = nn.ReLU(inplace=True)
self.conv_out = nn.Conv2d(64, channel_out, 3, 1, 1)
if config.use_bn:
self.bn_in = nn.BatchNorm2d(64)
self.bn_out = nn.BatchNorm2d(channel_out)
def forward(self, x):
x = self.conv_in(x)
if config.use_bn:
x = self.bn_in(x)
x = self.relu_in(x)
x = self.conv_out(x)
if config.use_bn:
x = self.bn_out(x)
return x
class DSLayer(nn.Module):
def __init__(self, channel_in=64, channel_out=1, activation_out='relu'):
super(DSLayer, self).__init__()
self.activation_out = activation_out
self.conv1 = nn.Conv2d(channel_in, 64, kernel_size=3, stride=1, padding=1)
self.relu1 = nn.ReLU(inplace=True)
self.conv2 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1)
self.relu2 = nn.ReLU(inplace=True)
if activation_out:
self.pred_conv = nn.Conv2d(64, channel_out, kernel_size=1, stride=1, padding=0)
self.pred_relu = nn.ReLU(inplace=True)
else:
self.pred_conv = nn.Conv2d(64, channel_out, kernel_size=1, stride=1, padding=0)
if config.use_bn:
self.bn1 = nn.BatchNorm2d(64)
self.bn2 = nn.BatchNorm2d(64)
self.pred_bn = nn.BatchNorm2d(channel_out)
def forward(self, x):
x = self.conv1(x)
if config.use_bn:
x = self.bn1(x)
x = self.relu1(x)
x = self.conv2(x)
if config.use_bn:
x = self.bn2(x)
x = self.relu2(x)
x = self.pred_conv(x)
if config.use_bn:
x = self.pred_bn(x)
if self.activation_out:
x = self.pred_relu(x)
return x
class half_DSLayer(nn.Module):
def __init__(self, channel_in=512):
super(half_DSLayer, self).__init__()
self.enlayer = nn.Sequential(
nn.Conv2d(channel_in, int(channel_in//4), kernel_size=3, stride=1, padding=1),
nn.ReLU(inplace=True)
)
self.predlayer = nn.Sequential(
nn.Conv2d(int(channel_in//4), 1, kernel_size=1, stride=1, padding=0),
)
def forward(self, x):
x = self.enlayer(x)
x = self.predlayer(x)
return x
class CoAttLayer(nn.Module):
def __init__(self, channel_in=512):
super(CoAttLayer, self).__init__()
self.all_attention = eval(Config().relation_module + '(channel_in)')
self.conv_output = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.conv_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.fc_transform = nn.Linear(channel_in, channel_in)
# for layer in [self.conv_output, self.conv_transform, self.fc_transform]:
# weight_init.c2_msra_fill(layer)
def forward(self, x5):
if self.training:
f_begin = 0
f_end = int(x5.shape[0] / 2)
s_begin = f_end
s_end = int(x5.shape[0])
x5_1 = x5[f_begin: f_end]
x5_2 = x5[s_begin: s_end]
x5_new_1 = self.all_attention(x5_1)
x5_new_2 = self.all_attention(x5_2)
x5_1_proto = torch.mean(x5_new_1, (0, 2, 3), True).view(1, -1)
x5_1_proto = x5_1_proto.unsqueeze(-1).unsqueeze(-1) # 1, C, 1, 1
x5_2_proto = torch.mean(x5_new_2, (0, 2, 3), True).view(1, -1)
x5_2_proto = x5_2_proto.unsqueeze(-1).unsqueeze(-1) # 1, C, 1, 1
x5_11 = x5_1 * x5_1_proto
x5_22 = x5_2 * x5_2_proto
weighted_x5 = torch.cat([x5_11, x5_22], dim=0)
x5_12 = x5_1 * x5_2_proto
x5_21 = x5_2 * x5_1_proto
neg_x5 = torch.cat([x5_12, x5_21], dim=0)
else:
x5_new = self.all_attention(x5)
x5_proto = torch.mean(x5_new, (0, 2, 3), True).view(1, -1)
x5_proto = x5_proto.unsqueeze(-1).unsqueeze(-1) # 1, C, 1, 1
weighted_x5 = x5 * x5_proto #* cweight
neg_x5 = None
return weighted_x5, neg_x5
class ICE(nn.Module):
# The Integrity Channel Enhancement (ICE) module
# _X means in X-th column
def __init__(self, channel_in=512):
super(ICE, self).__init__()
self.conv_1 = nn.Conv2d(channel_in, channel_in, 3, 1, 1)
self.conv_2 = nn.Conv1d(channel_in, channel_in, 3, 1, 1)
self.conv_3 = nn.Conv2d(channel_in*3, channel_in, 3, 1, 1)
self.fc_2 = nn.Linear(channel_in, channel_in)
self.fc_3 = nn.Linear(channel_in, channel_in)
def forward(self, x):
x_1, x_2, x_3 = x, x, x
x_1 = x_1 * x_2 * x_3
x_2 = x_1 + x_2 + x_3
x_3 = torch.cat((x_1, x_2, x_3), dim=1)
V = self.conv_1(x_1)
bs, c, h, w = x_2.shape
K = self.conv_2(x_2.view(bs, c, h*w))
Q_prime = self.conv_3(x_3)
Q_prime = torch.norm(Q_prime, dim=(-2, -1)).view(bs, c, 1, 1)
Q_prime = Q_prime.view(bs, -1)
Q_prime = self.fc_3(Q_prime)
Q_prime = torch.softmax(Q_prime, dim=-1)
Q_prime = Q_prime.unsqueeze(1)
Q = torch.matmul(Q_prime, K)
x_2 = torch.nn.functional.cosine_similarity(K, Q, dim=-1)
x_2 = torch.sigmoid(x_2)
x_2 = self.fc_2(x_2)
x_2 = x_2.unsqueeze(-1).unsqueeze(-1)
x_1 = V * x_2 + V
return x_1
class GAM(nn.Module):
def __init__(self, channel_in=512):
super(GAM, self).__init__()
self.query_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.key_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.scale = 1.0 / (channel_in ** 0.5)
self.conv6 = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
# for layer in [self.query_transform, self.key_transform, self.conv6]:
# weight_init.c2_msra_fill(layer)
def forward(self, x5):
# x: B,C,H,W
# x_query: B,C,HW
B, C, H5, W5 = x5.size()
x_query = self.query_transform(x5).view(B, C, -1)
# x_query: B,HW,C
x_query = torch.transpose(x_query, 1, 2).contiguous().view(-1, C) # BHW, C
# x_key: B,C,HW
x_key = self.key_transform(x5).view(B, C, -1)
x_key = torch.transpose(x_key, 0, 1).contiguous().view(C, -1) # C, BHW
# W = Q^T K: B,HW,HW
x_w = torch.matmul(x_query, x_key) #* self.scale # BHW, BHW
x_w = x_w.view(B*H5*W5, B, H5*W5)
x_w = torch.max(x_w, -1).values # BHW, B
x_w = x_w.mean(-1)
#x_w = torch.mean(x_w, -1).values # BHW
x_w = x_w.view(B, -1) * self.scale # B, HW
x_w = F.softmax(x_w, dim=-1) # B, HW
x_w = x_w.view(B, H5, W5).unsqueeze(1) # B, 1, H, W
x5 = x5 * x_w
x5 = self.conv6(x5)
return x5
class MHA(nn.Module):
'''
Scaled dot-product attention
'''
def __init__(self, d_model=512, d_k=512, d_v=512, h=8, dropout=.1, channel_in=512):
'''
:param d_model: Output dimensionality of the model
:param d_k: Dimensionality of queries and keys
:param d_v: Dimensionality of values
:param h: Number of heads
'''
super(MHA, self).__init__()
self.query_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.key_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.value_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.fc_q = nn.Linear(d_model, h * d_k)
self.fc_k = nn.Linear(d_model, h * d_k)
self.fc_v = nn.Linear(d_model, h * d_v)
self.fc_o = nn.Linear(h * d_v, d_model)
self.dropout = nn.Dropout(dropout)
self.d_model = d_model
self.d_k = d_k
self.d_v = d_v
self.h = h
self.init_weights()
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode='fan_out')
if m.bias is not None:
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.Linear):
nn.init.normal_(m.weight, std=0.001)
if m.bias is not None:
nn.init.constant_(m.bias, 0)
def forward(self, x, attention_mask=None, attention_weights=None):
'''
Computes
:param queries: Queries (b_s, nq, d_model)
:param keys: Keys (b_s, nk, d_model)
:param values: Values (b_s, nk, d_model)
:param attention_mask: Mask over attention values (b_s, h, nq, nk). True indicates masking.
:param attention_weights: Multiplicative weights for attention values (b_s, h, nq, nk).
:return:
'''
B, C, H, W = x.size()
queries = self.query_transform(x).view(B, -1, C)
keys = self.query_transform(x).view(B, -1, C)
values = self.query_transform(x).view(B, -1, C)
b_s, nq = queries.shape[:2]
nk = keys.shape[1]
q = self.fc_q(queries).view(b_s, nq, self.h, self.d_k).permute(0, 2, 1, 3) # (b_s, h, nq, d_k)
k = self.fc_k(keys).view(b_s, nk, self.h, self.d_k).permute(0, 2, 3, 1) # (b_s, h, d_k, nk)
v = self.fc_v(values).view(b_s, nk, self.h, self.d_v).permute(0, 2, 1, 3) # (b_s, h, nk, d_v)
att = torch.matmul(q, k) / np.sqrt(self.d_k) # (b_s, h, nq, nk)
if attention_weights is not None:
att = att * attention_weights
if attention_mask is not None:
att = att.masked_fill(attention_mask, -np.inf)
att = torch.softmax(att, -1)
att = self.dropout(att)
out = torch.matmul(att, v).permute(0, 2, 1, 3).contiguous().view(b_s, nq, self.h * self.d_v) # (b_s, nq, h*d_v)
out = self.fc_o(out).view(B, C, H, W) # (b_s, nq, d_model)
return out
class NonLocal(nn.Module):
def __init__(self, channel_in=512, inter_channels=None, dimension=2, sub_sample=True, bn_layer=True):
super(NonLocal, self).__init__()
assert dimension in [1, 2, 3]
self.dimension = dimension
self.sub_sample = sub_sample
self.channel_in = channel_in
self.inter_channels = inter_channels
if self.inter_channels is None:
self.inter_channels = channel_in // 2
if self.inter_channels == 0:
self.inter_channels = 1
self.g = nn.Conv2d(self.channel_in, self.inter_channels, 1, 1, 0)
if bn_layer:
self.W = nn.Sequential(
nn.Conv2d(self.inter_channels, self.channel_in, kernel_size=1, stride=1, padding=0),
nn.BatchNorm2d(self.channel_in)
)
nn.init.constant_(self.W[1].weight, 0)
nn.init.constant_(self.W[1].bias, 0)
else:
self.W = nn.Conv2d(self.inter_channels, self.channel_in, kernel_size=1, stride=1, padding=0)
nn.init.constant_(self.W.weight, 0)
nn.init.constant_(self.W.bias, 0)
self.theta = nn.Conv2d(self.channel_in, self.inter_channels, kernel_size=1, stride=1, padding=0)
self.phi = nn.Conv2d(self.channel_in, self.inter_channels, kernel_size=1, stride=1, padding=0)
if sub_sample:
self.g = nn.Sequential(self.g, nn.MaxPool2d(kernel_size=(2, 2)))
self.phi = nn.Sequential(self.phi, nn.MaxPool2d(kernel_size=(2, 2)))
def forward(self, x, return_nl_map=False):
"""
:param x: (b, c, t, h, w)
:param return_nl_map: if True return z, nl_map, else only return z.
:return:
"""
batch_size = x.size(0)
g_x = self.g(x).view(batch_size, self.inter_channels, -1)
g_x = g_x.permute(0, 2, 1)
theta_x = self.theta(x).view(batch_size, self.inter_channels, -1)
theta_x = theta_x.permute(0, 2, 1)
phi_x = self.phi(x).view(batch_size, self.inter_channels, -1)
f = torch.matmul(theta_x, phi_x)
f_div_C = F.softmax(f, dim=-1)
y = torch.matmul(f_div_C, g_x)
y = y.permute(0, 2, 1).contiguous()
y = y.view(batch_size, self.inter_channels, *x.size()[2:])
W_y = self.W(y)
z = W_y + x
if return_nl_map:
return z, f_div_C
return z
class DBHead(nn.Module):
def __init__(self, channel_in=32, channel_out=1, k=config.db_k):
super().__init__()
self.k = k
self.binarize = nn.Sequential(
nn.Conv2d(channel_in, channel_in, 3, 1, 1),
*[nn.BatchNorm2d(channel_in), nn.ReLU(inplace=True)] if config.use_bn else nn.ReLU(inplace=True),
nn.Conv2d(channel_in, channel_in, 3, 1, 1),
*[nn.BatchNorm2d(channel_in), nn.ReLU(inplace=True)] if config.use_bn else nn.ReLU(inplace=True),
nn.Conv2d(channel_in, channel_out, 1, 1, 0),
nn.Sigmoid()
)
self.thresh = nn.Sequential(
nn.Conv2d(channel_in, channel_in, 3, padding=1),
*[nn.BatchNorm2d(channel_in), nn.ReLU(inplace=True)] if config.use_bn else nn.ReLU(inplace=True),
nn.Conv2d(channel_in, channel_in, 3, 1, 1),
*[nn.BatchNorm2d(channel_in), nn.ReLU(inplace=True)] if config.use_bn else nn.ReLU(inplace=True),
nn.Conv2d(channel_in, channel_out, 1, 1, 0),
nn.Sigmoid()
)
def forward(self, x):
shrink_maps = self.binarize(x)
threshold_maps = self.thresh(x)
binary_maps = self.step_function(shrink_maps, threshold_maps)
return binary_maps
def step_function(self, x, y):
if config.db_k_alpha != 1:
z = x - y
mask_neg_inv = 1 - 2 * (z < 0)
a = torch.exp(-self.k * (torch.pow(z * mask_neg_inv + 1e-16, 1/config. | k_alpha) * mask_neg_inv)) |
else:
a = torch.exp(-self.k * (x - y))
if torch.isinf(a).any():
a = torch.exp(-50 * (x - y))
return torch.reciprocal(1 + a)
class RefUnet(nn.Module):
# Refinement
def __init__(self, in_ch, inc_ch):
super(RefUnet, self).__init__()
self.conv0 = nn.Conv2d(in_ch, inc_ch, 3, padding=1)
self.conv1 = nn.Conv2d(inc_ch, 64, 3, padding=1)
if config.use_bn:
self.bn1 = nn.BatchNorm2d(64)
self.relu1 = nn.ReLU(inplace=True)
self.pool1 = nn.MaxPool2d(2, 2, ceil_mode=True)
self.conv2 = nn.Conv2d(64, 64, 3, padding=1)
if config.use_bn:
self.bn2 = nn.BatchNorm2d(64)
self.relu2 = nn.ReLU(inplace=True)
self.pool2 = nn.MaxPool2d(2, 2, ceil_mode=True)
self.conv3 = nn.Conv2d(64, 64, 3, padding=1)
if config.use_bn:
self.bn3 = nn.BatchNorm2d(64)
self.relu3 = nn.ReLU(inplace=True)
self.pool3 = nn.MaxPool2d(2, 2, ceil_mode=True)
self.conv4 = nn.Conv2d(64, 64, 3, padding=1)
if config.use_bn:
self.bn4 = nn.BatchNorm2d(64)
self.relu4 = nn.ReLU(inplace=True)
self.pool4 = nn.MaxPool2d(2, 2, ceil_mode=True)
#####
self.conv5 = nn.Conv2d(64, 64, 3, padding=1)
if config.use_bn:
self.bn5 = nn.BatchNorm2d(64)
self.relu5 = nn.ReLU(inplace=True)
#####
self.conv_d4 = nn.Conv2d(128, 64, 3, padding=1)
if config.use_bn:
self.bn_d4 = nn.BatchNorm2d(64)
self.relu_d4 = nn.ReLU(inplace=True)
self.conv_d3 = nn.Conv2d(128, 64, 3, padding=1)
if config.use_bn:
self.bn_d3 = nn.BatchNorm2d(64)
self.relu_d3 = nn.ReLU(inplace=True)
self.conv_d2 = nn.Conv2d(128, 64, 3, padding=1)
if config.use_bn:
self.bn_d2 = nn.BatchNorm2d(64)
self.relu_d2 = nn.ReLU(inplace=True)
self.conv_d1 = nn.Conv2d(128, 64, 3, padding=1)
if config.use_bn:
self.bn_d1 = nn.BatchNorm2d(64)
self.relu_d1 = nn.ReLU(inplace=True)
self.conv_d0 = nn.Conv2d(64, 1, 3, padding=1)
self.upscore2 = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
if config.db_output_refiner:
self.db_output_refiner = DBHead(64)
def forward(self, x):
hx = x
hx = self.conv1(self.conv0(hx))
if config.use_bn:
hx = self.bn1(hx)
hx1 = self.relu1(hx)
hx = self.conv2(self.pool1(hx1))
if config.use_bn:
hx = self.bn2(hx)
hx2 = self.relu2(hx)
hx = self.conv3(self.pool2(hx2))
if config.use_bn:
hx = self.bn3(hx)
hx3 = self.relu3(hx)
hx = self.conv4(self.pool3(hx3))
if config.use_bn:
hx = self.bn4(hx)
hx4 = self.relu4(hx)
hx = self.conv5(self.pool4(hx4))
if config.use_bn:
hx = self.bn5(hx)
hx5 = self.relu5(hx)
hx = self.upscore2(hx5)
d4 = self.conv_d4(torch.cat((hx, hx4), 1))
if config.use_bn:
d4 = self.bn_d4(d4)
d4 = self.relu_d4(d4)
hx = self.upscore2(d4)
d3 = self.conv_d3(torch.cat((hx, hx3), 1))
if config.use_bn:
d3 = self.bn_d3(d3)
d3 = self.relu_d3(d3)
hx = self.upscore2(d3)
d2 = self.conv_d2(torch.cat((hx, hx2), 1))
if config.use_bn:
d2 = self.bn_d2(d2)
d2 = self.relu_d2(d2)
hx = self.upscore2(d2)
d1 = self.conv_d1(torch.cat((hx, hx1), 1))
if config.use_bn:
d1 = self.bn_d1(d1)
d1 = self.relu_d1(d1)
if config.db_output_refiner:
x = self.db_output_refiner(d1)
else:
residual = self.conv_d0(d1)
x = x + residual
return x
| GCoNet_plus/models/modules.py | ZhengPeng7-CoSOD_fps_collection-bee3764 | [
{
"filename": "GCAGC_CVPR2020/model3/cls_hrnet.py",
"retrieved_chunk": " x = self.bn2(x)\n x = self.relu(x)\n x = self.layer1(x)\n x_list = []\n for i in range(self.stage2_cfg['NUM_BRANCHES']):\n if self.transition1[i] is not None:\n x_list.append(self.transition1[i](x))\n else:\n x_list.append(x)\n y_list = self.stage2(x_list)",
"score": 0.7747178077697754
},
{
"filename": "DCFM/models/main.py",
"retrieved_chunk": " B, C, H5, W5 = x5.size()\n if self.training:\n correlation_maps = F.conv2d(x5, weight=seeds) # B,B,H,W\n else:\n correlation_maps = torch.relu(F.conv2d(x5, weight=seeds)) # B,B,H,W\n correlation_maps = correlation_maps.mean(1).view(B, -1)\n min_value = torch.min(correlation_maps, dim=1, keepdim=True)[0]\n max_value = torch.max(correlation_maps, dim=1, keepdim=True)[0]\n correlation_maps = (correlation_maps - min_value) / (max_value - min_value + 1e-12) # shape=[B, HW]\n correlation_maps = correlation_maps.view(B, 1, H5, W5) # shape=[B, 1, H, W]",
"score": 0.7746461629867554
},
{
"filename": "DCFM/models/main.py",
"retrieved_chunk": " x = self.conv(x)\n x_query = self.query_transform(x).view(B, C, -1).permute(0, 2, 1) # B,HW,C\n # x_key: C,BHW\n x_key = self.key_transform(x).view(B, C, -1) # B, C,HW\n # x_value: BHW, C\n x_value = self.value_transform(x).view(B, C, -1).permute(0, 2, 1) # B,HW,C\n attention_bmm = torch.bmm(x_query, x_key)*self.scale # B, HW, HW\n attention = F.softmax(attention_bmm, dim=-1)\n attention_sort = torch.sort(attention_bmm, dim=-1, descending=True)[1]\n attention_sort = torch.sort(attention_sort, dim=-1)[1]",
"score": 0.7741490602493286
},
{
"filename": "DCFM/models/main.py",
"retrieved_chunk": " return correlation_maps\n def forward(self, x5):\n # x: B,C,H,W\n x5 = self.conv(x5)+x5\n B, C, H5, W5 = x5.size()\n x_query = self.query_transform(x5).view(B, C, -1)\n # x_query: B,HW,C\n x_query = torch.transpose(x_query, 1, 2).contiguous().view(-1, C) # BHW, C\n # x_key: B,C,HW\n x_key = self.key_transform(x5).view(B, C, -1)",
"score": 0.7733408212661743
},
{
"filename": "DCFM/models/main.py",
"retrieved_chunk": " x5, x4, x3, x2, x1 = self.featextract(x)\n feat, proto, weighted_x5, cormap = self.fusion(x5)\n feataug = self.aug(weighted_x5)\n preds = self.decoder(feataug, x4, x3, x2, x1, H, W)\n if self.training:\n gt = F.interpolate(gt, size=weighted_x5.size()[2:], mode='bilinear', align_corners=False)\n feat_pos, proto_pos, weighted_x5_pos, cormap_pos = self.fusion(x5 * gt)\n feat_neg, proto_neg, weighted_x5_neg, cormap_neg = self.fusion(x5*(1-gt))\n return preds, proto, proto_pos, proto_neg\n return preds",
"score": 0.7726375460624695
}
] | python | k_alpha) * mask_neg_inv)) |
# Copyright 2023 Adobe. All rights reserved.
# This file is licensed to you 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 REPRESENTATIONS
# OF ANY KIND, either express or implied. See the License for the specific language
# governing permissions and limitations under the License.
from aepp.schema import Schema
import unittest
from unittest.mock import patch, MagicMock
class SchemaTest(unittest.TestCase):
@patch("aepp.connector.AdobeRequest")
def test_schema_get_resource(self, mock_connector):
instance_conn = mock_connector.return_value
instance_conn.getData.return_value = "foo"
schema_obj = Schema()
result = schema_obj.getResource(MagicMock(), MagicMock(), MagicMock(), MagicMock())
assert(result is not None)
instance_conn.getData.assert_called_once()
@patch("aepp.connector.AdobeRequest")
def test_schema_update_sandbox(self, mock_connector):
schema_obj = Schema()
test_sandbox = "prod"
schema_obj.updateSandbox(test_sandbox)
assert(schema_obj.sandbox == test_sandbox)
@patch("aepp.connector.AdobeRequest")
def test_schema_get_stats(self, mock_connector):
instance_conn = mock_connector.return_value
instance_conn.getData.return_value = MagicMock()
schema_obj = Schema()
stats_result = schema_obj.getStats()
assert (stats_result is not None)
assert(stats_result == instance_conn.getData.return_value)
instance_conn.getData.assert_called_once()
@patch("aepp.connector.AdobeRequest")
def test_schema_get_tenant_id(self, mock_connector):
instance_conn = mock_connector.return_value
instance_conn.getStats.return_value = MagicMock()
schema_obj = Schema()
tenant_id_result = schema_obj.getTenantId()
assert (tenant_id_result is not None)
instance_conn.getData.assert_called_once()
@patch("aepp.connector.AdobeRequest")
def test_schema_get_behavior(self, mock_connector):
instance_conn = mock_connector.return_value
instance_conn.getData.return_value = {"results":[1234,5678]}
schema_obj = Schema()
stats_result = schema_obj. | getBehaviors() |
assert (stats_result is not None)
assert (stats_result == instance_conn.getData.return_value.get("results"))
instance_conn.getData.assert_called_once() | tests/schema_test.py | adobe-aepp-0e23c55 | [
{
"filename": "tests/destinationinstanceservice_test.py",
"retrieved_chunk": "import unittest\nfrom unittest.mock import patch, MagicMock, ANY\nclass DestinationInstanceServiceTest(unittest.TestCase):\n ADHOC_INPUT = {\"flow1\": [\"dataset1\"], \"flow2\": [\"dataset2\", \"dataset3\"]}\n ADHOC_EXPECTED_PAYLOAD = {'activationInfo': {'destinations': [{'flowId': 'flow1', 'datasets': [{'id': 'dataset1'}]}, {'flowId': 'flow2', 'datasets': [{'id': 'dataset2'}, {'id': 'dataset3'}]}]}}\n @patch(\"aepp.connector.AdobeRequest\")\n def test_create_adhoc_dataset_export(self, mock_connector):\n instance_conn = mock_connector.return_value\n instance_conn.postData.return_value = {'foo'}\n destination_instance_service_obj = DestinationInstanceService()",
"score": 0.8162609338760376
},
{
"filename": "tests/exportDatasetToDatalandingZone_test.py",
"retrieved_chunk": " export_obj = ExportDatasetToDataLandingZone(config= self.config, header= MagicMock())\n return_dataflow_id = export_obj.createDataFlow(dataset_id=\"test\", compression_type=\"gzip\", data_format=\"parquet\", export_path=\"test\", on_schedule=False, config_path=\"test\", entity_name=\"test\")\n assert (return_dataflow_id == self.flow_response[\"id\"])\n @patch('aepp.destinationinstanceservice.DestinationInstanceService.createAdHocDatasetExport', MagicMock(return_value = adhoc_success_response))\n @patch(\"aepp.connector.AdobeRequest\", MagicMock())\n def test_retry_on_success_response(self):\n export_obj = ExportDatasetToDataLandingZone(config= self.config, header= MagicMock())\n assert(export_obj.retryOnNotReadyException(\"test\", \"test\", 1, 1) == self.adhoc_success_response)\n @patch('aepp.destinationinstanceservice.DestinationInstanceService.createAdHocDatasetExport', MagicMock(return_value = adhoc_non_retry_error))\n @patch(\"aepp.connector.AdobeRequest\", MagicMock())",
"score": 0.8078042268753052
},
{
"filename": "tests/exportDatasetToDatalandingZone_test.py",
"retrieved_chunk": " export_obj = ExportDatasetToDataLandingZone(config= self.config, header= MagicMock())\n export_obj.createDataFlowRunIfNotExists(dataset_id=\"test\", compression_type=\"gzip\", data_format=\"parquet\", export_path=\"test\", on_schedule=True, config_path=\"test\",entity_name=\"test\", initial_delay=0)\n @patch('aepp.flowservice.FlowService.createConnection', MagicMock(return_value = base_connection))\n @patch('aepp.flowservice.FlowService.getConnectionSpecIdFromName', MagicMock(return_value = connection_spec))\n @patch('aepp.flowservice.FlowService.createSourceConnection', MagicMock(return_value = source_connection))\n @patch('aepp.flowservice.FlowService.createTargetConnection', MagicMock(return_value = target_connection))\n @patch('aepp.flowservice.FlowService.createFlow', MagicMock(return_value = flow_response))\n @patch('aepp.utils.Utils.save_field_in_config', MagicMock())\n @patch(\"aepp.connector.AdobeRequest\", MagicMock())\n def test_create_dataflow_if_not_exist(self):",
"score": 0.8063048124313354
},
{
"filename": "tests/exportDatasetToDatalandingZone_test.py",
"retrieved_chunk": " @patch('aepp.destinationinstanceservice.DestinationInstanceService.createAdHocDatasetExport', MagicMock(return_value = adhoc_success_response))\n @patch(\"aepp.connector.AdobeRequest\", MagicMock())\n def test_create_dataflow_if_exist(self):\n export_obj = ExportDatasetToDataLandingZone(config= self.config, header= MagicMock())\n export_obj.createDataFlowRunIfNotExists(dataset_id=\"test\", compression_type=\"gzip\", data_format=\"parquet\", export_path=\"test\", on_schedule=False, config_path=\"test\", entity_name=\"test\", initial_delay=0)\n @patch('aepp.utils.Utils.check_if_exists', MagicMock(return_value = \"test_dataflow_id\"))\n @patch('aepp.flowservice.FlowService.getFlow', MagicMock(return_value = flow_response))\n @patch('aepp.flowservice.FlowService.getSourceConnection', MagicMock(return_value = source_connection))\n @patch(\"aepp.connector.AdobeRequest\", MagicMock())\n def test_create_dataflow_on_schedule(self):",
"score": 0.8060683012008667
},
{
"filename": "tests/destinationinstanceservice_test.py",
"retrieved_chunk": " result = destination_instance_service_obj.createAdHocDatasetExport(self.ADHOC_INPUT)\n assert(result is not None)\n instance_conn.postData.assert_called_once()\n instance_conn.postData.assert_called_with(ANY, data=self.ADHOC_EXPECTED_PAYLOAD)\n @patch(\"aepp.connector.AdobeRequest\")\n def test_create_adhoc_dataset_export_invalid_input(self, mock_connector):\n destination_instance_service_obj = DestinationInstanceService()\n with self.assertRaises(Exception) as cm:\n destination_instance_service_obj.createAdHocDatasetExport(None)\n self.assertEqual('Require a dict for defining the flowId to datasetIds mapping', str(cm.exception))",
"score": 0.8020358681678772
}
] | python | getBehaviors() |
# Copyright 2023 Adobe. All rights reserved.
# This file is licensed to you 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 REPRESENTATIONS
# OF ANY KIND, either express or implied. See the License for the specific language
# governing permissions and limitations under the License.
import json
import os
from pathlib import Path
from typing import Optional
import json
# Non standard libraries
from .config import config_object, header, endpoints
from aepp import connector
def find_path(path: str) -> Optional[Path]:
"""Checks if the file denoted by the specified `path` exists and returns the Path object
for the file.
If the file under the `path` does not exist and the path denotes an absolute path, tries
to find the file by converting the absolute path to a relative path.
If the file does not exist with either the absolute and the relative path, returns `None`.
"""
if Path(path).exists():
return Path(path)
elif path.startswith("/") and Path("." + path).exists():
return Path("." + path)
elif path.startswith("\\") and Path("." + path).exists():
return Path("." + path)
else:
return None
def createConfigFile(
destination: str = "config_aep_template.json",
sandbox: str = "prod",
environment: str = "prod",
verbose: object = False,
auth_type: str = "oauthV2",
**kwargs,
) -> None:
"""
This function will create a 'config_admin.json' file where you can store your access data.
Arguments:
destination : OPTIONAL : if you wish to save the file at a specific location.
sandbox : OPTIONAL : You can directly set your sandbox name in this parameter.
verbose : OPTIONAL : set to true, gives you a print stateent where is the location.
auth_type : OPTIONAL : type of authentication, either "jwt" or "oauthV2" or "oauthV1". Default is oauthV2
"""
json_data: dict = {
"org_id": "<orgID>",
"client_id": "<client_id>",
"secret": "<YourSecret>",
"sandbox-name": sandbox,
"environment": environment
}
if auth_type == "jwt":
json_data["tech_id"] = "<something>@techacct.adobe.com"
json_data["pathToKey"] = "<path/to/your/privatekey.key>"
elif auth_type == "oauthV2":
json_data["scopes"] = "<scopes>"
elif auth_type == "oauthV1":
json_data["auth_code"] = "<auth_code>"
else:
raise ValueError("unsupported authentication type, currently only jwt, oauthV1 and oauthV2 are supported")
if ".json" not in destination:
destination: str = f"{destination}.json"
with open(destination, "w") as cf:
cf.write(json.dumps(json_data, indent=4))
if verbose:
print(
f" file created at this location : {os.getcwd()}{os.sep}{destination}.json"
)
def importConfigFile(
path: str = None,
connectInstance: bool = False,
auth_type: str = None,
sandbox:str = None,
):
"""Reads the file denoted by the supplied `path` and retrieves the configuration information
from it.
Arguments:
path: REQUIRED : path to the configuration file. Can be either a fully-qualified or relative.
connectInstance : OPTIONAL : If you want to return an instance of the ConnectObject class
auth_type : OPTIONAL : type of authentication, either "jwt" or "oauthV1" or "oauthV2". Detected based on keys present in config file.
sandbox : OPTIONAL : The sandbox to connect it.
Example of path value.
"config.json"
"./config.json"
"/my-folder/config.json"
"""
if path is None:
raise ValueError("require a path to a configuration file to be provided")
config_file_path: Optional[Path] = find_path(path)
if config_file_path is None:
raise FileNotFoundError(
f"Unable to find the configuration file under path `{path}`."
)
with open(config_file_path, "r") as file:
provided_config = json.load(file)
provided_keys = list(provided_config.keys())
if "api_key" in provided_keys:
## old naming for client_id
client_id = provided_config["api_key"]
elif "client_id" in provided_keys:
client_id = provided_config["client_id"]
else:
raise RuntimeError(
f"Either an `api_key` or a `client_id` should be provided."
)
if auth_type is None:
if 'scopes' in provided_keys:
auth_type = 'oauthV2'
elif 'tech_id' in provided_keys and "pathToKey" in provided_keys:
auth_type = 'jwt'
elif 'auth_code' in provided_keys:
auth_type = 'oauthV1'
args = {
"org_id": provided_config["org_id"],
"client_id": client_id,
"secret": provided_config["secret"],
"sandbox": provided_config.get("sandbox-name", "prod"),
"environment": provided_config.get("environment", "prod"),
"connectInstance": connectInstance
}
if sandbox is not None: ## overriding sandbox from parameter
args["sandbox"] = sandbox
if auth_type == "jwt":
args["tech_id"] = provided_config["tech_id"]
args["path_to_key"] = provided_config["pathToKey"]
elif auth_type == "oauthV2":
args["scopes"] = provided_config["scopes"].replace(' ','')
elif auth_type == "oauthV1":
args["auth_code"] = provided_config["auth_code"]
else:
raise ValueError("unsupported authentication type, currently only jwt and oauth are supported")
myInstance = configure(**args)
if connectInstance:
return myInstance
def configure(
org_id: str = None,
tech_id: str = None,
secret: str = None,
client_id: str = None,
path_to_key: str = None,
private_key: str = None,
sandbox: str = "prod",
connectInstance: bool = False,
environment: str = "prod",
scopes: str = None,
auth_code:str=None
):
"""Performs programmatic configuration of the API using provided values.
Arguments:
org_id : REQUIRED : Organization ID
tech_id : OPTIONAL : Technical Account ID
secret : REQUIRED : secret generated for your connection
client_id : REQUIRED : The client_id (old api_key) provided by the JWT connection.
path_to_key : REQUIRED : If you have a file containing your private key value.
private_key : REQUIRED : If you do not use a file but pass a variable directly.
sandbox : OPTIONAL : If not provided, default to prod
connectInstance : OPTIONAL : If you want to return an instance of the ConnectObject class
environment : OPTIONAL : If not provided, default to prod
scopes : OPTIONAL : The scope define in your project for your API connection. Oauth V2, for clients and customers.
auth_code : OPTIONAL : If an authorization code is used directly instead of generating via JWT. Oauth V1 only, for adobe internal services.
"""
if not org_id:
raise ValueError("`org_id` must be specified in the configuration.")
if not client_id:
raise ValueError("`client_id` must be specified in the configuration.")
if not secret:
raise ValueError("`secret` must be specified in the configuration.")
if (scopes is not None and (path_to_key is not None or private_key is not None) and auth_code is not None) \
or (scopes is None and path_to_key is None and private_key is None and auth_code is None):
raise ValueError("either `scopes` needs to be specified or one of `private_key` or `path_to_key` or an `auth_code`")
config_object["org_id"] = org_id
header["x-gw-ims-org-id"] = org_id
config_object["client_id"] = client_id
header["x-api-key"] = client_id
config_object["tech_id"] = tech_id
config_object["secret"] = secret
config_object["pathToKey"] = path_to_key
config_object["private_key"] = private_key
config_object["scopes"] = scopes
config_object["auth_code"] = auth_code
config_object["sandbox"] = sandbox
header["x-sandbox-name"] = sandbox
# ensure we refer to the right environment endpoints
config_object["environment"] = environment
if environment == "prod":
endpoints["global"] = "https://platform.adobe.io"
config_object["imsEndpoint"] = "https://ims-na1.adobelogin.com"
else:
endpoints["global"] = f"https://platform-{environment}.adobe.io"
config_object["imsEndpoint"] = "https://ims-na1-stg1.adobelogin.com"
endpoints["streaming"]["inlet"] = f"{endpoints['global']}/data/core/edge"
config_object["jwtTokenEndpoint"] = f"{config_object['imsEndpoint']}/ims/exchange/jwt"
config_object["oauthTokenEndpointV1"] = f"{config_object['imsEndpoint']}/ims/token/v1"
config_object["oauthTokenEndpointV2"] = f"{config_object['imsEndpoint']}/ims/token/v2"
# ensure the reset of the state by overwriting possible values from previous import.
config_object["date_limit"] = 0
config_object["token"] = ""
if connectInstance:
myInstance = ConnectObject(
org_id=org_id,
tech_id=tech_id,
secret=secret,
client_id=client_id,
path_to_key = path_to_key,
private_key = private_key,
sandbox=sandbox,
scopes=scopes,
auth_code=auth_code
)
return myInstance
def get_private_key_from_config(config: dict) -> str:
"""
Returns the private key directly or read a file to return the private key.
"""
private_key = config.get("private_key")
if private_key is not None:
return private_key
private_key_path = find_path(config["pathToKey"])
if private_key_path is None:
raise FileNotFoundError(
f'Unable to find the private key under path `{config["pathToKey"]}`.'
)
with open(Path(private_key_path), "r") as f:
private_key = f.read()
return private_key
def generateLoggingObject(level:str="WARNING",filename:str="aepp.log") -> dict:
"""
Generates a dictionary for the logging object with basic configuration.
You can find the information for the different possible values on the logging documentation.
https://docs.python.org/3/library/logging.html
Arguments:
level : OPTIONAL : Level of the logger to display information (NOTSET, DEBUG,INFO,WARNING,EROR,CRITICAL)
default WARNING
filename : OPTIONAL : name of the file for debugging. default aepp.log
Output:
level : Level of the logger to display information (NOTSET, DEBUG,INFO,WARNING,EROR,CRITICAL)
stream : If the logger should display print statements
file : If the logger should write the messages to a file
filename : name of the file where log are written
format : format of the logs
"""
myObject = {
"level": level,
"stream": True,
"file": False,
"format": "%(asctime)s::%(name)s::%(funcName)s::%(levelname)s::%(message)s::%(lineno)d",
"filename": filename,
}
return myObject
class ConnectObject:
"""
A connect Object class that keep tracks of the configuration loaded during the importConfigFile operation or during configure operation.
"""
def __init__(self,
org_id: str = None,
tech_id: str = None,
secret: str = None,
client_id: str = None,
path_to_key: str = None,
private_key: str = None,
scopes:str=None,
sandbox: str = "prod",
environment: str = "prod",
auth_code:str=None,
**kwargs)->None:
"""
Take a config object and save the configuration directly in the instance of the class.
"""
self.header = {"Accept": "application/json",
"Content-Type": "application/json",
"Authorization": "",
"x-api-key": client_id,
"x-gw-ims-org-id": org_id,
"x-sandbox-name": sandbox
}
## setting environment prod vs non-prod for token generation
if environment == "prod":
self.globalEndpoint = "https://platform.adobe.io"
self.imsEndpoint = "https://ims-na1.adobelogin.com"
else:
self.globalEndpoint = f"https://platform-{environment}.adobe.io"
self.imsEndpoint = "https://ims-na1-stg1.adobelogin.com"
self.streamInletEndpoint = f"{self.globalEndpoint}/data/core/edge"
self.jwtEndpoint = f"{self.imsEndpoint}/ims/exchange/jwt"
self.oauthEndpointV1 = f"{self.imsEndpoint}/ims/token/v1"
self.oauthEndpointV2 = f"{self.imsEndpoint}/ims/token/v2"
self.org_id = org_id
self.tech_id = tech_id
self.client_id = client_id
self.secret = secret
self.pathToKey = path_to_key
self.privateKey = private_key
self.sandbox = sandbox
self.scopes = scopes
self.token = ""
self.__configObject__ = {
"org_id": self.org_id,
"client_id": self.client_id,
"tech_id": self.tech_id,
"pathToKey": self.pathToKey,
"private_key": self.privateKey,
"secret": self.secret,
"date_limit" : 0,
"sandbox": self.sandbox,
"token": "",
"imsEndpoint" : self.imsEndpoint,
"jwtTokenEndpoint" : self.jwtEndpoint,
"oauthTokenEndpointV1" : self.oauthEndpointV1,
"oauthTokenEndpointV2" : self.oauthEndpointV2,
"scopes": self.scopes
}
def connect(self)->None:
"""
Generate a token and provide a connector instance in that class.
"""
self.connector = connector. | AdobeRequest(self.__configObject__,self.header) |
self.token = self.connector.token
self.header['Authorization'] = 'bearer '+self.token
def getConfigObject(self)->dict:
"""
Return the config object expected.
"""
return self.__configObject__
def getConfigHeader(self)->dict:
"""
Return the default header
"""
return self.header
def setSandbox(self,sandbox:str=None)->dict:
"""
Update the sandbox used
"""
if sandbox is None:
return None
self.sandbox = sandbox
self.header["x-sandbox-name"] = sandbox
self.__configObject__["sandbox"] = sandbox
return self.getConfigObject()
| aepp/configs.py | adobe-aepp-0e23c55 | [
{
"filename": "aepp/accesscontrol.py",
"retrieved_chunk": " header = config.getConfigHeader()\n config = config.getConfigObject()\n self.connector = connector.AdobeRequest(\n config=config,\n header=header,\n loggingEnabled=self.loggingEnabled,\n logger=self.logger,\n )\n if kwargs.get('sandbox',None) is not None: ## supporting sandbox setup on class instanciation\n self.sandbox = kwargs.get('sandbox')",
"score": 0.8148305416107178
},
{
"filename": "aepp/queryservice.py",
"retrieved_chunk": " if type(config) == dict: ## Supporting either default setup or passing a ConnectObject\n config = config\n elif type(config) == ConnectObject:\n header = config.getConfigHeader()\n config = config.getConfigObject()\n self.connector = connector.AdobeRequest(\n config=config,\n header=header,\n loggingEnabled=self.loggingEnabled,\n logger=self.logger,",
"score": 0.8081373572349548
},
{
"filename": "aepp/datasets.py",
"retrieved_chunk": " if type(config) == dict: ## Supporting either default setup or passing a ConnectObject\n config = config\n elif type(config) == ConnectObject:\n header = config.getConfigHeader()\n config = config.getConfigObject()\n self.connector = connector.AdobeRequest(\n config=config,\n header=header,\n loggingEnabled=self.loggingEnabled,\n logger=self.logger,",
"score": 0.8081373572349548
},
{
"filename": "aepp/customerprofile.py",
"retrieved_chunk": " if type(config) == dict: ## Supporting either default setup or passing a ConnectObject\n config = config\n elif type(config) == ConnectObject:\n header = config.getConfigHeader()\n config = config.getConfigObject()\n self.connector = connector.AdobeRequest(\n config=config,\n header=header,\n loggingEnabled=self.loggingEnabled,\n logger=self.logger,",
"score": 0.8081373572349548
},
{
"filename": "aepp/catalog.py",
"retrieved_chunk": " streamHandler = logging.StreamHandler()\n streamHandler.setFormatter(formatter)\n self.logger.addHandler(streamHandler)\n if type(config) == dict: ## Supporting either default setup or passing a ConnectObject\n config = config\n elif type(config) == ConnectObject:\n header = config.getConfigHeader()\n config = config.getConfigObject()\n self.connector = connector.AdobeRequest(\n config=config, ",
"score": 0.7985258102416992
}
] | python | AdobeRequest(self.__configObject__,self.header) |
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
# import fvcore.nn.weight_init as weight_init
from GCoNet_plus.config import Config
config = Config()
class ResBlk(nn.Module):
def __init__(self, channel_in=64, channel_out=64):
super(ResBlk, self).__init__()
self.conv_in = nn.Conv2d(channel_in, 64, 3, 1, 1)
self.relu_in = nn.ReLU(inplace=True)
self.conv_out = nn.Conv2d(64, channel_out, 3, 1, 1)
if config.use_bn:
self.bn_in = nn.BatchNorm2d(64)
self.bn_out = nn.BatchNorm2d(channel_out)
def forward(self, x):
x = self.conv_in(x)
if config.use_bn:
x = self.bn_in(x)
x = self.relu_in(x)
x = self.conv_out(x)
if config.use_bn:
x = self.bn_out(x)
return x
class DSLayer(nn.Module):
def __init__(self, channel_in=64, channel_out=1, activation_out='relu'):
super(DSLayer, self).__init__()
self.activation_out = activation_out
self.conv1 = nn.Conv2d(channel_in, 64, kernel_size=3, stride=1, padding=1)
self.relu1 = nn.ReLU(inplace=True)
self.conv2 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1)
self.relu2 = nn.ReLU(inplace=True)
if activation_out:
self.pred_conv = nn.Conv2d(64, channel_out, kernel_size=1, stride=1, padding=0)
self.pred_relu = nn.ReLU(inplace=True)
else:
self.pred_conv = nn.Conv2d(64, channel_out, kernel_size=1, stride=1, padding=0)
if config.use_bn:
self.bn1 = nn.BatchNorm2d(64)
self.bn2 = nn.BatchNorm2d(64)
self.pred_bn = nn.BatchNorm2d(channel_out)
def forward(self, x):
x = self.conv1(x)
if config.use_bn:
x = self.bn1(x)
x = self.relu1(x)
x = self.conv2(x)
if config.use_bn:
x = self.bn2(x)
x = self.relu2(x)
x = self.pred_conv(x)
if config.use_bn:
x = self.pred_bn(x)
if self.activation_out:
x = self.pred_relu(x)
return x
class half_DSLayer(nn.Module):
def __init__(self, channel_in=512):
super(half_DSLayer, self).__init__()
self.enlayer = nn.Sequential(
nn.Conv2d(channel_in, int(channel_in//4), kernel_size=3, stride=1, padding=1),
nn.ReLU(inplace=True)
)
self.predlayer = nn.Sequential(
nn.Conv2d(int(channel_in//4), 1, kernel_size=1, stride=1, padding=0),
)
def forward(self, x):
x = self.enlayer(x)
x = self.predlayer(x)
return x
class CoAttLayer(nn.Module):
def __init__(self, channel_in=512):
super(CoAttLayer, self).__init__()
self.all_attention = eval(Config().relation_module + '(channel_in)')
self.conv_output = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.conv_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.fc_transform = nn.Linear(channel_in, channel_in)
# for layer in [self.conv_output, self.conv_transform, self.fc_transform]:
# weight_init.c2_msra_fill(layer)
def forward(self, x5):
if self.training:
f_begin = 0
f_end = int(x5.shape[0] / 2)
s_begin = f_end
s_end = int(x5.shape[0])
x5_1 = x5[f_begin: f_end]
x5_2 = x5[s_begin: s_end]
x5_new_1 = self.all_attention(x5_1)
x5_new_2 = self.all_attention(x5_2)
x5_1_proto = torch.mean(x5_new_1, (0, 2, 3), True).view(1, -1)
x5_1_proto = x5_1_proto.unsqueeze(-1).unsqueeze(-1) # 1, C, 1, 1
x5_2_proto = torch.mean(x5_new_2, (0, 2, 3), True).view(1, -1)
x5_2_proto = x5_2_proto.unsqueeze(-1).unsqueeze(-1) # 1, C, 1, 1
x5_11 = x5_1 * x5_1_proto
x5_22 = x5_2 * x5_2_proto
weighted_x5 = torch.cat([x5_11, x5_22], dim=0)
x5_12 = x5_1 * x5_2_proto
x5_21 = x5_2 * x5_1_proto
neg_x5 = torch.cat([x5_12, x5_21], dim=0)
else:
x5_new = self.all_attention(x5)
x5_proto = torch.mean(x5_new, (0, 2, 3), True).view(1, -1)
x5_proto = x5_proto.unsqueeze(-1).unsqueeze(-1) # 1, C, 1, 1
weighted_x5 = x5 * x5_proto #* cweight
neg_x5 = None
return weighted_x5, neg_x5
class ICE(nn.Module):
# The Integrity Channel Enhancement (ICE) module
# _X means in X-th column
def __init__(self, channel_in=512):
super(ICE, self).__init__()
self.conv_1 = nn.Conv2d(channel_in, channel_in, 3, 1, 1)
self.conv_2 = nn.Conv1d(channel_in, channel_in, 3, 1, 1)
self.conv_3 = nn.Conv2d(channel_in*3, channel_in, 3, 1, 1)
self.fc_2 = nn.Linear(channel_in, channel_in)
self.fc_3 = nn.Linear(channel_in, channel_in)
def forward(self, x):
x_1, x_2, x_3 = x, x, x
x_1 = x_1 * x_2 * x_3
x_2 = x_1 + x_2 + x_3
x_3 = torch.cat((x_1, x_2, x_3), dim=1)
V = self.conv_1(x_1)
bs, c, h, w = x_2.shape
K = self.conv_2(x_2.view(bs, c, h*w))
Q_prime = self.conv_3(x_3)
Q_prime = torch.norm(Q_prime, dim=(-2, -1)).view(bs, c, 1, 1)
Q_prime = Q_prime.view(bs, -1)
Q_prime = self.fc_3(Q_prime)
Q_prime = torch.softmax(Q_prime, dim=-1)
Q_prime = Q_prime.unsqueeze(1)
Q = torch.matmul(Q_prime, K)
x_2 = torch.nn.functional.cosine_similarity(K, Q, dim=-1)
x_2 = torch.sigmoid(x_2)
x_2 = self.fc_2(x_2)
x_2 = x_2.unsqueeze(-1).unsqueeze(-1)
x_1 = V * x_2 + V
return x_1
class GAM(nn.Module):
def __init__(self, channel_in=512):
super(GAM, self).__init__()
self.query_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.key_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.scale = 1.0 / (channel_in ** 0.5)
self.conv6 = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
# for layer in [self.query_transform, self.key_transform, self.conv6]:
# weight_init.c2_msra_fill(layer)
def forward(self, x5):
# x: B,C,H,W
# x_query: B,C,HW
B, C, H5, W5 = x5.size()
x_query = self.query_transform(x5).view(B, C, -1)
# x_query: B,HW,C
x_query = torch.transpose(x_query, 1, 2).contiguous().view(-1, C) # BHW, C
# x_key: B,C,HW
x_key = self.key_transform(x5).view(B, C, -1)
x_key = torch.transpose(x_key, 0, 1).contiguous().view(C, -1) # C, BHW
# W = Q^T K: B,HW,HW
x_w = torch.matmul(x_query, x_key) #* self.scale # BHW, BHW
x_w = x_w.view(B*H5*W5, B, H5*W5)
x_w = torch.max(x_w, -1).values # BHW, B
x_w = x_w.mean(-1)
#x_w = torch.mean(x_w, -1).values # BHW
x_w = x_w.view(B, -1) * self.scale # B, HW
x_w = F.softmax(x_w, dim=-1) # B, HW
x_w = x_w.view(B, H5, W5).unsqueeze(1) # B, 1, H, W
x5 = x5 * x_w
x5 = self.conv6(x5)
return x5
class MHA(nn.Module):
'''
Scaled dot-product attention
'''
def __init__(self, d_model=512, d_k=512, d_v=512, h=8, dropout=.1, channel_in=512):
'''
:param d_model: Output dimensionality of the model
:param d_k: Dimensionality of queries and keys
:param d_v: Dimensionality of values
:param h: Number of heads
'''
super(MHA, self).__init__()
self.query_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.key_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.value_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.fc_q = nn.Linear(d_model, h * d_k)
self.fc_k = nn.Linear(d_model, h * d_k)
self.fc_v = nn.Linear(d_model, h * d_v)
self.fc_o = nn.Linear(h * d_v, d_model)
self.dropout = nn.Dropout(dropout)
self.d_model = d_model
self.d_k = d_k
self.d_v = d_v
self.h = h
self.init_weights()
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode='fan_out')
if m.bias is not None:
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.Linear):
nn.init.normal_(m.weight, std=0.001)
if m.bias is not None:
nn.init.constant_(m.bias, 0)
def forward(self, x, attention_mask=None, attention_weights=None):
'''
Computes
:param queries: Queries (b_s, nq, d_model)
:param keys: Keys (b_s, nk, d_model)
:param values: Values (b_s, nk, d_model)
:param attention_mask: Mask over attention values (b_s, h, nq, nk). True indicates masking.
:param attention_weights: Multiplicative weights for attention values (b_s, h, nq, nk).
:return:
'''
B, C, H, W = x.size()
queries = self.query_transform(x).view(B, -1, C)
keys = self.query_transform(x).view(B, -1, C)
values = self.query_transform(x).view(B, -1, C)
b_s, nq = queries.shape[:2]
nk = keys.shape[1]
q = self.fc_q(queries).view(b_s, nq, self.h, self.d_k).permute(0, 2, 1, 3) # (b_s, h, nq, d_k)
k = self.fc_k(keys).view(b_s, nk, self.h, self.d_k).permute(0, 2, 3, 1) # (b_s, h, d_k, nk)
v = self.fc_v(values).view(b_s, nk, self.h, self.d_v).permute(0, 2, 1, 3) # (b_s, h, nk, d_v)
att = torch.matmul(q, k) / np.sqrt(self.d_k) # (b_s, h, nq, nk)
if attention_weights is not None:
att = att * attention_weights
if attention_mask is not None:
att = att.masked_fill(attention_mask, -np.inf)
att = torch.softmax(att, -1)
att = self.dropout(att)
out = torch.matmul(att, v).permute(0, 2, 1, 3).contiguous().view(b_s, nq, self.h * self.d_v) # (b_s, nq, h*d_v)
out = self.fc_o(out).view(B, C, H, W) # (b_s, nq, d_model)
return out
class NonLocal(nn.Module):
def __init__(self, channel_in=512, inter_channels=None, dimension=2, sub_sample=True, bn_layer=True):
super(NonLocal, self).__init__()
assert dimension in [1, 2, 3]
self.dimension = dimension
self.sub_sample = sub_sample
self.channel_in = channel_in
self.inter_channels = inter_channels
if self.inter_channels is None:
self.inter_channels = channel_in // 2
if self.inter_channels == 0:
self.inter_channels = 1
self.g = nn.Conv2d(self.channel_in, self.inter_channels, 1, 1, 0)
if bn_layer:
self.W = nn.Sequential(
nn.Conv2d(self.inter_channels, self.channel_in, kernel_size=1, stride=1, padding=0),
nn.BatchNorm2d(self.channel_in)
)
nn.init.constant_(self.W[1].weight, 0)
nn.init.constant_(self.W[1].bias, 0)
else:
self.W = nn.Conv2d(self.inter_channels, self.channel_in, kernel_size=1, stride=1, padding=0)
nn.init.constant_(self.W.weight, 0)
nn.init.constant_(self.W.bias, 0)
self.theta = nn.Conv2d(self.channel_in, self.inter_channels, kernel_size=1, stride=1, padding=0)
self.phi = nn.Conv2d(self.channel_in, self.inter_channels, kernel_size=1, stride=1, padding=0)
if sub_sample:
self.g = nn.Sequential(self.g, nn.MaxPool2d(kernel_size=(2, 2)))
self.phi = nn.Sequential(self.phi, nn.MaxPool2d(kernel_size=(2, 2)))
def forward(self, x, return_nl_map=False):
"""
:param x: (b, c, t, h, w)
:param return_nl_map: if True return z, nl_map, else only return z.
:return:
"""
batch_size = x.size(0)
g_x = self.g(x).view(batch_size, self.inter_channels, -1)
g_x = g_x.permute(0, 2, 1)
theta_x = self.theta(x).view(batch_size, self.inter_channels, -1)
theta_x = theta_x.permute(0, 2, 1)
phi_x = self.phi(x).view(batch_size, self.inter_channels, -1)
f = torch.matmul(theta_x, phi_x)
f_div_C = F.softmax(f, dim=-1)
y = torch.matmul(f_div_C, g_x)
y = y.permute(0, 2, 1).contiguous()
y = y.view(batch_size, self.inter_channels, *x.size()[2:])
W_y = self.W(y)
z = W_y + x
if return_nl_map:
return z, f_div_C
return z
class DBHead(nn.Module):
def __init__(self, channel_in=32, channel_out=1, k=config. | db_k): |
super().__init__()
self.k = k
self.binarize = nn.Sequential(
nn.Conv2d(channel_in, channel_in, 3, 1, 1),
*[nn.BatchNorm2d(channel_in), nn.ReLU(inplace=True)] if config.use_bn else nn.ReLU(inplace=True),
nn.Conv2d(channel_in, channel_in, 3, 1, 1),
*[nn.BatchNorm2d(channel_in), nn.ReLU(inplace=True)] if config.use_bn else nn.ReLU(inplace=True),
nn.Conv2d(channel_in, channel_out, 1, 1, 0),
nn.Sigmoid()
)
self.thresh = nn.Sequential(
nn.Conv2d(channel_in, channel_in, 3, padding=1),
*[nn.BatchNorm2d(channel_in), nn.ReLU(inplace=True)] if config.use_bn else nn.ReLU(inplace=True),
nn.Conv2d(channel_in, channel_in, 3, 1, 1),
*[nn.BatchNorm2d(channel_in), nn.ReLU(inplace=True)] if config.use_bn else nn.ReLU(inplace=True),
nn.Conv2d(channel_in, channel_out, 1, 1, 0),
nn.Sigmoid()
)
def forward(self, x):
shrink_maps = self.binarize(x)
threshold_maps = self.thresh(x)
binary_maps = self.step_function(shrink_maps, threshold_maps)
return binary_maps
def step_function(self, x, y):
if config.db_k_alpha != 1:
z = x - y
mask_neg_inv = 1 - 2 * (z < 0)
a = torch.exp(-self.k * (torch.pow(z * mask_neg_inv + 1e-16, 1/config.k_alpha) * mask_neg_inv))
else:
a = torch.exp(-self.k * (x - y))
if torch.isinf(a).any():
a = torch.exp(-50 * (x - y))
return torch.reciprocal(1 + a)
class RefUnet(nn.Module):
# Refinement
def __init__(self, in_ch, inc_ch):
super(RefUnet, self).__init__()
self.conv0 = nn.Conv2d(in_ch, inc_ch, 3, padding=1)
self.conv1 = nn.Conv2d(inc_ch, 64, 3, padding=1)
if config.use_bn:
self.bn1 = nn.BatchNorm2d(64)
self.relu1 = nn.ReLU(inplace=True)
self.pool1 = nn.MaxPool2d(2, 2, ceil_mode=True)
self.conv2 = nn.Conv2d(64, 64, 3, padding=1)
if config.use_bn:
self.bn2 = nn.BatchNorm2d(64)
self.relu2 = nn.ReLU(inplace=True)
self.pool2 = nn.MaxPool2d(2, 2, ceil_mode=True)
self.conv3 = nn.Conv2d(64, 64, 3, padding=1)
if config.use_bn:
self.bn3 = nn.BatchNorm2d(64)
self.relu3 = nn.ReLU(inplace=True)
self.pool3 = nn.MaxPool2d(2, 2, ceil_mode=True)
self.conv4 = nn.Conv2d(64, 64, 3, padding=1)
if config.use_bn:
self.bn4 = nn.BatchNorm2d(64)
self.relu4 = nn.ReLU(inplace=True)
self.pool4 = nn.MaxPool2d(2, 2, ceil_mode=True)
#####
self.conv5 = nn.Conv2d(64, 64, 3, padding=1)
if config.use_bn:
self.bn5 = nn.BatchNorm2d(64)
self.relu5 = nn.ReLU(inplace=True)
#####
self.conv_d4 = nn.Conv2d(128, 64, 3, padding=1)
if config.use_bn:
self.bn_d4 = nn.BatchNorm2d(64)
self.relu_d4 = nn.ReLU(inplace=True)
self.conv_d3 = nn.Conv2d(128, 64, 3, padding=1)
if config.use_bn:
self.bn_d3 = nn.BatchNorm2d(64)
self.relu_d3 = nn.ReLU(inplace=True)
self.conv_d2 = nn.Conv2d(128, 64, 3, padding=1)
if config.use_bn:
self.bn_d2 = nn.BatchNorm2d(64)
self.relu_d2 = nn.ReLU(inplace=True)
self.conv_d1 = nn.Conv2d(128, 64, 3, padding=1)
if config.use_bn:
self.bn_d1 = nn.BatchNorm2d(64)
self.relu_d1 = nn.ReLU(inplace=True)
self.conv_d0 = nn.Conv2d(64, 1, 3, padding=1)
self.upscore2 = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
if config.db_output_refiner:
self.db_output_refiner = DBHead(64)
def forward(self, x):
hx = x
hx = self.conv1(self.conv0(hx))
if config.use_bn:
hx = self.bn1(hx)
hx1 = self.relu1(hx)
hx = self.conv2(self.pool1(hx1))
if config.use_bn:
hx = self.bn2(hx)
hx2 = self.relu2(hx)
hx = self.conv3(self.pool2(hx2))
if config.use_bn:
hx = self.bn3(hx)
hx3 = self.relu3(hx)
hx = self.conv4(self.pool3(hx3))
if config.use_bn:
hx = self.bn4(hx)
hx4 = self.relu4(hx)
hx = self.conv5(self.pool4(hx4))
if config.use_bn:
hx = self.bn5(hx)
hx5 = self.relu5(hx)
hx = self.upscore2(hx5)
d4 = self.conv_d4(torch.cat((hx, hx4), 1))
if config.use_bn:
d4 = self.bn_d4(d4)
d4 = self.relu_d4(d4)
hx = self.upscore2(d4)
d3 = self.conv_d3(torch.cat((hx, hx3), 1))
if config.use_bn:
d3 = self.bn_d3(d3)
d3 = self.relu_d3(d3)
hx = self.upscore2(d3)
d2 = self.conv_d2(torch.cat((hx, hx2), 1))
if config.use_bn:
d2 = self.bn_d2(d2)
d2 = self.relu_d2(d2)
hx = self.upscore2(d2)
d1 = self.conv_d1(torch.cat((hx, hx1), 1))
if config.use_bn:
d1 = self.bn_d1(d1)
d1 = self.relu_d1(d1)
if config.db_output_refiner:
x = self.db_output_refiner(d1)
else:
residual = self.conv_d0(d1)
x = x + residual
return x
| GCoNet_plus/models/modules.py | ZhengPeng7-CoSOD_fps_collection-bee3764 | [
{
"filename": "MCCL/models/modules.py",
"retrieved_chunk": " x_proto = torch.mean(x_new, (0, 2, 3), True).view(1, -1)\n x_proto = x_proto.unsqueeze(-1).unsqueeze(-1) # 1, C, 1, 1\n weighted_x = x * x_proto\n return weighted_x\nclass GCAM(nn.Module):\n def __init__(self, channel_in=512):\n super(GCAM, self).__init__()\n self.query_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0) \n self.key_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0) \n self.scale = 1.0 / (channel_in ** 0.5)",
"score": 0.8107492923736572
},
{
"filename": "MCCL/models/modules.py",
"retrieved_chunk": " self.conv6 = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0) \n # for layer in [self.query_transform, self.key_transform, self.conv6]:\n # weight_init.c2_msra_fill(layer)\n def forward(self, x):\n # x: B,C,H,W\n # x_query: B,C,HW\n B, C, H5, W5 = x.size()\n x_query = self.query_transform(x).view(B, C, -1)\n # x_query: B,HW,C\n x_query = torch.transpose(x_query, 1, 2).contiguous().view(-1, C) # BHW, C",
"score": 0.8095340132713318
},
{
"filename": "MCCL/models/modules.py",
"retrieved_chunk": " x5 = F.interpolate(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)\n x = torch.cat((x1, x2, x3, x4, x5), dim=1)\n x = self.conv1(x)\n x = self.bn1(x)\n x = self.relu(x)\n return self.dropout(x)\nclass CoAttLayer(nn.Module):\n def __init__(self, channel_in=512):\n super(CoAttLayer, self).__init__()\n self.all_attention = GCAM(channel_in)",
"score": 0.8090538382530212
},
{
"filename": "MCCL/models/modules.py",
"retrieved_chunk": " self.conv1 = nn.Conv2d(self.channel_inter * 5, channel_in, 1, bias=False)\n self.bn1 = nn.BatchNorm2d(channel_in)\n self.relu = nn.ReLU(inplace=True)\n self.dropout = nn.Dropout(0.5)\n def forward(self, x):\n x1 = self.aspp1(x)\n x2 = self.aspp2(x)\n x3 = self.aspp3(x)\n x4 = self.aspp4(x)\n x5 = self.global_avg_pool(x)",
"score": 0.8071701526641846
},
{
"filename": "CoSOD_CoADNet/code/modules.py",
"retrieved_chunk": " # y: [B, in_channels, fh, fw]\n x_1 = self.conv_1(x) # [B, inter_channels, fh, fw]\n x_2 = self.conv_2(x) # [B, inter_channels, fh, fw]\n x_3 = self.conv_3(x) # [B, inter_channels, fh, fw]\n x_4 = self.conv_4(x) # [B, inter_channels, fh, fw]\n x_f = self.fusion(torch.cat((x_1, x_2, x_3, x_4), dim=1)) # [B, in_channels, fh, fw]\n y = x_f + x\n return y\nclass GCA(nn.Module):\n # Global Context Aggregation",
"score": 0.8062083125114441
}
] | python | db_k): |
from collections import OrderedDict
import torch
from torch.functional import norm
import torch.nn as nn
import torch.nn.functional as F
from torchvision.models import vgg16, vgg16_bn
from torchvision.models import resnet50
from MCCL.models.modules import ResBlk, CoAttLayer
from MCCL.models.pvt import pvt_v2_b2
from MCCL.config import Config
class MCCL(nn.Module):
def __init__(self):
super(MCCL, self).__init__()
self.config = Config()
bb = self.config.bb
if bb == 'cnn-vgg16':
bb_net = list(vgg16(pretrained=False).children())[0]
bb_convs = OrderedDict({
'conv1': bb_net[:4],
'conv2': bb_net[4:9],
'conv3': bb_net[9:16],
'conv4': bb_net[16:23]
})
elif bb == 'cnn-vgg16bn':
bb_net = list(vgg16_bn(pretrained=False).children())[0]
bb_convs = OrderedDict({
'conv1': bb_net[:6],
'conv2': bb_net[6:13],
'conv3': bb_net[13:23],
'conv4': bb_net[23:33]
})
elif bb == 'cnn-resnet50':
bb_net = list(resnet50(pretrained=False).children())
bb_convs = OrderedDict({
'conv1': nn.Sequential(*bb_net[0:3]),
'conv2': bb_net[4],
'conv3': bb_net[5],
'conv4': bb_net[6]
})
elif bb == 'trans-pvt':
self.bb = pvt_v2_b2()
# if self.config.pvt_weights:
# save_model = torch.load(self.config.pvt_weights)
# model_dict = self.bb.state_dict()
# state_dict = {k: v for k, v in save_model.items() if k in model_dict.keys()}
# model_dict.update(state_dict)
# self.bb.load_state_dict(model_dict)
if 'cnn-' in bb:
self.bb = nn.Sequential(bb_convs)
lateral_channels_in = {
'cnn-vgg16': [512, 256, 128, 64],
'cnn-vgg16bn': [512, 256, 128, 64],
'cnn-resnet50': [1024, 512, 256, 64],
'trans-pvt': [512, 320, 128, 64],
}
if self.config. | consensus == 'GCAM': |
self.co_x4 = CoAttLayer(channel_in=lateral_channels_in[bb][0])
elif self.config.consensus == 'SGS':
self.co_x4 = SGS(channel_in=lateral_channels_in[bb][0])
elif self.config.consensus == 'GWM':
self.co_x4 = GWM(channel_in=lateral_channels_in[bb][0])
if self.config.dec_blk == 'ResBlk':
DecBlk = ResBlk
self.top_layer = DecBlk(lateral_channels_in[bb][0], lateral_channels_in[bb][1])
self.dec_layer4 = DecBlk(lateral_channels_in[bb][1], lateral_channels_in[bb][1])
self.lat_layer4 = nn.Conv2d(lateral_channels_in[bb][1], lateral_channels_in[bb][1], 1, 1, 0)
self.dec_layer3 = DecBlk(lateral_channels_in[bb][1], lateral_channels_in[bb][2])
self.lat_layer3 = nn.Conv2d(lateral_channels_in[bb][2], lateral_channels_in[bb][2], 1, 1, 0)
self.dec_layer2 = DecBlk(lateral_channels_in[bb][2], lateral_channels_in[bb][3])
self.lat_layer2 = nn.Conv2d(lateral_channels_in[bb][3], lateral_channels_in[bb][3], 1, 1, 0)
self.dec_layer1 = DecBlk(lateral_channels_in[bb][3], lateral_channels_in[bb][3]//2)
self.conv_out1 = nn.Sequential(nn.Conv2d(lateral_channels_in[bb][3]//2, 1, 1, 1, 0))
def forward(self, x):
########## Encoder ##########
if 'trans' in self.config.bb:
x1, x2, x3, x4 = self.bb(x)
else:
x1 = self.bb.conv1(x)
x2 = self.bb.conv2(x1)
x3 = self.bb.conv3(x2)
x4 = self.bb.conv4(x3)
if self.config.consensus:
x4 = self.co_x4(x4)
p4 = self.top_layer(x4)
########## Decoder ##########
scaled_preds = []
p4 = self.dec_layer4(p4)
p4 = F.interpolate(p4, size=x3.shape[2:], mode='bilinear', align_corners=True)
p3 = p4 + self.lat_layer4(x3)
p3 = self.dec_layer3(p3)
p3 = F.interpolate(p3, size=x2.shape[2:], mode='bilinear', align_corners=True)
p2 = p3 + self.lat_layer3(x2)
p2 = self.dec_layer2(p2)
p2 = F.interpolate(p2, size=x1.shape[2:], mode='bilinear', align_corners=True)
p1 = p2 + self.lat_layer2(x1)
p1 = self.dec_layer1(p1)
p1 = F.interpolate(p1, size=x.shape[2:], mode='bilinear', align_corners=True)
if self.config.db_output_decoder:
p1_out = self.db_output_decoder(p1)
else:
p1_out = self.conv_out1(p1)
scaled_preds.append(p1_out)
if self.training:
return_values = [scaled_preds, x4]
return return_values
else:
return scaled_preds
| MCCL/models/GCoNet.py | ZhengPeng7-CoSOD_fps_collection-bee3764 | [
{
"filename": "GCoNet_plus/models/GCoNet.py",
"retrieved_chunk": " 'conv3': bb_net[13:23],\n 'conv4': bb_net[23:33],\n 'conv5': bb_net[33:43]\n })\n channel_scale = 1\n self.bb = nn.Sequential(bb_convs)\n lateral_channels_in = [512, 512, 256, 128, 64] if 'vgg16' in bb else [2048, 1024, 512, 256, 64]\n # channel_scale_latlayer = channel_scale // 2 if bb == 'resnet50' else 1\n # channel_last = 32\n ch_decoder = lateral_channels_in[0]//2//channel_scale",
"score": 0.9187483191490173
},
{
"filename": "GCoNet_plus/models/GCoNet.py",
"retrieved_chunk": " 'conv3': bb_net[9:16],\n 'conv4': bb_net[16:23],\n 'conv5': bb_net[23:30]\n })\n channel_scale = 1\n elif bb == 'resnet50':\n bb_net = list(resnet50(pretrained=False).children())\n bb_convs = OrderedDict({\n 'conv1': nn.Sequential(*bb_net[0:3]),\n 'conv2': bb_net[4],",
"score": 0.8759037256240845
},
{
"filename": "GCoNet_plus/models/GCoNet.py",
"retrieved_chunk": " 'conv3': bb_net[5],\n 'conv4': bb_net[6],\n 'conv5': bb_net[7]\n })\n channel_scale = 4\n elif bb == 'vgg16bn':\n bb_net = list(vgg16_bn(pretrained=False).children())[0]\n bb_convs = OrderedDict({\n 'conv1': bb_net[:6],\n 'conv2': bb_net[6:13],",
"score": 0.8723729848861694
},
{
"filename": "CoSOD_CoADNet/code/backbone.py",
"retrieved_chunk": " self.C3 = nn.Sequential()\n self.C4 = nn.Sequential()\n self.C5 = nn.Sequential()\n for layer_index, (name, sub_module) in enumerate(bb.named_children()):\n if layer_index>=0 and layer_index<=5:\n self.C1.add_module(name, sub_module) \n if layer_index>=7 and layer_index <= 12:\n self.C2.add_module(name, sub_module)\n if layer_index>=14 and layer_index <= 22:\n self.C3.add_module(name, sub_module)",
"score": 0.8597874641418457
},
{
"filename": "GCoNet_plus/models/GCoNet.py",
"retrieved_chunk": "class GCoNet_plus(nn.Module):\n def __init__(self):\n super(GCoNet_plus, self).__init__()\n self.config = Config()\n bb = self.config.bb\n if bb == 'vgg16':\n bb_net = list(vgg16(pretrained=False).children())[0]\n bb_convs = OrderedDict({\n 'conv1': bb_net[:4],\n 'conv2': bb_net[4:9],",
"score": 0.8442018032073975
}
] | python | consensus == 'GCAM': |
# Copyright 2023 Adobe. All rights reserved.
# This file is licensed to you 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 REPRESENTATIONS
# OF ANY KIND, either express or implied. See the License for the specific language
# governing permissions and limitations under the License.
from aepp.destinationinstanceservice import DestinationInstanceService
import unittest
from unittest.mock import patch, MagicMock, ANY
class DestinationInstanceServiceTest(unittest.TestCase):
ADHOC_INPUT = {"flow1": ["dataset1"], "flow2": ["dataset2", "dataset3"]}
ADHOC_EXPECTED_PAYLOAD = {'activationInfo': {'destinations': [{'flowId': 'flow1', 'datasets': [{'id': 'dataset1'}]}, {'flowId': 'flow2', 'datasets': [{'id': 'dataset2'}, {'id': 'dataset3'}]}]}}
@patch("aepp.connector.AdobeRequest")
def test_create_adhoc_dataset_export(self, mock_connector):
instance_conn = mock_connector.return_value
instance_conn.postData.return_value = {'foo'}
destination_instance_service_obj = DestinationInstanceService()
result = destination_instance_service_obj. | createAdHocDatasetExport(self.ADHOC_INPUT) |
assert(result is not None)
instance_conn.postData.assert_called_once()
instance_conn.postData.assert_called_with(ANY, data=self.ADHOC_EXPECTED_PAYLOAD)
@patch("aepp.connector.AdobeRequest")
def test_create_adhoc_dataset_export_invalid_input(self, mock_connector):
destination_instance_service_obj = DestinationInstanceService()
with self.assertRaises(Exception) as cm:
destination_instance_service_obj.createAdHocDatasetExport(None)
self.assertEqual('Require a dict for defining the flowId to datasetIds mapping', str(cm.exception))
| tests/destinationinstanceservice_test.py | adobe-aepp-0e23c55 | [
{
"filename": "tests/exportDatasetToDatalandingZone_test.py",
"retrieved_chunk": " @patch('aepp.destinationinstanceservice.DestinationInstanceService.createAdHocDatasetExport', MagicMock(return_value = adhoc_success_response))\n @patch(\"aepp.connector.AdobeRequest\", MagicMock())\n def test_create_dataflow_if_exist(self):\n export_obj = ExportDatasetToDataLandingZone(config= self.config, header= MagicMock())\n export_obj.createDataFlowRunIfNotExists(dataset_id=\"test\", compression_type=\"gzip\", data_format=\"parquet\", export_path=\"test\", on_schedule=False, config_path=\"test\", entity_name=\"test\", initial_delay=0)\n @patch('aepp.utils.Utils.check_if_exists', MagicMock(return_value = \"test_dataflow_id\"))\n @patch('aepp.flowservice.FlowService.getFlow', MagicMock(return_value = flow_response))\n @patch('aepp.flowservice.FlowService.getSourceConnection', MagicMock(return_value = source_connection))\n @patch(\"aepp.connector.AdobeRequest\", MagicMock())\n def test_create_dataflow_on_schedule(self):",
"score": 0.8831396698951721
},
{
"filename": "tests/exportDatasetToDatalandingZone_test.py",
"retrieved_chunk": " export_obj = ExportDatasetToDataLandingZone(config= self.config, header= MagicMock())\n return_dataflow_id = export_obj.createDataFlow(dataset_id=\"test\", compression_type=\"gzip\", data_format=\"parquet\", export_path=\"test\", on_schedule=False, config_path=\"test\", entity_name=\"test\")\n assert (return_dataflow_id == self.flow_response[\"id\"])\n @patch('aepp.destinationinstanceservice.DestinationInstanceService.createAdHocDatasetExport', MagicMock(return_value = adhoc_success_response))\n @patch(\"aepp.connector.AdobeRequest\", MagicMock())\n def test_retry_on_success_response(self):\n export_obj = ExportDatasetToDataLandingZone(config= self.config, header= MagicMock())\n assert(export_obj.retryOnNotReadyException(\"test\", \"test\", 1, 1) == self.adhoc_success_response)\n @patch('aepp.destinationinstanceservice.DestinationInstanceService.createAdHocDatasetExport', MagicMock(return_value = adhoc_non_retry_error))\n @patch(\"aepp.connector.AdobeRequest\", MagicMock())",
"score": 0.8818791508674622
},
{
"filename": "tests/exportDatasetToDatalandingZone_test.py",
"retrieved_chunk": "import unittest\nfrom unittest.mock import patch, MagicMock, ANY\nfrom tenacity import RetryError\nclass ExportDatasetToDataLandingZoneTest(unittest.TestCase):\n flow_response = {\n \"id\": \"df193495-9837-407f-9d50-e51efc067cb5\",\n \"sourceConnectionIds\": [\n \"78754315-852c-4c4e-8f1a-d12b83264f3f\"\n ],\n \"state\": \"disabled\",",
"score": 0.8416320085525513
},
{
"filename": "tests/exportDatasetToDatalandingZone_test.py",
"retrieved_chunk": " export_obj = ExportDatasetToDataLandingZone(config= self.config, header= MagicMock())\n export_obj.createDataFlowRunIfNotExists(dataset_id=\"test\", compression_type=\"gzip\", data_format=\"parquet\", export_path=\"test\", on_schedule=True, config_path=\"test\",entity_name=\"test\", initial_delay=0)\n @patch('aepp.flowservice.FlowService.createConnection', MagicMock(return_value = base_connection))\n @patch('aepp.flowservice.FlowService.getConnectionSpecIdFromName', MagicMock(return_value = connection_spec))\n @patch('aepp.flowservice.FlowService.createSourceConnection', MagicMock(return_value = source_connection))\n @patch('aepp.flowservice.FlowService.createTargetConnection', MagicMock(return_value = target_connection))\n @patch('aepp.flowservice.FlowService.createFlow', MagicMock(return_value = flow_response))\n @patch('aepp.utils.Utils.save_field_in_config', MagicMock())\n @patch(\"aepp.connector.AdobeRequest\", MagicMock())\n def test_create_dataflow_if_not_exist(self):",
"score": 0.8406018018722534
},
{
"filename": "tests/exportDatasetToDatalandingZone_test.py",
"retrieved_chunk": " def test_no_retry_error(self):\n export_obj = ExportDatasetToDataLandingZone(config= self.config, header= MagicMock())\n assert (export_obj.retryOnNotReadyException(\"test\", \"test\", 1, 1) == self.adhoc_non_retry_error)\n @patch('aepp.destinationinstanceservice.DestinationInstanceService.createAdHocDatasetExport', MagicMock(return_value = adhoc_retry_error))\n @patch(\"aepp.connector.AdobeRequest\", MagicMock())\n def test_retry_error(self):\n export_obj = ExportDatasetToDataLandingZone(config= self.config, header= MagicMock())\n try:\n export_obj.retryOnNotReadyException(\"test\", \"test\", 1, 1)\n self.fail(\"expect a retry error\")",
"score": 0.8366949558258057
}
] | python | createAdHocDatasetExport(self.ADHOC_INPUT) |
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
# import fvcore.nn.weight_init as weight_init
from GCoNet_plus.config import Config
config = Config()
class ResBlk(nn.Module):
def __init__(self, channel_in=64, channel_out=64):
super(ResBlk, self).__init__()
self.conv_in = nn.Conv2d(channel_in, 64, 3, 1, 1)
self.relu_in = nn.ReLU(inplace=True)
self.conv_out = nn.Conv2d(64, channel_out, 3, 1, 1)
if config.use_bn:
self.bn_in = nn.BatchNorm2d(64)
self.bn_out = nn.BatchNorm2d(channel_out)
def forward(self, x):
x = self.conv_in(x)
if config.use_bn:
x = self.bn_in(x)
x = self.relu_in(x)
x = self.conv_out(x)
if config.use_bn:
x = self.bn_out(x)
return x
class DSLayer(nn.Module):
def __init__(self, channel_in=64, channel_out=1, activation_out='relu'):
super(DSLayer, self).__init__()
self.activation_out = activation_out
self.conv1 = nn.Conv2d(channel_in, 64, kernel_size=3, stride=1, padding=1)
self.relu1 = nn.ReLU(inplace=True)
self.conv2 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1)
self.relu2 = nn.ReLU(inplace=True)
if activation_out:
self.pred_conv = nn.Conv2d(64, channel_out, kernel_size=1, stride=1, padding=0)
self.pred_relu = nn.ReLU(inplace=True)
else:
self.pred_conv = nn.Conv2d(64, channel_out, kernel_size=1, stride=1, padding=0)
if config.use_bn:
self.bn1 = nn.BatchNorm2d(64)
self.bn2 = nn.BatchNorm2d(64)
self.pred_bn = nn.BatchNorm2d(channel_out)
def forward(self, x):
x = self.conv1(x)
if config.use_bn:
x = self.bn1(x)
x = self.relu1(x)
x = self.conv2(x)
if config.use_bn:
x = self.bn2(x)
x = self.relu2(x)
x = self.pred_conv(x)
if config.use_bn:
x = self.pred_bn(x)
if self.activation_out:
x = self.pred_relu(x)
return x
class half_DSLayer(nn.Module):
def __init__(self, channel_in=512):
super(half_DSLayer, self).__init__()
self.enlayer = nn.Sequential(
nn.Conv2d(channel_in, int(channel_in//4), kernel_size=3, stride=1, padding=1),
nn.ReLU(inplace=True)
)
self.predlayer = nn.Sequential(
nn.Conv2d(int(channel_in//4), 1, kernel_size=1, stride=1, padding=0),
)
def forward(self, x):
x = self.enlayer(x)
x = self.predlayer(x)
return x
class CoAttLayer(nn.Module):
def __init__(self, channel_in=512):
super(CoAttLayer, self).__init__()
self.all_attention = eval(Config(). | relation_module + '(channel_in)') |
self.conv_output = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.conv_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.fc_transform = nn.Linear(channel_in, channel_in)
# for layer in [self.conv_output, self.conv_transform, self.fc_transform]:
# weight_init.c2_msra_fill(layer)
def forward(self, x5):
if self.training:
f_begin = 0
f_end = int(x5.shape[0] / 2)
s_begin = f_end
s_end = int(x5.shape[0])
x5_1 = x5[f_begin: f_end]
x5_2 = x5[s_begin: s_end]
x5_new_1 = self.all_attention(x5_1)
x5_new_2 = self.all_attention(x5_2)
x5_1_proto = torch.mean(x5_new_1, (0, 2, 3), True).view(1, -1)
x5_1_proto = x5_1_proto.unsqueeze(-1).unsqueeze(-1) # 1, C, 1, 1
x5_2_proto = torch.mean(x5_new_2, (0, 2, 3), True).view(1, -1)
x5_2_proto = x5_2_proto.unsqueeze(-1).unsqueeze(-1) # 1, C, 1, 1
x5_11 = x5_1 * x5_1_proto
x5_22 = x5_2 * x5_2_proto
weighted_x5 = torch.cat([x5_11, x5_22], dim=0)
x5_12 = x5_1 * x5_2_proto
x5_21 = x5_2 * x5_1_proto
neg_x5 = torch.cat([x5_12, x5_21], dim=0)
else:
x5_new = self.all_attention(x5)
x5_proto = torch.mean(x5_new, (0, 2, 3), True).view(1, -1)
x5_proto = x5_proto.unsqueeze(-1).unsqueeze(-1) # 1, C, 1, 1
weighted_x5 = x5 * x5_proto #* cweight
neg_x5 = None
return weighted_x5, neg_x5
class ICE(nn.Module):
# The Integrity Channel Enhancement (ICE) module
# _X means in X-th column
def __init__(self, channel_in=512):
super(ICE, self).__init__()
self.conv_1 = nn.Conv2d(channel_in, channel_in, 3, 1, 1)
self.conv_2 = nn.Conv1d(channel_in, channel_in, 3, 1, 1)
self.conv_3 = nn.Conv2d(channel_in*3, channel_in, 3, 1, 1)
self.fc_2 = nn.Linear(channel_in, channel_in)
self.fc_3 = nn.Linear(channel_in, channel_in)
def forward(self, x):
x_1, x_2, x_3 = x, x, x
x_1 = x_1 * x_2 * x_3
x_2 = x_1 + x_2 + x_3
x_3 = torch.cat((x_1, x_2, x_3), dim=1)
V = self.conv_1(x_1)
bs, c, h, w = x_2.shape
K = self.conv_2(x_2.view(bs, c, h*w))
Q_prime = self.conv_3(x_3)
Q_prime = torch.norm(Q_prime, dim=(-2, -1)).view(bs, c, 1, 1)
Q_prime = Q_prime.view(bs, -1)
Q_prime = self.fc_3(Q_prime)
Q_prime = torch.softmax(Q_prime, dim=-1)
Q_prime = Q_prime.unsqueeze(1)
Q = torch.matmul(Q_prime, K)
x_2 = torch.nn.functional.cosine_similarity(K, Q, dim=-1)
x_2 = torch.sigmoid(x_2)
x_2 = self.fc_2(x_2)
x_2 = x_2.unsqueeze(-1).unsqueeze(-1)
x_1 = V * x_2 + V
return x_1
class GAM(nn.Module):
def __init__(self, channel_in=512):
super(GAM, self).__init__()
self.query_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.key_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.scale = 1.0 / (channel_in ** 0.5)
self.conv6 = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
# for layer in [self.query_transform, self.key_transform, self.conv6]:
# weight_init.c2_msra_fill(layer)
def forward(self, x5):
# x: B,C,H,W
# x_query: B,C,HW
B, C, H5, W5 = x5.size()
x_query = self.query_transform(x5).view(B, C, -1)
# x_query: B,HW,C
x_query = torch.transpose(x_query, 1, 2).contiguous().view(-1, C) # BHW, C
# x_key: B,C,HW
x_key = self.key_transform(x5).view(B, C, -1)
x_key = torch.transpose(x_key, 0, 1).contiguous().view(C, -1) # C, BHW
# W = Q^T K: B,HW,HW
x_w = torch.matmul(x_query, x_key) #* self.scale # BHW, BHW
x_w = x_w.view(B*H5*W5, B, H5*W5)
x_w = torch.max(x_w, -1).values # BHW, B
x_w = x_w.mean(-1)
#x_w = torch.mean(x_w, -1).values # BHW
x_w = x_w.view(B, -1) * self.scale # B, HW
x_w = F.softmax(x_w, dim=-1) # B, HW
x_w = x_w.view(B, H5, W5).unsqueeze(1) # B, 1, H, W
x5 = x5 * x_w
x5 = self.conv6(x5)
return x5
class MHA(nn.Module):
'''
Scaled dot-product attention
'''
def __init__(self, d_model=512, d_k=512, d_v=512, h=8, dropout=.1, channel_in=512):
'''
:param d_model: Output dimensionality of the model
:param d_k: Dimensionality of queries and keys
:param d_v: Dimensionality of values
:param h: Number of heads
'''
super(MHA, self).__init__()
self.query_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.key_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.value_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.fc_q = nn.Linear(d_model, h * d_k)
self.fc_k = nn.Linear(d_model, h * d_k)
self.fc_v = nn.Linear(d_model, h * d_v)
self.fc_o = nn.Linear(h * d_v, d_model)
self.dropout = nn.Dropout(dropout)
self.d_model = d_model
self.d_k = d_k
self.d_v = d_v
self.h = h
self.init_weights()
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode='fan_out')
if m.bias is not None:
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.Linear):
nn.init.normal_(m.weight, std=0.001)
if m.bias is not None:
nn.init.constant_(m.bias, 0)
def forward(self, x, attention_mask=None, attention_weights=None):
'''
Computes
:param queries: Queries (b_s, nq, d_model)
:param keys: Keys (b_s, nk, d_model)
:param values: Values (b_s, nk, d_model)
:param attention_mask: Mask over attention values (b_s, h, nq, nk). True indicates masking.
:param attention_weights: Multiplicative weights for attention values (b_s, h, nq, nk).
:return:
'''
B, C, H, W = x.size()
queries = self.query_transform(x).view(B, -1, C)
keys = self.query_transform(x).view(B, -1, C)
values = self.query_transform(x).view(B, -1, C)
b_s, nq = queries.shape[:2]
nk = keys.shape[1]
q = self.fc_q(queries).view(b_s, nq, self.h, self.d_k).permute(0, 2, 1, 3) # (b_s, h, nq, d_k)
k = self.fc_k(keys).view(b_s, nk, self.h, self.d_k).permute(0, 2, 3, 1) # (b_s, h, d_k, nk)
v = self.fc_v(values).view(b_s, nk, self.h, self.d_v).permute(0, 2, 1, 3) # (b_s, h, nk, d_v)
att = torch.matmul(q, k) / np.sqrt(self.d_k) # (b_s, h, nq, nk)
if attention_weights is not None:
att = att * attention_weights
if attention_mask is not None:
att = att.masked_fill(attention_mask, -np.inf)
att = torch.softmax(att, -1)
att = self.dropout(att)
out = torch.matmul(att, v).permute(0, 2, 1, 3).contiguous().view(b_s, nq, self.h * self.d_v) # (b_s, nq, h*d_v)
out = self.fc_o(out).view(B, C, H, W) # (b_s, nq, d_model)
return out
class NonLocal(nn.Module):
def __init__(self, channel_in=512, inter_channels=None, dimension=2, sub_sample=True, bn_layer=True):
super(NonLocal, self).__init__()
assert dimension in [1, 2, 3]
self.dimension = dimension
self.sub_sample = sub_sample
self.channel_in = channel_in
self.inter_channels = inter_channels
if self.inter_channels is None:
self.inter_channels = channel_in // 2
if self.inter_channels == 0:
self.inter_channels = 1
self.g = nn.Conv2d(self.channel_in, self.inter_channels, 1, 1, 0)
if bn_layer:
self.W = nn.Sequential(
nn.Conv2d(self.inter_channels, self.channel_in, kernel_size=1, stride=1, padding=0),
nn.BatchNorm2d(self.channel_in)
)
nn.init.constant_(self.W[1].weight, 0)
nn.init.constant_(self.W[1].bias, 0)
else:
self.W = nn.Conv2d(self.inter_channels, self.channel_in, kernel_size=1, stride=1, padding=0)
nn.init.constant_(self.W.weight, 0)
nn.init.constant_(self.W.bias, 0)
self.theta = nn.Conv2d(self.channel_in, self.inter_channels, kernel_size=1, stride=1, padding=0)
self.phi = nn.Conv2d(self.channel_in, self.inter_channels, kernel_size=1, stride=1, padding=0)
if sub_sample:
self.g = nn.Sequential(self.g, nn.MaxPool2d(kernel_size=(2, 2)))
self.phi = nn.Sequential(self.phi, nn.MaxPool2d(kernel_size=(2, 2)))
def forward(self, x, return_nl_map=False):
"""
:param x: (b, c, t, h, w)
:param return_nl_map: if True return z, nl_map, else only return z.
:return:
"""
batch_size = x.size(0)
g_x = self.g(x).view(batch_size, self.inter_channels, -1)
g_x = g_x.permute(0, 2, 1)
theta_x = self.theta(x).view(batch_size, self.inter_channels, -1)
theta_x = theta_x.permute(0, 2, 1)
phi_x = self.phi(x).view(batch_size, self.inter_channels, -1)
f = torch.matmul(theta_x, phi_x)
f_div_C = F.softmax(f, dim=-1)
y = torch.matmul(f_div_C, g_x)
y = y.permute(0, 2, 1).contiguous()
y = y.view(batch_size, self.inter_channels, *x.size()[2:])
W_y = self.W(y)
z = W_y + x
if return_nl_map:
return z, f_div_C
return z
class DBHead(nn.Module):
def __init__(self, channel_in=32, channel_out=1, k=config.db_k):
super().__init__()
self.k = k
self.binarize = nn.Sequential(
nn.Conv2d(channel_in, channel_in, 3, 1, 1),
*[nn.BatchNorm2d(channel_in), nn.ReLU(inplace=True)] if config.use_bn else nn.ReLU(inplace=True),
nn.Conv2d(channel_in, channel_in, 3, 1, 1),
*[nn.BatchNorm2d(channel_in), nn.ReLU(inplace=True)] if config.use_bn else nn.ReLU(inplace=True),
nn.Conv2d(channel_in, channel_out, 1, 1, 0),
nn.Sigmoid()
)
self.thresh = nn.Sequential(
nn.Conv2d(channel_in, channel_in, 3, padding=1),
*[nn.BatchNorm2d(channel_in), nn.ReLU(inplace=True)] if config.use_bn else nn.ReLU(inplace=True),
nn.Conv2d(channel_in, channel_in, 3, 1, 1),
*[nn.BatchNorm2d(channel_in), nn.ReLU(inplace=True)] if config.use_bn else nn.ReLU(inplace=True),
nn.Conv2d(channel_in, channel_out, 1, 1, 0),
nn.Sigmoid()
)
def forward(self, x):
shrink_maps = self.binarize(x)
threshold_maps = self.thresh(x)
binary_maps = self.step_function(shrink_maps, threshold_maps)
return binary_maps
def step_function(self, x, y):
if config.db_k_alpha != 1:
z = x - y
mask_neg_inv = 1 - 2 * (z < 0)
a = torch.exp(-self.k * (torch.pow(z * mask_neg_inv + 1e-16, 1/config.k_alpha) * mask_neg_inv))
else:
a = torch.exp(-self.k * (x - y))
if torch.isinf(a).any():
a = torch.exp(-50 * (x - y))
return torch.reciprocal(1 + a)
class RefUnet(nn.Module):
# Refinement
def __init__(self, in_ch, inc_ch):
super(RefUnet, self).__init__()
self.conv0 = nn.Conv2d(in_ch, inc_ch, 3, padding=1)
self.conv1 = nn.Conv2d(inc_ch, 64, 3, padding=1)
if config.use_bn:
self.bn1 = nn.BatchNorm2d(64)
self.relu1 = nn.ReLU(inplace=True)
self.pool1 = nn.MaxPool2d(2, 2, ceil_mode=True)
self.conv2 = nn.Conv2d(64, 64, 3, padding=1)
if config.use_bn:
self.bn2 = nn.BatchNorm2d(64)
self.relu2 = nn.ReLU(inplace=True)
self.pool2 = nn.MaxPool2d(2, 2, ceil_mode=True)
self.conv3 = nn.Conv2d(64, 64, 3, padding=1)
if config.use_bn:
self.bn3 = nn.BatchNorm2d(64)
self.relu3 = nn.ReLU(inplace=True)
self.pool3 = nn.MaxPool2d(2, 2, ceil_mode=True)
self.conv4 = nn.Conv2d(64, 64, 3, padding=1)
if config.use_bn:
self.bn4 = nn.BatchNorm2d(64)
self.relu4 = nn.ReLU(inplace=True)
self.pool4 = nn.MaxPool2d(2, 2, ceil_mode=True)
#####
self.conv5 = nn.Conv2d(64, 64, 3, padding=1)
if config.use_bn:
self.bn5 = nn.BatchNorm2d(64)
self.relu5 = nn.ReLU(inplace=True)
#####
self.conv_d4 = nn.Conv2d(128, 64, 3, padding=1)
if config.use_bn:
self.bn_d4 = nn.BatchNorm2d(64)
self.relu_d4 = nn.ReLU(inplace=True)
self.conv_d3 = nn.Conv2d(128, 64, 3, padding=1)
if config.use_bn:
self.bn_d3 = nn.BatchNorm2d(64)
self.relu_d3 = nn.ReLU(inplace=True)
self.conv_d2 = nn.Conv2d(128, 64, 3, padding=1)
if config.use_bn:
self.bn_d2 = nn.BatchNorm2d(64)
self.relu_d2 = nn.ReLU(inplace=True)
self.conv_d1 = nn.Conv2d(128, 64, 3, padding=1)
if config.use_bn:
self.bn_d1 = nn.BatchNorm2d(64)
self.relu_d1 = nn.ReLU(inplace=True)
self.conv_d0 = nn.Conv2d(64, 1, 3, padding=1)
self.upscore2 = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
if config.db_output_refiner:
self.db_output_refiner = DBHead(64)
def forward(self, x):
hx = x
hx = self.conv1(self.conv0(hx))
if config.use_bn:
hx = self.bn1(hx)
hx1 = self.relu1(hx)
hx = self.conv2(self.pool1(hx1))
if config.use_bn:
hx = self.bn2(hx)
hx2 = self.relu2(hx)
hx = self.conv3(self.pool2(hx2))
if config.use_bn:
hx = self.bn3(hx)
hx3 = self.relu3(hx)
hx = self.conv4(self.pool3(hx3))
if config.use_bn:
hx = self.bn4(hx)
hx4 = self.relu4(hx)
hx = self.conv5(self.pool4(hx4))
if config.use_bn:
hx = self.bn5(hx)
hx5 = self.relu5(hx)
hx = self.upscore2(hx5)
d4 = self.conv_d4(torch.cat((hx, hx4), 1))
if config.use_bn:
d4 = self.bn_d4(d4)
d4 = self.relu_d4(d4)
hx = self.upscore2(d4)
d3 = self.conv_d3(torch.cat((hx, hx3), 1))
if config.use_bn:
d3 = self.bn_d3(d3)
d3 = self.relu_d3(d3)
hx = self.upscore2(d3)
d2 = self.conv_d2(torch.cat((hx, hx2), 1))
if config.use_bn:
d2 = self.bn_d2(d2)
d2 = self.relu_d2(d2)
hx = self.upscore2(d2)
d1 = self.conv_d1(torch.cat((hx, hx1), 1))
if config.use_bn:
d1 = self.bn_d1(d1)
d1 = self.relu_d1(d1)
if config.db_output_refiner:
x = self.db_output_refiner(d1)
else:
residual = self.conv_d0(d1)
x = x + residual
return x
| GCoNet_plus/models/modules.py | ZhengPeng7-CoSOD_fps_collection-bee3764 | [
{
"filename": "MCCL/models/modules.py",
"retrieved_chunk": " x5 = F.interpolate(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)\n x = torch.cat((x1, x2, x3, x4, x5), dim=1)\n x = self.conv1(x)\n x = self.bn1(x)\n x = self.relu(x)\n return self.dropout(x)\nclass CoAttLayer(nn.Module):\n def __init__(self, channel_in=512):\n super(CoAttLayer, self).__init__()\n self.all_attention = GCAM(channel_in)",
"score": 0.9103944301605225
},
{
"filename": "DCFM/models/main.py",
"retrieved_chunk": " nn.ReLU(inplace=True),\n )\n self.predlayer = nn.Sequential(\n nn.Conv2d(int(in_channel/4), 1, kernel_size=1, stride=1, padding=0)) #, nn.Sigmoid())\n def forward(self, x):\n x = self.enlayer(x)\n x = self.predlayer(x)\n return x\nclass AugAttentionModule(nn.Module):\n def __init__(self, input_channels=512):",
"score": 0.8883935213088989
},
{
"filename": "GCoNet/models/GCoNet.py",
"retrieved_chunk": " return x5\nclass CoAttLayer(nn.Module):\n def __init__(self, input_channels=512):\n super(CoAttLayer, self).__init__()\n self.all_attention = AllAttLayer(input_channels)\n self.conv_output = Conv2d(input_channels, input_channels, kernel_size=1, stride=1, padding=0) \n self.conv_transform = Conv2d(input_channels, input_channels, kernel_size=1, stride=1, padding=0) \n self.fc_transform = nn.Linear(input_channels, input_channels)\n # for layer in [self.conv_output, self.conv_transform, self.fc_transform]:\n # weight_init.c2_msra_fill(layer)",
"score": 0.8847471475601196
},
{
"filename": "GCoNet/models/GCoNet.py",
"retrieved_chunk": " nn.ReLU(inplace=True),\n #nn.Conv2d(int(in_channel/2), int(in_channel/4), kernel_size=3, stride=1, padding=1),\n #nn.ReLU(inplace=True),\n )\n self.predlayer = nn.Sequential(\n nn.Conv2d(int(in_channel/4), 1, kernel_size=1, stride=1, padding=0)) #, nn.Sigmoid())\n def forward(self, x):\n x = self.enlayer(x)\n x = self.predlayer(x)\n return x",
"score": 0.8665249347686768
},
{
"filename": "MCCL/models/modules.py",
"retrieved_chunk": " super(ResBlk, self).__init__()\n self.conv_in = nn.Conv2d(channel_in, 64, 3, 1, 1)\n self.relu_in = nn.ReLU(inplace=True)\n if config.dec_att == 'ASPP':\n self.dec_att = ASPP(channel_in=64)\n self.conv_out = nn.Conv2d(64, channel_out, 3, 1, 1)\n if config.use_bn:\n self.bn_in = nn.BatchNorm2d(64)\n self.bn_out = nn.BatchNorm2d(channel_out)\n def forward(self, x):",
"score": 0.8509728312492371
}
] | python | relation_module + '(channel_in)') |
# Copyright 2023 Adobe. All rights reserved.
# This file is licensed to you 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 REPRESENTATIONS
# OF ANY KIND, either express or implied. See the License for the specific language
# governing permissions and limitations under the License.
from aepp.exportDatasetToDataLandingZone import ExportDatasetToDataLandingZone
import unittest
from unittest.mock import patch, MagicMock, ANY
from tenacity import RetryError
class ExportDatasetToDataLandingZoneTest(unittest.TestCase):
flow_response = {
"id": "df193495-9837-407f-9d50-e51efc067cb5",
"sourceConnectionIds": [
"78754315-852c-4c4e-8f1a-d12b83264f3f"
],
"state": "disabled",
"etag": "test_etag"}
connection_spec = {
"name": "test",
"id": "test_connection_id"
}
source_connection = {
"id": "test_source_connection_id",
"params": {
"datasets": [{
"dataSetId": "test"
}]}
}
base_connection = {
"id": "test_base_connection_id"
}
target_connection = {
"id": "test_target_connection_id"
}
flow_run = {
"items": [
{
"id": "test_id",
"metrics": {
"durationSummary": {
"startedAtUTC": 1691184699,
"completedAtUTC": 1691184819
},
"fileSummary": {
"outputFileCount": 24
},
"sizeSummary": {
"outputBytes": 77494320
},
"recordSummary": {
"outputRecordCount": 1065802
}
}
}
]
}
adhoc_success_response = {
"destinations":[
{
"datasets":[
{
"id":"641ce00b8f31811b98dd3b56",
"statusURL":"https: //platform-stage.adobe.io/data/foundation/flowservice/runs/aa39ad3d-24ba-4579-9cdc-55536c408721",
"flowId":"3eaa2c0b-e24b-46bd-8eee-bbaf9d6cf2cb"
}
]
}
]
}
adhoc_non_retry_error = {
"error_code": "401013",
"message": "Oauth token is not valid"
}
adhoc_retry_error = {
"message": "Following order ID(s) are not ready for dataset export"
}
config = {
"org_id": "3ADF23C463D98F640A494032@AdobeOrg",
"client_id": "35e6e4d205274c4ca1418805ac41153b",
"tech_id": "test005@techacct.adobe.com",
"pathToKey": "/Users/Downloads/config/private.key",
"auth_code": "",
"secret": "test",
"date_limit": 0,
"sandbox": "prod",
"environment": "stage",
"token": "token",
"jwtTokenEndpoint": "https://ims-na1.adobelogin.com/ims/exchange/jwt/",
"oauthTokenEndpoint": "",
"imsEndpoint": "https://ims-na1-stg1.adobelogin.com",
"private_key": ""
}
@patch('aepp.utils.Utils.check_if_exists', MagicMock(return_value = "test_dataflow_id"))
@patch('aepp.flowservice.FlowService.getFlow', MagicMock(return_value = flow_response))
@patch('aepp.flowservice.FlowService.getSourceConnection', MagicMock(return_value = source_connection))
@patch('aepp.flowservice.FlowService.getRun', MagicMock(return_value = flow_run))
@patch('aepp.destinationinstanceservice.DestinationInstanceService.createAdHocDatasetExport', MagicMock(return_value = adhoc_success_response))
@patch("aepp.connector.AdobeRequest", MagicMock())
def test_create_dataflow_if_exist(self):
export_obj = ExportDatasetToDataLandingZone(config= self.config, header= MagicMock())
export_obj.createDataFlowRunIfNotExists(dataset_id="test", compression_type="gzip", data_format="parquet", export_path="test", on_schedule=False, config_path="test", entity_name="test", initial_delay=0)
@patch('aepp.utils.Utils.check_if_exists', MagicMock(return_value = "test_dataflow_id"))
@patch('aepp.flowservice.FlowService.getFlow', MagicMock(return_value = flow_response))
@patch('aepp.flowservice.FlowService.getSourceConnection', MagicMock(return_value = source_connection))
@patch("aepp.connector.AdobeRequest", MagicMock())
def test_create_dataflow_on_schedule(self):
export_obj = ExportDatasetToDataLandingZone(config= self.config, header= MagicMock())
export_obj.createDataFlowRunIfNotExists(dataset_id="test", compression_type="gzip", data_format="parquet", export_path="test", on_schedule=True, config_path="test",entity_name="test", initial_delay=0)
@patch('aepp.flowservice.FlowService.createConnection', MagicMock(return_value = base_connection))
@patch('aepp.flowservice.FlowService.getConnectionSpecIdFromName', MagicMock(return_value = connection_spec))
@patch('aepp.flowservice.FlowService.createSourceConnection', MagicMock(return_value = source_connection))
@patch('aepp.flowservice.FlowService.createTargetConnection', MagicMock(return_value = target_connection))
@patch('aepp.flowservice.FlowService.createFlow', MagicMock(return_value = flow_response))
@patch('aepp.utils.Utils.save_field_in_config', MagicMock())
@patch("aepp.connector.AdobeRequest", MagicMock())
def test_create_dataflow_if_not_exist(self):
export_obj = ExportDatasetToDataLandingZone(config= self.config, header= MagicMock())
return_dataflow_id = export_obj.createDataFlow(dataset_id="test", compression_type="gzip", data_format="parquet", export_path="test", on_schedule=False, config_path="test", entity_name="test")
assert (return_dataflow_id == self.flow_response["id"])
@patch('aepp.destinationinstanceservice.DestinationInstanceService.createAdHocDatasetExport', MagicMock(return_value = adhoc_success_response))
@patch("aepp.connector.AdobeRequest", MagicMock())
def test_retry_on_success_response(self):
export_obj = ExportDatasetToDataLandingZone(config= self.config, header= MagicMock())
assert(export_obj. | retryOnNotReadyException("test", "test", 1, 1) == self.adhoc_success_response) |
@patch('aepp.destinationinstanceservice.DestinationInstanceService.createAdHocDatasetExport', MagicMock(return_value = adhoc_non_retry_error))
@patch("aepp.connector.AdobeRequest", MagicMock())
def test_no_retry_error(self):
export_obj = ExportDatasetToDataLandingZone(config= self.config, header= MagicMock())
assert (export_obj.retryOnNotReadyException("test", "test", 1, 1) == self.adhoc_non_retry_error)
@patch('aepp.destinationinstanceservice.DestinationInstanceService.createAdHocDatasetExport', MagicMock(return_value = adhoc_retry_error))
@patch("aepp.connector.AdobeRequest", MagicMock())
def test_retry_error(self):
export_obj = ExportDatasetToDataLandingZone(config= self.config, header= MagicMock())
try:
export_obj.retryOnNotReadyException("test", "test", 1, 1)
self.fail("expect a retry error")
except RetryError:
pass | tests/exportDatasetToDatalandingZone_test.py | adobe-aepp-0e23c55 | [
{
"filename": "tests/destinationinstanceservice_test.py",
"retrieved_chunk": " result = destination_instance_service_obj.createAdHocDatasetExport(self.ADHOC_INPUT)\n assert(result is not None)\n instance_conn.postData.assert_called_once()\n instance_conn.postData.assert_called_with(ANY, data=self.ADHOC_EXPECTED_PAYLOAD)\n @patch(\"aepp.connector.AdobeRequest\")\n def test_create_adhoc_dataset_export_invalid_input(self, mock_connector):\n destination_instance_service_obj = DestinationInstanceService()\n with self.assertRaises(Exception) as cm:\n destination_instance_service_obj.createAdHocDatasetExport(None)\n self.assertEqual('Require a dict for defining the flowId to datasetIds mapping', str(cm.exception))",
"score": 0.8736228346824646
},
{
"filename": "tests/destinationinstanceservice_test.py",
"retrieved_chunk": "import unittest\nfrom unittest.mock import patch, MagicMock, ANY\nclass DestinationInstanceServiceTest(unittest.TestCase):\n ADHOC_INPUT = {\"flow1\": [\"dataset1\"], \"flow2\": [\"dataset2\", \"dataset3\"]}\n ADHOC_EXPECTED_PAYLOAD = {'activationInfo': {'destinations': [{'flowId': 'flow1', 'datasets': [{'id': 'dataset1'}]}, {'flowId': 'flow2', 'datasets': [{'id': 'dataset2'}, {'id': 'dataset3'}]}]}}\n @patch(\"aepp.connector.AdobeRequest\")\n def test_create_adhoc_dataset_export(self, mock_connector):\n instance_conn = mock_connector.return_value\n instance_conn.postData.return_value = {'foo'}\n destination_instance_service_obj = DestinationInstanceService()",
"score": 0.8621768951416016
},
{
"filename": "tests/dataaccess_test.py",
"retrieved_chunk": "import unittest\nfrom unittest.mock import patch, MagicMock\nclass DataAccessTest(unittest.TestCase):\n def test_dataaccess_get_batch_files(self):\n assert True\n def test_dataaccess_get_batch_failed(self):\n assert True\n def test_dataaccess_get_batch_meta(self):\n assert True\n def test_dataaccess_getHeadFile(self):",
"score": 0.8264188170433044
},
{
"filename": "tests/flowservice_test.py",
"retrieved_chunk": "import unittest\nfrom unittest.mock import patch, MagicMock\nclass FlowserviceTest(unittest.TestCase):\n def test_flowservice_get_resource(self):\n assert True\n def test_flowservice_get_connections(self):\n assert True\n def test_flowservice_create_connection(self):\n assert True\n def test_flowservice_create_streaming_connection(self):",
"score": 0.8163912892341614
},
{
"filename": "tests/schema_test.py",
"retrieved_chunk": " schema_obj = Schema()\n tenant_id_result = schema_obj.getTenantId()\n assert (tenant_id_result is not None)\n instance_conn.getData.assert_called_once()\n @patch(\"aepp.connector.AdobeRequest\")\n def test_schema_get_behavior(self, mock_connector):\n instance_conn = mock_connector.return_value\n instance_conn.getData.return_value = {\"results\":[1234,5678]}\n schema_obj = Schema()\n stats_result = schema_obj.getBehaviors()",
"score": 0.8157200813293457
}
] | python | retryOnNotReadyException("test", "test", 1, 1) == self.adhoc_success_response) |
from collections import OrderedDict
import torch
from torch.functional import norm
import torch.nn as nn
import torch.nn.functional as F
from torchvision.models import vgg16, vgg16_bn
# import fvcore.nn.weight_init as weight_init
from torchvision.models import resnet50
from GCoNet_plus.models.modules import ResBlk, DSLayer, half_DSLayer, CoAttLayer, RefUnet, DBHead
from GCoNet_plus.config import Config
class GCoNet_plus(nn.Module):
def __init__(self):
super(GCoNet_plus, self).__init__()
self.config = Config()
bb = self.config.bb
if bb == 'vgg16':
bb_net = list(vgg16(pretrained=False).children())[0]
bb_convs = OrderedDict({
'conv1': bb_net[:4],
'conv2': bb_net[4:9],
'conv3': bb_net[9:16],
'conv4': bb_net[16:23],
'conv5': bb_net[23:30]
})
channel_scale = 1
elif bb == 'resnet50':
bb_net = list(resnet50(pretrained=False).children())
bb_convs = OrderedDict({
'conv1': nn.Sequential(*bb_net[0:3]),
'conv2': bb_net[4],
'conv3': bb_net[5],
'conv4': bb_net[6],
'conv5': bb_net[7]
})
channel_scale = 4
elif bb == 'vgg16bn':
bb_net = list(vgg16_bn(pretrained=False).children())[0]
bb_convs = OrderedDict({
'conv1': bb_net[:6],
'conv2': bb_net[6:13],
'conv3': bb_net[13:23],
'conv4': bb_net[23:33],
'conv5': bb_net[33:43]
})
channel_scale = 1
self.bb = nn.Sequential(bb_convs)
lateral_channels_in = [512, 512, 256, 128, 64] if 'vgg16' in bb else [2048, 1024, 512, 256, 64]
# channel_scale_latlayer = channel_scale // 2 if bb == 'resnet50' else 1
# channel_last = 32
ch_decoder = lateral_channels_in[0]//2//channel_scale
self.top_layer = ResBlk(lateral_channels_in[0], ch_decoder)
self.enlayer5 = ResBlk(ch_decoder, ch_decoder)
if self.config.conv_after_itp:
self.dslayer5 = DSLayer(ch_decoder, ch_decoder)
self.latlayer5 = ResBlk(lateral_channels_in[1], ch_decoder) if self.config. | complex_lateral_connection else nn.Conv2d(lateral_channels_in[1], ch_decoder, 1, 1, 0) |
ch_decoder //= 2
self.enlayer4 = ResBlk(ch_decoder*2, ch_decoder)
if self.config.conv_after_itp:
self.dslayer4 = DSLayer(ch_decoder, ch_decoder)
self.latlayer4 = ResBlk(lateral_channels_in[2], ch_decoder) if self.config.complex_lateral_connection else nn.Conv2d(lateral_channels_in[2], ch_decoder, 1, 1, 0)
if self.config.output_number >= 4:
self.conv_out4 = nn.Sequential(nn.Conv2d(ch_decoder, 32, 1, 1, 0), nn.ReLU(inplace=True), nn.Conv2d(32, 1, 1, 1, 0))
ch_decoder //= 2
self.enlayer3 = ResBlk(ch_decoder*2, ch_decoder)
if self.config.conv_after_itp:
self.dslayer3 = DSLayer(ch_decoder, ch_decoder)
self.latlayer3 = ResBlk(lateral_channels_in[3], ch_decoder) if self.config.complex_lateral_connection else nn.Conv2d(lateral_channels_in[3], ch_decoder, 1, 1, 0)
if self.config.output_number >= 3:
self.conv_out3 = nn.Sequential(nn.Conv2d(ch_decoder, 32, 1, 1, 0), nn.ReLU(inplace=True), nn.Conv2d(32, 1, 1, 1, 0))
ch_decoder //= 2
self.enlayer2 = ResBlk(ch_decoder*2, ch_decoder)
if self.config.conv_after_itp:
self.dslayer2 = DSLayer(ch_decoder, ch_decoder)
self.latlayer2 = ResBlk(lateral_channels_in[4], ch_decoder) if self.config.complex_lateral_connection else nn.Conv2d(lateral_channels_in[4], ch_decoder, 1, 1, 0)
if self.config.output_number >= 2:
self.conv_out2 = nn.Sequential(nn.Conv2d(ch_decoder, 32, 1, 1, 0), nn.ReLU(inplace=True), nn.Conv2d(32, 1, 1, 1, 0))
self.enlayer1 = ResBlk(ch_decoder, ch_decoder)
self.conv_out1 = nn.Sequential(nn.Conv2d(ch_decoder, 1, 1, 1, 0))
if self.config.GAM:
self.co_x5 = CoAttLayer(channel_in=lateral_channels_in[0])
if 'contrast' in self.config.loss:
self.pred_layer = half_DSLayer(lateral_channels_in[0])
if {'cls', 'cls_mask'} & set(self.config.loss):
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.classifier = nn.Linear(lateral_channels_in[0], 291) # DUTS_class has 291 classes
# for layer in [self.classifier]:
# weight_init.c2_msra_fill(layer)
if self.config.split_mask:
self.sgm = nn.Sigmoid()
if self.config.refine:
self.refiner = nn.Sequential(RefUnet(self.config.refine, 64))
if self.config.split_mask:
self.conv_out_mask = nn.Sequential(nn.Conv2d(ch_decoder, 1, 1, 1, 0))
if self.config.db_mask:
self.db_mask = DBHead(32)
if self.config.db_output_decoder:
self.db_output_decoder = DBHead(32)
if self.config.cls_mask_operation == 'c':
self.conv_cat_mask = nn.Conv2d(4, 3, 1, 1, 0)
def forward(self, x):
########## Encoder ##########
[N, _, H, W] = x.size()
x1 = self.bb.conv1(x)
x2 = self.bb.conv2(x1)
x3 = self.bb.conv3(x2)
x4 = self.bb.conv4(x3)
x5 = self.bb.conv5(x4)
if 'cls' in self.config.loss:
_x5 = self.avgpool(x5)
_x5 = _x5.view(_x5.size(0), -1)
pred_cls = self.classifier(_x5)
if self.config.GAM:
weighted_x5, neg_x5 = self.co_x5(x5)
if 'contrast' in self.config.loss:
if self.training:
########## contrastive branch #########
cat_x5 = torch.cat([weighted_x5, neg_x5], dim=0)
pred_contrast = self.pred_layer(cat_x5)
pred_contrast = F.interpolate(pred_contrast, size=(H, W), mode='bilinear', align_corners=True)
p5 = self.top_layer(weighted_x5)
else:
p5 = self.top_layer(x5)
########## Decoder ##########
scaled_preds = []
p5 = self.enlayer5(p5)
p5 = F.interpolate(p5, size=x4.shape[2:], mode='bilinear', align_corners=True)
if self.config.conv_after_itp:
p5 = self.dslayer5(p5)
p4 = p5 + self.latlayer5(x4)
p4 = self.enlayer4(p4)
p4 = F.interpolate(p4, size=x3.shape[2:], mode='bilinear', align_corners=True)
if self.config.conv_after_itp:
p4 = self.dslayer4(p4)
if self.config.output_number >= 4:
p4_out = self.conv_out4(p4)
scaled_preds.append(p4_out)
p3 = p4 + self.latlayer4(x3)
p3 = self.enlayer3(p3)
p3 = F.interpolate(p3, size=x2.shape[2:], mode='bilinear', align_corners=True)
if self.config.conv_after_itp:
p3 = self.dslayer3(p3)
if self.config.output_number >= 3:
p3_out = self.conv_out3(p3)
scaled_preds.append(p3_out)
p2 = p3 + self.latlayer3(x2)
p2 = self.enlayer2(p2)
p2 = F.interpolate(p2, size=x1.shape[2:], mode='bilinear', align_corners=True)
if self.config.conv_after_itp:
p2 = self.dslayer2(p2)
if self.config.output_number >= 2:
p2_out = self.conv_out2(p2)
scaled_preds.append(p2_out)
p1 = p2 + self.latlayer2(x1)
p1 = self.enlayer1(p1)
p1 = F.interpolate(p1, size=x.shape[2:], mode='bilinear', align_corners=True)
if self.config.db_output_decoder:
p1_out = self.db_output_decoder(p1)
else:
p1_out = self.conv_out1(p1)
scaled_preds.append(p1_out)
if self.config.refine == 1:
scaled_preds.append(self.refiner(p1_out))
elif self.config.refine == 4:
scaled_preds.append(self.refiner(torch.cat([x, p1_out], dim=1)))
if 'cls_mask' in self.config.loss:
pred_cls_masks = []
norm_features_mask = []
input_features = [x, x1, x2, x3][:self.config.loss_cls_mask_last_layers]
bb_lst = [self.bb.conv1, self.bb.conv2, self.bb.conv3, self.bb.conv4, self.bb.conv5]
for idx_out in range(self.config.loss_cls_mask_last_layers):
if idx_out:
mask_output = scaled_preds[-(idx_out+1+int(bool(self.config.refine)))]
else:
if self.config.split_mask:
if self.config.db_mask:
mask_output = self.db_mask(p1)
else:
mask_output = self.sgm(self.conv_out_mask(p1))
if self.config.cls_mask_operation == 'x':
masked_features = input_features[idx_out] * mask_output
elif self.config.cls_mask_operation == '+':
masked_features = input_features[idx_out] + mask_output
elif self.config.cls_mask_operation == 'c':
masked_features = self.conv_cat_mask(torch.cat((input_features[idx_out], mask_output), dim=1))
norm_feature_mask = self.avgpool(
nn.Sequential(*bb_lst[idx_out:])(
masked_features
)
).view(N, -1)
norm_features_mask.append(norm_feature_mask)
pred_cls_masks.append(
self.classifier(
norm_feature_mask
)
)
if self.training:
return_values = []
if {'sal', 'cls', 'contrast', 'cls_mask'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls, pred_contrast, pred_cls_masks]
elif {'sal', 'cls', 'contrast'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls, pred_contrast]
elif {'sal', 'cls', 'cls_mask'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls, pred_cls_masks]
elif {'sal', 'cls'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls]
elif {'sal', 'contrast'} == set(self.config.loss):
return_values = [scaled_preds, pred_contrast]
elif {'sal', 'cls_mask'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls_masks]
else:
return_values = [scaled_preds]
if self.config.lambdas_sal_last['triplet']:
norm_features = []
if '_x5' in self.config.triplet:
norm_features.append(_x5)
if 'mask' in self.config.triplet:
norm_features.append(norm_features_mask[0])
return_values.append(norm_features)
return return_values
else:
return scaled_preds
| GCoNet_plus/models/GCoNet.py | ZhengPeng7-CoSOD_fps_collection-bee3764 | [
{
"filename": "MCCL/models/GCoNet.py",
"retrieved_chunk": " self.co_x4 = GWM(channel_in=lateral_channels_in[bb][0])\n if self.config.dec_blk == 'ResBlk':\n DecBlk = ResBlk\n self.top_layer = DecBlk(lateral_channels_in[bb][0], lateral_channels_in[bb][1])\n self.dec_layer4 = DecBlk(lateral_channels_in[bb][1], lateral_channels_in[bb][1])\n self.lat_layer4 = nn.Conv2d(lateral_channels_in[bb][1], lateral_channels_in[bb][1], 1, 1, 0)\n self.dec_layer3 = DecBlk(lateral_channels_in[bb][1], lateral_channels_in[bb][2])\n self.lat_layer3 = nn.Conv2d(lateral_channels_in[bb][2], lateral_channels_in[bb][2], 1, 1, 0)\n self.dec_layer2 = DecBlk(lateral_channels_in[bb][2], lateral_channels_in[bb][3])\n self.lat_layer2 = nn.Conv2d(lateral_channels_in[bb][3], lateral_channels_in[bb][3], 1, 1, 0)",
"score": 0.92333984375
},
{
"filename": "MCCL/models/GCoNet.py",
"retrieved_chunk": " self.dec_layer1 = DecBlk(lateral_channels_in[bb][3], lateral_channels_in[bb][3]//2)\n self.conv_out1 = nn.Sequential(nn.Conv2d(lateral_channels_in[bb][3]//2, 1, 1, 1, 0))\n def forward(self, x):\n ########## Encoder ##########\n if 'trans' in self.config.bb:\n x1, x2, x3, x4 = self.bb(x)\n else:\n x1 = self.bb.conv1(x)\n x2 = self.bb.conv2(x1)\n x3 = self.bb.conv3(x2)",
"score": 0.8892309665679932
},
{
"filename": "MCCL/models/GCoNet.py",
"retrieved_chunk": " 'cnn-vgg16': [512, 256, 128, 64],\n 'cnn-vgg16bn': [512, 256, 128, 64],\n 'cnn-resnet50': [1024, 512, 256, 64],\n 'trans-pvt': [512, 320, 128, 64],\n }\n if self.config.consensus == 'GCAM':\n self.co_x4 = CoAttLayer(channel_in=lateral_channels_in[bb][0])\n elif self.config.consensus == 'SGS':\n self.co_x4 = SGS(channel_in=lateral_channels_in[bb][0])\n elif self.config.consensus == 'GWM':",
"score": 0.8766242265701294
},
{
"filename": "gicd/models/GICD.py",
"retrieved_chunk": " nn.Conv2d(512, 64, kernel_size=1, stride=1, padding=0),\n nn.ReLU(inplace=True),\n nn.Conv2d(64, 64, kernel_size=1, stride=1, padding=0))\n self.latlayer4 = LatLayer(in_channel=512)\n self.latlayer3 = LatLayer(in_channel=256)\n self.latlayer2 = LatLayer(in_channel=128)\n self.latlayer1 = LatLayer(in_channel=64)\n self.enlayer4 = EnLayer()\n self.enlayer3 = EnLayer()\n self.enlayer2 = EnLayer()",
"score": 0.8756184577941895
},
{
"filename": "DCFM/models/main.py",
"retrieved_chunk": " nn.Conv2d(512, 64, kernel_size=1, stride=1, padding=0),\n nn.ReLU(inplace=True),\n nn.Conv2d(64, 64, kernel_size=1, stride=1, padding=0))\n self.latlayer4 = LatLayer(in_channel=512)\n self.latlayer3 = LatLayer(in_channel=256)\n self.latlayer2 = LatLayer(in_channel=128)\n self.latlayer1 = LatLayer(in_channel=64)\n self.enlayer4 = EnLayer()\n self.enlayer3 = EnLayer()\n self.enlayer2 = EnLayer()",
"score": 0.8755536079406738
}
] | python | complex_lateral_connection else nn.Conv2d(lateral_channels_in[1], ch_decoder, 1, 1, 0) |
from collections import OrderedDict
import torch
from torch.functional import norm
import torch.nn as nn
import torch.nn.functional as F
from torchvision.models import vgg16, vgg16_bn
# import fvcore.nn.weight_init as weight_init
from torchvision.models import resnet50
from GCoNet_plus.models.modules import ResBlk, DSLayer, half_DSLayer, CoAttLayer, RefUnet, DBHead
from GCoNet_plus.config import Config
class GCoNet_plus(nn.Module):
def __init__(self):
super(GCoNet_plus, self).__init__()
self.config = Config()
bb = self.config.bb
if bb == 'vgg16':
bb_net = list(vgg16(pretrained=False).children())[0]
bb_convs = OrderedDict({
'conv1': bb_net[:4],
'conv2': bb_net[4:9],
'conv3': bb_net[9:16],
'conv4': bb_net[16:23],
'conv5': bb_net[23:30]
})
channel_scale = 1
elif bb == 'resnet50':
bb_net = list(resnet50(pretrained=False).children())
bb_convs = OrderedDict({
'conv1': nn.Sequential(*bb_net[0:3]),
'conv2': bb_net[4],
'conv3': bb_net[5],
'conv4': bb_net[6],
'conv5': bb_net[7]
})
channel_scale = 4
elif bb == 'vgg16bn':
bb_net = list(vgg16_bn(pretrained=False).children())[0]
bb_convs = OrderedDict({
'conv1': bb_net[:6],
'conv2': bb_net[6:13],
'conv3': bb_net[13:23],
'conv4': bb_net[23:33],
'conv5': bb_net[33:43]
})
channel_scale = 1
self.bb = nn.Sequential(bb_convs)
lateral_channels_in = [512, 512, 256, 128, 64] if 'vgg16' in bb else [2048, 1024, 512, 256, 64]
# channel_scale_latlayer = channel_scale // 2 if bb == 'resnet50' else 1
# channel_last = 32
ch_decoder = lateral_channels_in[0]//2//channel_scale
self.top_layer = ResBlk(lateral_channels_in[0], ch_decoder)
self.enlayer5 = ResBlk(ch_decoder, ch_decoder)
if self.config.conv_after_itp:
self.dslayer5 = DSLayer(ch_decoder, ch_decoder)
self.latlayer5 = ResBlk(lateral_channels_in[1], ch_decoder) if self.config.complex_lateral_connection else nn.Conv2d(lateral_channels_in[1], ch_decoder, 1, 1, 0)
ch_decoder //= 2
self.enlayer4 = ResBlk(ch_decoder*2, ch_decoder)
if self.config.conv_after_itp:
self.dslayer4 = DSLayer(ch_decoder, ch_decoder)
self.latlayer4 = ResBlk(lateral_channels_in[2], ch_decoder) if self.config.complex_lateral_connection else nn.Conv2d(lateral_channels_in[2], ch_decoder, 1, 1, 0)
if self.config.output_number >= 4:
self.conv_out4 = nn.Sequential(nn.Conv2d(ch_decoder, 32, 1, 1, 0), nn.ReLU(inplace=True), nn.Conv2d(32, 1, 1, 1, 0))
ch_decoder //= 2
self.enlayer3 = ResBlk(ch_decoder*2, ch_decoder)
if self.config.conv_after_itp:
self.dslayer3 = DSLayer(ch_decoder, ch_decoder)
self.latlayer3 = ResBlk(lateral_channels_in[3], ch_decoder) if self.config.complex_lateral_connection else nn.Conv2d(lateral_channels_in[3], ch_decoder, 1, 1, 0)
if self.config.output_number >= 3:
self.conv_out3 = nn.Sequential(nn.Conv2d(ch_decoder, 32, 1, 1, 0), nn.ReLU(inplace=True), nn.Conv2d(32, 1, 1, 1, 0))
ch_decoder //= 2
self.enlayer2 = ResBlk(ch_decoder*2, ch_decoder)
if self.config.conv_after_itp:
self.dslayer2 = DSLayer(ch_decoder, ch_decoder)
self.latlayer2 = ResBlk(lateral_channels_in[4], ch_decoder) if self.config.complex_lateral_connection else nn.Conv2d(lateral_channels_in[4], ch_decoder, 1, 1, 0)
if self.config.output_number >= 2:
self.conv_out2 = nn.Sequential(nn.Conv2d(ch_decoder, 32, 1, 1, 0), nn.ReLU(inplace=True), nn.Conv2d(32, 1, 1, 1, 0))
self.enlayer1 = ResBlk(ch_decoder, ch_decoder)
self.conv_out1 = nn.Sequential(nn.Conv2d(ch_decoder, 1, 1, 1, 0))
if self.config.GAM:
self.co_x5 = CoAttLayer(channel_in=lateral_channels_in[0])
if 'contrast' in self.config.loss:
self.pred_layer = half_DSLayer(lateral_channels_in[0])
if {'cls', 'cls_mask'} & set(self.config.loss):
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.classifier = nn.Linear(lateral_channels_in[0], 291) # DUTS_class has 291 classes
# for layer in [self.classifier]:
# weight_init.c2_msra_fill(layer)
if self.config.split_mask:
self.sgm = nn.Sigmoid()
if self.config.refine:
self.refiner = nn.Sequential(RefUnet(self.config.refine, 64))
if self.config.split_mask:
self.conv_out_mask = nn.Sequential(nn.Conv2d(ch_decoder, 1, 1, 1, 0))
if self.config.db_mask:
self.db_mask = DBHead(32)
if self.config.db_output_decoder:
self.db_output_decoder = DBHead(32)
if self.config. | cls_mask_operation == 'c': |
self.conv_cat_mask = nn.Conv2d(4, 3, 1, 1, 0)
def forward(self, x):
########## Encoder ##########
[N, _, H, W] = x.size()
x1 = self.bb.conv1(x)
x2 = self.bb.conv2(x1)
x3 = self.bb.conv3(x2)
x4 = self.bb.conv4(x3)
x5 = self.bb.conv5(x4)
if 'cls' in self.config.loss:
_x5 = self.avgpool(x5)
_x5 = _x5.view(_x5.size(0), -1)
pred_cls = self.classifier(_x5)
if self.config.GAM:
weighted_x5, neg_x5 = self.co_x5(x5)
if 'contrast' in self.config.loss:
if self.training:
########## contrastive branch #########
cat_x5 = torch.cat([weighted_x5, neg_x5], dim=0)
pred_contrast = self.pred_layer(cat_x5)
pred_contrast = F.interpolate(pred_contrast, size=(H, W), mode='bilinear', align_corners=True)
p5 = self.top_layer(weighted_x5)
else:
p5 = self.top_layer(x5)
########## Decoder ##########
scaled_preds = []
p5 = self.enlayer5(p5)
p5 = F.interpolate(p5, size=x4.shape[2:], mode='bilinear', align_corners=True)
if self.config.conv_after_itp:
p5 = self.dslayer5(p5)
p4 = p5 + self.latlayer5(x4)
p4 = self.enlayer4(p4)
p4 = F.interpolate(p4, size=x3.shape[2:], mode='bilinear', align_corners=True)
if self.config.conv_after_itp:
p4 = self.dslayer4(p4)
if self.config.output_number >= 4:
p4_out = self.conv_out4(p4)
scaled_preds.append(p4_out)
p3 = p4 + self.latlayer4(x3)
p3 = self.enlayer3(p3)
p3 = F.interpolate(p3, size=x2.shape[2:], mode='bilinear', align_corners=True)
if self.config.conv_after_itp:
p3 = self.dslayer3(p3)
if self.config.output_number >= 3:
p3_out = self.conv_out3(p3)
scaled_preds.append(p3_out)
p2 = p3 + self.latlayer3(x2)
p2 = self.enlayer2(p2)
p2 = F.interpolate(p2, size=x1.shape[2:], mode='bilinear', align_corners=True)
if self.config.conv_after_itp:
p2 = self.dslayer2(p2)
if self.config.output_number >= 2:
p2_out = self.conv_out2(p2)
scaled_preds.append(p2_out)
p1 = p2 + self.latlayer2(x1)
p1 = self.enlayer1(p1)
p1 = F.interpolate(p1, size=x.shape[2:], mode='bilinear', align_corners=True)
if self.config.db_output_decoder:
p1_out = self.db_output_decoder(p1)
else:
p1_out = self.conv_out1(p1)
scaled_preds.append(p1_out)
if self.config.refine == 1:
scaled_preds.append(self.refiner(p1_out))
elif self.config.refine == 4:
scaled_preds.append(self.refiner(torch.cat([x, p1_out], dim=1)))
if 'cls_mask' in self.config.loss:
pred_cls_masks = []
norm_features_mask = []
input_features = [x, x1, x2, x3][:self.config.loss_cls_mask_last_layers]
bb_lst = [self.bb.conv1, self.bb.conv2, self.bb.conv3, self.bb.conv4, self.bb.conv5]
for idx_out in range(self.config.loss_cls_mask_last_layers):
if idx_out:
mask_output = scaled_preds[-(idx_out+1+int(bool(self.config.refine)))]
else:
if self.config.split_mask:
if self.config.db_mask:
mask_output = self.db_mask(p1)
else:
mask_output = self.sgm(self.conv_out_mask(p1))
if self.config.cls_mask_operation == 'x':
masked_features = input_features[idx_out] * mask_output
elif self.config.cls_mask_operation == '+':
masked_features = input_features[idx_out] + mask_output
elif self.config.cls_mask_operation == 'c':
masked_features = self.conv_cat_mask(torch.cat((input_features[idx_out], mask_output), dim=1))
norm_feature_mask = self.avgpool(
nn.Sequential(*bb_lst[idx_out:])(
masked_features
)
).view(N, -1)
norm_features_mask.append(norm_feature_mask)
pred_cls_masks.append(
self.classifier(
norm_feature_mask
)
)
if self.training:
return_values = []
if {'sal', 'cls', 'contrast', 'cls_mask'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls, pred_contrast, pred_cls_masks]
elif {'sal', 'cls', 'contrast'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls, pred_contrast]
elif {'sal', 'cls', 'cls_mask'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls, pred_cls_masks]
elif {'sal', 'cls'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls]
elif {'sal', 'contrast'} == set(self.config.loss):
return_values = [scaled_preds, pred_contrast]
elif {'sal', 'cls_mask'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls_masks]
else:
return_values = [scaled_preds]
if self.config.lambdas_sal_last['triplet']:
norm_features = []
if '_x5' in self.config.triplet:
norm_features.append(_x5)
if 'mask' in self.config.triplet:
norm_features.append(norm_features_mask[0])
return_values.append(norm_features)
return return_values
else:
return scaled_preds
| GCoNet_plus/models/GCoNet.py | ZhengPeng7-CoSOD_fps_collection-bee3764 | [
{
"filename": "GCoNet_plus/models/modules.py",
"retrieved_chunk": " self.bn5 = nn.BatchNorm2d(64)\n self.relu5 = nn.ReLU(inplace=True)\n #####\n self.conv_d4 = nn.Conv2d(128, 64, 3, padding=1)\n if config.use_bn:\n self.bn_d4 = nn.BatchNorm2d(64)\n self.relu_d4 = nn.ReLU(inplace=True)\n self.conv_d3 = nn.Conv2d(128, 64, 3, padding=1)\n if config.use_bn:\n self.bn_d3 = nn.BatchNorm2d(64)",
"score": 0.8659025430679321
},
{
"filename": "GCoNet_plus/models/modules.py",
"retrieved_chunk": " self.relu_d3 = nn.ReLU(inplace=True)\n self.conv_d2 = nn.Conv2d(128, 64, 3, padding=1)\n if config.use_bn:\n self.bn_d2 = nn.BatchNorm2d(64)\n self.relu_d2 = nn.ReLU(inplace=True)\n self.conv_d1 = nn.Conv2d(128, 64, 3, padding=1)\n if config.use_bn:\n self.bn_d1 = nn.BatchNorm2d(64)\n self.relu_d1 = nn.ReLU(inplace=True)\n self.conv_d0 = nn.Conv2d(64, 1, 3, padding=1)",
"score": 0.8645366430282593
},
{
"filename": "GCoNet_plus/models/modules.py",
"retrieved_chunk": " self.relu1 = nn.ReLU(inplace=True)\n self.pool1 = nn.MaxPool2d(2, 2, ceil_mode=True)\n self.conv2 = nn.Conv2d(64, 64, 3, padding=1)\n if config.use_bn:\n self.bn2 = nn.BatchNorm2d(64)\n self.relu2 = nn.ReLU(inplace=True)\n self.pool2 = nn.MaxPool2d(2, 2, ceil_mode=True)\n self.conv3 = nn.Conv2d(64, 64, 3, padding=1)\n if config.use_bn:\n self.bn3 = nn.BatchNorm2d(64)",
"score": 0.8574490547180176
},
{
"filename": "GCoNet_plus/models/modules.py",
"retrieved_chunk": " self.relu3 = nn.ReLU(inplace=True)\n self.pool3 = nn.MaxPool2d(2, 2, ceil_mode=True)\n self.conv4 = nn.Conv2d(64, 64, 3, padding=1)\n if config.use_bn:\n self.bn4 = nn.BatchNorm2d(64)\n self.relu4 = nn.ReLU(inplace=True)\n self.pool4 = nn.MaxPool2d(2, 2, ceil_mode=True)\n #####\n self.conv5 = nn.Conv2d(64, 64, 3, padding=1)\n if config.use_bn:",
"score": 0.8551733493804932
},
{
"filename": "GCoNet_plus/models/modules.py",
"retrieved_chunk": " self.relu1 = nn.ReLU(inplace=True)\n self.conv2 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1)\n self.relu2 = nn.ReLU(inplace=True)\n if activation_out:\n self.pred_conv = nn.Conv2d(64, channel_out, kernel_size=1, stride=1, padding=0)\n self.pred_relu = nn.ReLU(inplace=True)\n else:\n self.pred_conv = nn.Conv2d(64, channel_out, kernel_size=1, stride=1, padding=0)\n if config.use_bn:\n self.bn1 = nn.BatchNorm2d(64)",
"score": 0.8549627065658569
}
] | python | cls_mask_operation == 'c': |
from collections import OrderedDict
import torch
from torch.functional import norm
import torch.nn as nn
import torch.nn.functional as F
from torchvision.models import vgg16, vgg16_bn
# import fvcore.nn.weight_init as weight_init
from torchvision.models import resnet50
from GCoNet_plus.models.modules import ResBlk, DSLayer, half_DSLayer, CoAttLayer, RefUnet, DBHead
from GCoNet_plus.config import Config
class GCoNet_plus(nn.Module):
def __init__(self):
super(GCoNet_plus, self).__init__()
self.config = Config()
bb = self.config.bb
if bb == 'vgg16':
bb_net = list(vgg16(pretrained=False).children())[0]
bb_convs = OrderedDict({
'conv1': bb_net[:4],
'conv2': bb_net[4:9],
'conv3': bb_net[9:16],
'conv4': bb_net[16:23],
'conv5': bb_net[23:30]
})
channel_scale = 1
elif bb == 'resnet50':
bb_net = list(resnet50(pretrained=False).children())
bb_convs = OrderedDict({
'conv1': nn.Sequential(*bb_net[0:3]),
'conv2': bb_net[4],
'conv3': bb_net[5],
'conv4': bb_net[6],
'conv5': bb_net[7]
})
channel_scale = 4
elif bb == 'vgg16bn':
bb_net = list(vgg16_bn(pretrained=False).children())[0]
bb_convs = OrderedDict({
'conv1': bb_net[:6],
'conv2': bb_net[6:13],
'conv3': bb_net[13:23],
'conv4': bb_net[23:33],
'conv5': bb_net[33:43]
})
channel_scale = 1
self.bb = nn.Sequential(bb_convs)
lateral_channels_in = [512, 512, 256, 128, 64] if 'vgg16' in bb else [2048, 1024, 512, 256, 64]
# channel_scale_latlayer = channel_scale // 2 if bb == 'resnet50' else 1
# channel_last = 32
ch_decoder = lateral_channels_in[0]//2//channel_scale
self.top_layer = ResBlk(lateral_channels_in[0], ch_decoder)
self.enlayer5 = ResBlk(ch_decoder, ch_decoder)
if self.config.conv_after_itp:
self.dslayer5 = DSLayer(ch_decoder, ch_decoder)
self.latlayer5 = ResBlk(lateral_channels_in[1], ch_decoder) if self.config.complex_lateral_connection else nn.Conv2d(lateral_channels_in[1], ch_decoder, 1, 1, 0)
ch_decoder //= 2
self.enlayer4 = ResBlk(ch_decoder*2, ch_decoder)
if self.config.conv_after_itp:
self.dslayer4 = DSLayer(ch_decoder, ch_decoder)
self.latlayer4 = ResBlk(lateral_channels_in[2], ch_decoder) if self.config.complex_lateral_connection else nn.Conv2d(lateral_channels_in[2], ch_decoder, 1, 1, 0)
if self.config. | output_number >= 4: |
self.conv_out4 = nn.Sequential(nn.Conv2d(ch_decoder, 32, 1, 1, 0), nn.ReLU(inplace=True), nn.Conv2d(32, 1, 1, 1, 0))
ch_decoder //= 2
self.enlayer3 = ResBlk(ch_decoder*2, ch_decoder)
if self.config.conv_after_itp:
self.dslayer3 = DSLayer(ch_decoder, ch_decoder)
self.latlayer3 = ResBlk(lateral_channels_in[3], ch_decoder) if self.config.complex_lateral_connection else nn.Conv2d(lateral_channels_in[3], ch_decoder, 1, 1, 0)
if self.config.output_number >= 3:
self.conv_out3 = nn.Sequential(nn.Conv2d(ch_decoder, 32, 1, 1, 0), nn.ReLU(inplace=True), nn.Conv2d(32, 1, 1, 1, 0))
ch_decoder //= 2
self.enlayer2 = ResBlk(ch_decoder*2, ch_decoder)
if self.config.conv_after_itp:
self.dslayer2 = DSLayer(ch_decoder, ch_decoder)
self.latlayer2 = ResBlk(lateral_channels_in[4], ch_decoder) if self.config.complex_lateral_connection else nn.Conv2d(lateral_channels_in[4], ch_decoder, 1, 1, 0)
if self.config.output_number >= 2:
self.conv_out2 = nn.Sequential(nn.Conv2d(ch_decoder, 32, 1, 1, 0), nn.ReLU(inplace=True), nn.Conv2d(32, 1, 1, 1, 0))
self.enlayer1 = ResBlk(ch_decoder, ch_decoder)
self.conv_out1 = nn.Sequential(nn.Conv2d(ch_decoder, 1, 1, 1, 0))
if self.config.GAM:
self.co_x5 = CoAttLayer(channel_in=lateral_channels_in[0])
if 'contrast' in self.config.loss:
self.pred_layer = half_DSLayer(lateral_channels_in[0])
if {'cls', 'cls_mask'} & set(self.config.loss):
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.classifier = nn.Linear(lateral_channels_in[0], 291) # DUTS_class has 291 classes
# for layer in [self.classifier]:
# weight_init.c2_msra_fill(layer)
if self.config.split_mask:
self.sgm = nn.Sigmoid()
if self.config.refine:
self.refiner = nn.Sequential(RefUnet(self.config.refine, 64))
if self.config.split_mask:
self.conv_out_mask = nn.Sequential(nn.Conv2d(ch_decoder, 1, 1, 1, 0))
if self.config.db_mask:
self.db_mask = DBHead(32)
if self.config.db_output_decoder:
self.db_output_decoder = DBHead(32)
if self.config.cls_mask_operation == 'c':
self.conv_cat_mask = nn.Conv2d(4, 3, 1, 1, 0)
def forward(self, x):
########## Encoder ##########
[N, _, H, W] = x.size()
x1 = self.bb.conv1(x)
x2 = self.bb.conv2(x1)
x3 = self.bb.conv3(x2)
x4 = self.bb.conv4(x3)
x5 = self.bb.conv5(x4)
if 'cls' in self.config.loss:
_x5 = self.avgpool(x5)
_x5 = _x5.view(_x5.size(0), -1)
pred_cls = self.classifier(_x5)
if self.config.GAM:
weighted_x5, neg_x5 = self.co_x5(x5)
if 'contrast' in self.config.loss:
if self.training:
########## contrastive branch #########
cat_x5 = torch.cat([weighted_x5, neg_x5], dim=0)
pred_contrast = self.pred_layer(cat_x5)
pred_contrast = F.interpolate(pred_contrast, size=(H, W), mode='bilinear', align_corners=True)
p5 = self.top_layer(weighted_x5)
else:
p5 = self.top_layer(x5)
########## Decoder ##########
scaled_preds = []
p5 = self.enlayer5(p5)
p5 = F.interpolate(p5, size=x4.shape[2:], mode='bilinear', align_corners=True)
if self.config.conv_after_itp:
p5 = self.dslayer5(p5)
p4 = p5 + self.latlayer5(x4)
p4 = self.enlayer4(p4)
p4 = F.interpolate(p4, size=x3.shape[2:], mode='bilinear', align_corners=True)
if self.config.conv_after_itp:
p4 = self.dslayer4(p4)
if self.config.output_number >= 4:
p4_out = self.conv_out4(p4)
scaled_preds.append(p4_out)
p3 = p4 + self.latlayer4(x3)
p3 = self.enlayer3(p3)
p3 = F.interpolate(p3, size=x2.shape[2:], mode='bilinear', align_corners=True)
if self.config.conv_after_itp:
p3 = self.dslayer3(p3)
if self.config.output_number >= 3:
p3_out = self.conv_out3(p3)
scaled_preds.append(p3_out)
p2 = p3 + self.latlayer3(x2)
p2 = self.enlayer2(p2)
p2 = F.interpolate(p2, size=x1.shape[2:], mode='bilinear', align_corners=True)
if self.config.conv_after_itp:
p2 = self.dslayer2(p2)
if self.config.output_number >= 2:
p2_out = self.conv_out2(p2)
scaled_preds.append(p2_out)
p1 = p2 + self.latlayer2(x1)
p1 = self.enlayer1(p1)
p1 = F.interpolate(p1, size=x.shape[2:], mode='bilinear', align_corners=True)
if self.config.db_output_decoder:
p1_out = self.db_output_decoder(p1)
else:
p1_out = self.conv_out1(p1)
scaled_preds.append(p1_out)
if self.config.refine == 1:
scaled_preds.append(self.refiner(p1_out))
elif self.config.refine == 4:
scaled_preds.append(self.refiner(torch.cat([x, p1_out], dim=1)))
if 'cls_mask' in self.config.loss:
pred_cls_masks = []
norm_features_mask = []
input_features = [x, x1, x2, x3][:self.config.loss_cls_mask_last_layers]
bb_lst = [self.bb.conv1, self.bb.conv2, self.bb.conv3, self.bb.conv4, self.bb.conv5]
for idx_out in range(self.config.loss_cls_mask_last_layers):
if idx_out:
mask_output = scaled_preds[-(idx_out+1+int(bool(self.config.refine)))]
else:
if self.config.split_mask:
if self.config.db_mask:
mask_output = self.db_mask(p1)
else:
mask_output = self.sgm(self.conv_out_mask(p1))
if self.config.cls_mask_operation == 'x':
masked_features = input_features[idx_out] * mask_output
elif self.config.cls_mask_operation == '+':
masked_features = input_features[idx_out] + mask_output
elif self.config.cls_mask_operation == 'c':
masked_features = self.conv_cat_mask(torch.cat((input_features[idx_out], mask_output), dim=1))
norm_feature_mask = self.avgpool(
nn.Sequential(*bb_lst[idx_out:])(
masked_features
)
).view(N, -1)
norm_features_mask.append(norm_feature_mask)
pred_cls_masks.append(
self.classifier(
norm_feature_mask
)
)
if self.training:
return_values = []
if {'sal', 'cls', 'contrast', 'cls_mask'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls, pred_contrast, pred_cls_masks]
elif {'sal', 'cls', 'contrast'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls, pred_contrast]
elif {'sal', 'cls', 'cls_mask'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls, pred_cls_masks]
elif {'sal', 'cls'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls]
elif {'sal', 'contrast'} == set(self.config.loss):
return_values = [scaled_preds, pred_contrast]
elif {'sal', 'cls_mask'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls_masks]
else:
return_values = [scaled_preds]
if self.config.lambdas_sal_last['triplet']:
norm_features = []
if '_x5' in self.config.triplet:
norm_features.append(_x5)
if 'mask' in self.config.triplet:
norm_features.append(norm_features_mask[0])
return_values.append(norm_features)
return return_values
else:
return scaled_preds
| GCoNet_plus/models/GCoNet.py | ZhengPeng7-CoSOD_fps_collection-bee3764 | [
{
"filename": "MCCL/models/GCoNet.py",
"retrieved_chunk": " self.co_x4 = GWM(channel_in=lateral_channels_in[bb][0])\n if self.config.dec_blk == 'ResBlk':\n DecBlk = ResBlk\n self.top_layer = DecBlk(lateral_channels_in[bb][0], lateral_channels_in[bb][1])\n self.dec_layer4 = DecBlk(lateral_channels_in[bb][1], lateral_channels_in[bb][1])\n self.lat_layer4 = nn.Conv2d(lateral_channels_in[bb][1], lateral_channels_in[bb][1], 1, 1, 0)\n self.dec_layer3 = DecBlk(lateral_channels_in[bb][1], lateral_channels_in[bb][2])\n self.lat_layer3 = nn.Conv2d(lateral_channels_in[bb][2], lateral_channels_in[bb][2], 1, 1, 0)\n self.dec_layer2 = DecBlk(lateral_channels_in[bb][2], lateral_channels_in[bb][3])\n self.lat_layer2 = nn.Conv2d(lateral_channels_in[bb][3], lateral_channels_in[bb][3], 1, 1, 0)",
"score": 0.9022576212882996
},
{
"filename": "MCCL/models/GCoNet.py",
"retrieved_chunk": " self.dec_layer1 = DecBlk(lateral_channels_in[bb][3], lateral_channels_in[bb][3]//2)\n self.conv_out1 = nn.Sequential(nn.Conv2d(lateral_channels_in[bb][3]//2, 1, 1, 1, 0))\n def forward(self, x):\n ########## Encoder ##########\n if 'trans' in self.config.bb:\n x1, x2, x3, x4 = self.bb(x)\n else:\n x1 = self.bb.conv1(x)\n x2 = self.bb.conv2(x1)\n x3 = self.bb.conv3(x2)",
"score": 0.8636592626571655
},
{
"filename": "DCFM/models/main.py",
"retrieved_chunk": " nn.Conv2d(512, 64, kernel_size=1, stride=1, padding=0),\n nn.ReLU(inplace=True),\n nn.Conv2d(64, 64, kernel_size=1, stride=1, padding=0))\n self.latlayer4 = LatLayer(in_channel=512)\n self.latlayer3 = LatLayer(in_channel=256)\n self.latlayer2 = LatLayer(in_channel=128)\n self.latlayer1 = LatLayer(in_channel=64)\n self.enlayer4 = EnLayer()\n self.enlayer3 = EnLayer()\n self.enlayer2 = EnLayer()",
"score": 0.8565737009048462
},
{
"filename": "gicd/models/GICD.py",
"retrieved_chunk": " nn.Conv2d(512, 64, kernel_size=1, stride=1, padding=0),\n nn.ReLU(inplace=True),\n nn.Conv2d(64, 64, kernel_size=1, stride=1, padding=0))\n self.latlayer4 = LatLayer(in_channel=512)\n self.latlayer3 = LatLayer(in_channel=256)\n self.latlayer2 = LatLayer(in_channel=128)\n self.latlayer1 = LatLayer(in_channel=64)\n self.enlayer4 = EnLayer()\n self.enlayer3 = EnLayer()\n self.enlayer2 = EnLayer()",
"score": 0.8564580678939819
},
{
"filename": "GCoNet/models/GCoNet.py",
"retrieved_chunk": " self.latlayer2 = LatLayer(in_channel=128)\n self.latlayer1 = LatLayer(in_channel=64)\n self.enlayer4 = EnLayer()\n self.enlayer3 = EnLayer()\n self.enlayer2 = EnLayer()\n self.enlayer1 = EnLayer()\n self.dslayer4 = DSLayer()\n self.dslayer3 = DSLayer()\n self.dslayer2 = DSLayer()\n self.dslayer1 = DSLayer()",
"score": 0.8515777587890625
}
] | python | output_number >= 4: |
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
# import fvcore.nn.weight_init as weight_init
from GCoNet_plus.config import Config
config = Config()
class ResBlk(nn.Module):
def __init__(self, channel_in=64, channel_out=64):
super(ResBlk, self).__init__()
self.conv_in = nn.Conv2d(channel_in, 64, 3, 1, 1)
self.relu_in = nn.ReLU(inplace=True)
self.conv_out = nn.Conv2d(64, channel_out, 3, 1, 1)
if config.use_bn:
self.bn_in = nn.BatchNorm2d(64)
self.bn_out = nn.BatchNorm2d(channel_out)
def forward(self, x):
x = self.conv_in(x)
if config.use_bn:
x = self.bn_in(x)
x = self.relu_in(x)
x = self.conv_out(x)
if config.use_bn:
x = self.bn_out(x)
return x
class DSLayer(nn.Module):
def __init__(self, channel_in=64, channel_out=1, activation_out='relu'):
super(DSLayer, self).__init__()
self.activation_out = activation_out
self.conv1 = nn.Conv2d(channel_in, 64, kernel_size=3, stride=1, padding=1)
self.relu1 = nn.ReLU(inplace=True)
self.conv2 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1)
self.relu2 = nn.ReLU(inplace=True)
if activation_out:
self.pred_conv = nn.Conv2d(64, channel_out, kernel_size=1, stride=1, padding=0)
self.pred_relu = nn.ReLU(inplace=True)
else:
self.pred_conv = nn.Conv2d(64, channel_out, kernel_size=1, stride=1, padding=0)
if config.use_bn:
self.bn1 = nn.BatchNorm2d(64)
self.bn2 = nn.BatchNorm2d(64)
self.pred_bn = nn.BatchNorm2d(channel_out)
def forward(self, x):
x = self.conv1(x)
if config.use_bn:
x = self.bn1(x)
x = self.relu1(x)
x = self.conv2(x)
if config.use_bn:
x = self.bn2(x)
x = self.relu2(x)
x = self.pred_conv(x)
if config.use_bn:
x = self.pred_bn(x)
if self.activation_out:
x = self.pred_relu(x)
return x
class half_DSLayer(nn.Module):
def __init__(self, channel_in=512):
super(half_DSLayer, self).__init__()
self.enlayer = nn.Sequential(
nn.Conv2d(channel_in, int(channel_in//4), kernel_size=3, stride=1, padding=1),
nn.ReLU(inplace=True)
)
self.predlayer = nn.Sequential(
nn.Conv2d(int(channel_in//4), 1, kernel_size=1, stride=1, padding=0),
)
def forward(self, x):
x = self.enlayer(x)
x = self.predlayer(x)
return x
class CoAttLayer(nn.Module):
def __init__(self, channel_in=512):
super(CoAttLayer, self).__init__()
self.all_attention = eval(Config().relation_module + '(channel_in)')
self.conv_output = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.conv_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.fc_transform = nn.Linear(channel_in, channel_in)
# for layer in [self.conv_output, self.conv_transform, self.fc_transform]:
# weight_init.c2_msra_fill(layer)
def forward(self, x5):
if self.training:
f_begin = 0
f_end = int(x5.shape[0] / 2)
s_begin = f_end
s_end = int(x5.shape[0])
x5_1 = x5[f_begin: f_end]
x5_2 = x5[s_begin: s_end]
x5_new_1 = self.all_attention(x5_1)
x5_new_2 = self.all_attention(x5_2)
x5_1_proto = torch.mean(x5_new_1, (0, 2, 3), True).view(1, -1)
x5_1_proto = x5_1_proto.unsqueeze(-1).unsqueeze(-1) # 1, C, 1, 1
x5_2_proto = torch.mean(x5_new_2, (0, 2, 3), True).view(1, -1)
x5_2_proto = x5_2_proto.unsqueeze(-1).unsqueeze(-1) # 1, C, 1, 1
x5_11 = x5_1 * x5_1_proto
x5_22 = x5_2 * x5_2_proto
weighted_x5 = torch.cat([x5_11, x5_22], dim=0)
x5_12 = x5_1 * x5_2_proto
x5_21 = x5_2 * x5_1_proto
neg_x5 = torch.cat([x5_12, x5_21], dim=0)
else:
x5_new = self.all_attention(x5)
x5_proto = torch.mean(x5_new, (0, 2, 3), True).view(1, -1)
x5_proto = x5_proto.unsqueeze(-1).unsqueeze(-1) # 1, C, 1, 1
weighted_x5 = x5 * x5_proto #* cweight
neg_x5 = None
return weighted_x5, neg_x5
class ICE(nn.Module):
# The Integrity Channel Enhancement (ICE) module
# _X means in X-th column
def __init__(self, channel_in=512):
super(ICE, self).__init__()
self.conv_1 = nn.Conv2d(channel_in, channel_in, 3, 1, 1)
self.conv_2 = nn.Conv1d(channel_in, channel_in, 3, 1, 1)
self.conv_3 = nn.Conv2d(channel_in*3, channel_in, 3, 1, 1)
self.fc_2 = nn.Linear(channel_in, channel_in)
self.fc_3 = nn.Linear(channel_in, channel_in)
def forward(self, x):
x_1, x_2, x_3 = x, x, x
x_1 = x_1 * x_2 * x_3
x_2 = x_1 + x_2 + x_3
x_3 = torch.cat((x_1, x_2, x_3), dim=1)
V = self.conv_1(x_1)
bs, c, h, w = x_2.shape
K = self.conv_2(x_2.view(bs, c, h*w))
Q_prime = self.conv_3(x_3)
Q_prime = torch.norm(Q_prime, dim=(-2, -1)).view(bs, c, 1, 1)
Q_prime = Q_prime.view(bs, -1)
Q_prime = self.fc_3(Q_prime)
Q_prime = torch.softmax(Q_prime, dim=-1)
Q_prime = Q_prime.unsqueeze(1)
Q = torch.matmul(Q_prime, K)
x_2 = torch.nn.functional.cosine_similarity(K, Q, dim=-1)
x_2 = torch.sigmoid(x_2)
x_2 = self.fc_2(x_2)
x_2 = x_2.unsqueeze(-1).unsqueeze(-1)
x_1 = V * x_2 + V
return x_1
class GAM(nn.Module):
def __init__(self, channel_in=512):
super(GAM, self).__init__()
self.query_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.key_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.scale = 1.0 / (channel_in ** 0.5)
self.conv6 = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
# for layer in [self.query_transform, self.key_transform, self.conv6]:
# weight_init.c2_msra_fill(layer)
def forward(self, x5):
# x: B,C,H,W
# x_query: B,C,HW
B, C, H5, W5 = x5.size()
x_query = self.query_transform(x5).view(B, C, -1)
# x_query: B,HW,C
x_query = torch.transpose(x_query, 1, 2).contiguous().view(-1, C) # BHW, C
# x_key: B,C,HW
x_key = self.key_transform(x5).view(B, C, -1)
x_key = torch.transpose(x_key, 0, 1).contiguous().view(C, -1) # C, BHW
# W = Q^T K: B,HW,HW
x_w = torch.matmul(x_query, x_key) #* self.scale # BHW, BHW
x_w = x_w.view(B*H5*W5, B, H5*W5)
x_w = torch.max(x_w, -1).values # BHW, B
x_w = x_w.mean(-1)
#x_w = torch.mean(x_w, -1).values # BHW
x_w = x_w.view(B, -1) * self.scale # B, HW
x_w = F.softmax(x_w, dim=-1) # B, HW
x_w = x_w.view(B, H5, W5).unsqueeze(1) # B, 1, H, W
x5 = x5 * x_w
x5 = self.conv6(x5)
return x5
class MHA(nn.Module):
'''
Scaled dot-product attention
'''
def __init__(self, d_model=512, d_k=512, d_v=512, h=8, dropout=.1, channel_in=512):
'''
:param d_model: Output dimensionality of the model
:param d_k: Dimensionality of queries and keys
:param d_v: Dimensionality of values
:param h: Number of heads
'''
super(MHA, self).__init__()
self.query_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.key_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.value_transform = nn.Conv2d(channel_in, channel_in, kernel_size=1, stride=1, padding=0)
self.fc_q = nn.Linear(d_model, h * d_k)
self.fc_k = nn.Linear(d_model, h * d_k)
self.fc_v = nn.Linear(d_model, h * d_v)
self.fc_o = nn.Linear(h * d_v, d_model)
self.dropout = nn.Dropout(dropout)
self.d_model = d_model
self.d_k = d_k
self.d_v = d_v
self.h = h
self.init_weights()
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode='fan_out')
if m.bias is not None:
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.Linear):
nn.init.normal_(m.weight, std=0.001)
if m.bias is not None:
nn.init.constant_(m.bias, 0)
def forward(self, x, attention_mask=None, attention_weights=None):
'''
Computes
:param queries: Queries (b_s, nq, d_model)
:param keys: Keys (b_s, nk, d_model)
:param values: Values (b_s, nk, d_model)
:param attention_mask: Mask over attention values (b_s, h, nq, nk). True indicates masking.
:param attention_weights: Multiplicative weights for attention values (b_s, h, nq, nk).
:return:
'''
B, C, H, W = x.size()
queries = self.query_transform(x).view(B, -1, C)
keys = self.query_transform(x).view(B, -1, C)
values = self.query_transform(x).view(B, -1, C)
b_s, nq = queries.shape[:2]
nk = keys.shape[1]
q = self.fc_q(queries).view(b_s, nq, self.h, self.d_k).permute(0, 2, 1, 3) # (b_s, h, nq, d_k)
k = self.fc_k(keys).view(b_s, nk, self.h, self.d_k).permute(0, 2, 3, 1) # (b_s, h, d_k, nk)
v = self.fc_v(values).view(b_s, nk, self.h, self.d_v).permute(0, 2, 1, 3) # (b_s, h, nk, d_v)
att = torch.matmul(q, k) / np.sqrt(self.d_k) # (b_s, h, nq, nk)
if attention_weights is not None:
att = att * attention_weights
if attention_mask is not None:
att = att.masked_fill(attention_mask, -np.inf)
att = torch.softmax(att, -1)
att = self.dropout(att)
out = torch.matmul(att, v).permute(0, 2, 1, 3).contiguous().view(b_s, nq, self.h * self.d_v) # (b_s, nq, h*d_v)
out = self.fc_o(out).view(B, C, H, W) # (b_s, nq, d_model)
return out
class NonLocal(nn.Module):
def __init__(self, channel_in=512, inter_channels=None, dimension=2, sub_sample=True, bn_layer=True):
super(NonLocal, self).__init__()
assert dimension in [1, 2, 3]
self.dimension = dimension
self.sub_sample = sub_sample
self.channel_in = channel_in
self.inter_channels = inter_channels
if self.inter_channels is None:
self.inter_channels = channel_in // 2
if self.inter_channels == 0:
self.inter_channels = 1
self.g = nn.Conv2d(self.channel_in, self.inter_channels, 1, 1, 0)
if bn_layer:
self.W = nn.Sequential(
nn.Conv2d(self.inter_channels, self.channel_in, kernel_size=1, stride=1, padding=0),
nn.BatchNorm2d(self.channel_in)
)
nn.init.constant_(self.W[1].weight, 0)
nn.init.constant_(self.W[1].bias, 0)
else:
self.W = nn.Conv2d(self.inter_channels, self.channel_in, kernel_size=1, stride=1, padding=0)
nn.init.constant_(self.W.weight, 0)
nn.init.constant_(self.W.bias, 0)
self.theta = nn.Conv2d(self.channel_in, self.inter_channels, kernel_size=1, stride=1, padding=0)
self.phi = nn.Conv2d(self.channel_in, self.inter_channels, kernel_size=1, stride=1, padding=0)
if sub_sample:
self.g = nn.Sequential(self.g, nn.MaxPool2d(kernel_size=(2, 2)))
self.phi = nn.Sequential(self.phi, nn.MaxPool2d(kernel_size=(2, 2)))
def forward(self, x, return_nl_map=False):
"""
:param x: (b, c, t, h, w)
:param return_nl_map: if True return z, nl_map, else only return z.
:return:
"""
batch_size = x.size(0)
g_x = self.g(x).view(batch_size, self.inter_channels, -1)
g_x = g_x.permute(0, 2, 1)
theta_x = self.theta(x).view(batch_size, self.inter_channels, -1)
theta_x = theta_x.permute(0, 2, 1)
phi_x = self.phi(x).view(batch_size, self.inter_channels, -1)
f = torch.matmul(theta_x, phi_x)
f_div_C = F.softmax(f, dim=-1)
y = torch.matmul(f_div_C, g_x)
y = y.permute(0, 2, 1).contiguous()
y = y.view(batch_size, self.inter_channels, *x.size()[2:])
W_y = self.W(y)
z = W_y + x
if return_nl_map:
return z, f_div_C
return z
class DBHead(nn.Module):
def __init__(self, channel_in=32, channel_out=1, k=config.db_k):
super().__init__()
self.k = k
self.binarize = nn.Sequential(
nn.Conv2d(channel_in, channel_in, 3, 1, 1),
*[nn.BatchNorm2d(channel_in), nn.ReLU(inplace=True)] if config.use_bn else nn.ReLU(inplace=True),
nn.Conv2d(channel_in, channel_in, 3, 1, 1),
*[nn.BatchNorm2d(channel_in), nn.ReLU(inplace=True)] if config.use_bn else nn.ReLU(inplace=True),
nn.Conv2d(channel_in, channel_out, 1, 1, 0),
nn.Sigmoid()
)
self.thresh = nn.Sequential(
nn.Conv2d(channel_in, channel_in, 3, padding=1),
*[nn.BatchNorm2d(channel_in), nn.ReLU(inplace=True)] if config.use_bn else nn.ReLU(inplace=True),
nn.Conv2d(channel_in, channel_in, 3, 1, 1),
*[nn.BatchNorm2d(channel_in), nn.ReLU(inplace=True)] if config.use_bn else nn.ReLU(inplace=True),
nn.Conv2d(channel_in, channel_out, 1, 1, 0),
nn.Sigmoid()
)
def forward(self, x):
shrink_maps = self.binarize(x)
threshold_maps = self.thresh(x)
binary_maps = self.step_function(shrink_maps, threshold_maps)
return binary_maps
def step_function(self, x, y):
if config. | db_k_alpha != 1: |
z = x - y
mask_neg_inv = 1 - 2 * (z < 0)
a = torch.exp(-self.k * (torch.pow(z * mask_neg_inv + 1e-16, 1/config.k_alpha) * mask_neg_inv))
else:
a = torch.exp(-self.k * (x - y))
if torch.isinf(a).any():
a = torch.exp(-50 * (x - y))
return torch.reciprocal(1 + a)
class RefUnet(nn.Module):
# Refinement
def __init__(self, in_ch, inc_ch):
super(RefUnet, self).__init__()
self.conv0 = nn.Conv2d(in_ch, inc_ch, 3, padding=1)
self.conv1 = nn.Conv2d(inc_ch, 64, 3, padding=1)
if config.use_bn:
self.bn1 = nn.BatchNorm2d(64)
self.relu1 = nn.ReLU(inplace=True)
self.pool1 = nn.MaxPool2d(2, 2, ceil_mode=True)
self.conv2 = nn.Conv2d(64, 64, 3, padding=1)
if config.use_bn:
self.bn2 = nn.BatchNorm2d(64)
self.relu2 = nn.ReLU(inplace=True)
self.pool2 = nn.MaxPool2d(2, 2, ceil_mode=True)
self.conv3 = nn.Conv2d(64, 64, 3, padding=1)
if config.use_bn:
self.bn3 = nn.BatchNorm2d(64)
self.relu3 = nn.ReLU(inplace=True)
self.pool3 = nn.MaxPool2d(2, 2, ceil_mode=True)
self.conv4 = nn.Conv2d(64, 64, 3, padding=1)
if config.use_bn:
self.bn4 = nn.BatchNorm2d(64)
self.relu4 = nn.ReLU(inplace=True)
self.pool4 = nn.MaxPool2d(2, 2, ceil_mode=True)
#####
self.conv5 = nn.Conv2d(64, 64, 3, padding=1)
if config.use_bn:
self.bn5 = nn.BatchNorm2d(64)
self.relu5 = nn.ReLU(inplace=True)
#####
self.conv_d4 = nn.Conv2d(128, 64, 3, padding=1)
if config.use_bn:
self.bn_d4 = nn.BatchNorm2d(64)
self.relu_d4 = nn.ReLU(inplace=True)
self.conv_d3 = nn.Conv2d(128, 64, 3, padding=1)
if config.use_bn:
self.bn_d3 = nn.BatchNorm2d(64)
self.relu_d3 = nn.ReLU(inplace=True)
self.conv_d2 = nn.Conv2d(128, 64, 3, padding=1)
if config.use_bn:
self.bn_d2 = nn.BatchNorm2d(64)
self.relu_d2 = nn.ReLU(inplace=True)
self.conv_d1 = nn.Conv2d(128, 64, 3, padding=1)
if config.use_bn:
self.bn_d1 = nn.BatchNorm2d(64)
self.relu_d1 = nn.ReLU(inplace=True)
self.conv_d0 = nn.Conv2d(64, 1, 3, padding=1)
self.upscore2 = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
if config.db_output_refiner:
self.db_output_refiner = DBHead(64)
def forward(self, x):
hx = x
hx = self.conv1(self.conv0(hx))
if config.use_bn:
hx = self.bn1(hx)
hx1 = self.relu1(hx)
hx = self.conv2(self.pool1(hx1))
if config.use_bn:
hx = self.bn2(hx)
hx2 = self.relu2(hx)
hx = self.conv3(self.pool2(hx2))
if config.use_bn:
hx = self.bn3(hx)
hx3 = self.relu3(hx)
hx = self.conv4(self.pool3(hx3))
if config.use_bn:
hx = self.bn4(hx)
hx4 = self.relu4(hx)
hx = self.conv5(self.pool4(hx4))
if config.use_bn:
hx = self.bn5(hx)
hx5 = self.relu5(hx)
hx = self.upscore2(hx5)
d4 = self.conv_d4(torch.cat((hx, hx4), 1))
if config.use_bn:
d4 = self.bn_d4(d4)
d4 = self.relu_d4(d4)
hx = self.upscore2(d4)
d3 = self.conv_d3(torch.cat((hx, hx3), 1))
if config.use_bn:
d3 = self.bn_d3(d3)
d3 = self.relu_d3(d3)
hx = self.upscore2(d3)
d2 = self.conv_d2(torch.cat((hx, hx2), 1))
if config.use_bn:
d2 = self.bn_d2(d2)
d2 = self.relu_d2(d2)
hx = self.upscore2(d2)
d1 = self.conv_d1(torch.cat((hx, hx1), 1))
if config.use_bn:
d1 = self.bn_d1(d1)
d1 = self.relu_d1(d1)
if config.db_output_refiner:
x = self.db_output_refiner(d1)
else:
residual = self.conv_d0(d1)
x = x + residual
return x
| GCoNet_plus/models/modules.py | ZhengPeng7-CoSOD_fps_collection-bee3764 | [
{
"filename": "CoSOD_CoADNet/code/ops.py",
"retrieved_chunk": " self.activation = nn.Sigmoid()\n def forward(self, x):\n # x: [B, ic]\n # y: [B, oc]\n y = self.linear(x)\n if self.is_bn:\n y = self.batch_normalization(y)\n if self.na != 'none':\n y = self.activation(y)\n return y",
"score": 0.8168174624443054
},
{
"filename": "CoSOD_CoADNet/code/ops.py",
"retrieved_chunk": " if self.na == 'relu':\n self.activation = nn.ReLU(inplace=True)\n if self.na == 'sigmoid':\n self.activation = nn.Sigmoid()\n def forward(self, x):\n # x: [B, ic, H, W]\n # y: [B, oc, H, W]\n y = self.dil_conv(x)\n if self.is_bn:\n y = self.batch_normalization(y)",
"score": 0.7990337610244751
},
{
"filename": "DCFM/models/main.py",
"retrieved_chunk": " nn.Conv2d(64, 1, kernel_size=1, stride=1, padding=0))#, nn.Sigmoid())\n def forward(self, x):\n x = self.enlayer(x)\n x = self.predlayer(x)\n return x\nclass half_DSLayer(nn.Module):\n def __init__(self, in_channel=512):\n super(half_DSLayer, self).__init__()\n self.enlayer = nn.Sequential(\n nn.Conv2d(in_channel, int(in_channel/4), kernel_size=3, stride=1, padding=1),",
"score": 0.7901338934898376
},
{
"filename": "GCoNet_plus/models/GCoNet.py",
"retrieved_chunk": " self.refiner = nn.Sequential(RefUnet(self.config.refine, 64))\n if self.config.split_mask:\n self.conv_out_mask = nn.Sequential(nn.Conv2d(ch_decoder, 1, 1, 1, 0))\n if self.config.db_mask:\n self.db_mask = DBHead(32)\n if self.config.db_output_decoder:\n self.db_output_decoder = DBHead(32)\n if self.config.cls_mask_operation == 'c':\n self.conv_cat_mask = nn.Conv2d(4, 3, 1, 1, 0)\n def forward(self, x):",
"score": 0.7889927625656128
},
{
"filename": "gicd/models/vgg.py",
"retrieved_chunk": " nn.Linear(4096, 4096),\n nn.ReLU(True),\n nn.Dropout(),\n nn.Linear(4096, 1000),\n )\n def forward(self, x):\n x = self.conv1(x)\n x = self.conv2(x)\n x = self.conv3(x)\n x1 = self.conv4_1(x)",
"score": 0.7873187065124512
}
] | python | db_k_alpha != 1: |
"""raddet dataset."""
import numpy as np
import tensorflow as tf
import tensorflow_datasets.public_api as tfds
from utils import loader, helper
# TODO(raddet): Markdown description that will appear on the catalog page.
_DESCRIPTION = """
Description is **formatted** as markdown.
It should also contain any processing which has been applied (if any),
(e.g. corrupted example skipped, images cropped,...):
"""
# TODO(raddet): BibTeX citation
_CITATION = """
"""
class Raddet(tfds.core.GeneratorBasedBuilder):
"""DatasetBuilder for raddet dataset."""
VERSION = tfds.core.Version('1.1.0')
RELEASE_NOTES = {
'1.0.0': 'Initial release.',
}
def _info(self) -> tfds.core.DatasetInfo:
"""Returns the dataset metadata."""
return tfds.core.DatasetInfo(
builder=self,
description=_DESCRIPTION,
features=tfds.features.FeaturesDict({
# No need to keep 'spectrum' and 'image' field. Serialize their filenames is
# enough to load it and allows to save disk space.
'spectrum': tfds.features.Tensor(shape=(256, 64), dtype=tf.float32),
'image': tfds.features.Image(shape=(None, None, 3)),
'spectrum/filename': tfds.features.Text(),
'spectrum/id': tf.int64,
'sequence/id': tf.int64,
'objects': tfds.features.Sequence({
'area': tf.int64,
'bbox': tfds.features.BBoxFeature(),
'id': tf.int64,
'label': tfds.features.ClassLabel(names=["person", "bicycle", "car", "motorcycle", "bus", "truck"])
# Keep 0 class for BG
}),
}),
# If there's a common (input, target) tuple from the
# features, specify them here. They'll be used if
# `as_supervised=True` in `builder.as_dataset`.
supervised_keys=('spectrum', 'objects'), # Set to `None` to disable
homepage="",
citation=_CITATION,
disable_shuffling=True,
)
def _split_generators(self, dl_manager: tfds.download.DownloadManager):
"""Returns SplitGenerators."""
# TODO(carrada): Downloads the data and defines the splits
train_path = "/opt/stomach/radar1/RADDet dataset/train/"
test_path = "/opt/stomach/radar1/RADDet dataset/test/"
# TODO(carrada): Returns the Dict[split names, Iterator[Key, Example]]
return {
'train': self._generate_examples(train_path, 'train'),
'test': self._generate_examples(test_path, 'test'),
}
def _generate_examples(self, path, input_type="RD"):
classes_list = ["person", "bicycle", "car", "motorcycle", "bus", "truck"]
if path.split('/')[-2] == "train":
RAD_sequences = loader.readSequences(path)
else:
RAD_sequences = sorted(loader.readSequences(path))
count = 0
a_id = 0
s_id = 0
global_mean_log = 3.2438383
global_variance_log = 6.8367246
global_max_log = 10.0805629
global_min_log = 0.0
while count < len(RAD_sequences):
objects = []
RAD_filename = RAD_sequences[count]
RAD_complex = loader.readRAD(RAD_filename)
if RAD_complex is None:
raise ValueError("RAD file not found, please double check the path.")
RAD_data = helper.complexTo2channels(RAD_complex)
# Normalize data
RAD_data = (RAD_data - global_mean_log) / global_variance_log
# RAD_data = (RAD_data - global_min_log) / (global_max_log - global_min_log)
# Load GT instances
gt_filename = loader. | gtfileFromRADfile(RAD_filename, path) |
gt_instances = loader.readRadarInstances(gt_filename)
if gt_instances is None:
raise ValueError("gt file not found, please double check the path")
# Get RD spectrum
RD_data = helper.getSumDim(RAD_data, target_axis=1)
# Get RD bboxes
bboxes, classes = helper.readAndEncodeGtRD(gt_instances, RD_data.shape)
seq_id = RAD_filename.split('/')[-2].split('_')[-1]
for (box, class_) in zip(bboxes, classes):
bbox, area = helper.buildTfdsBoxes(box)
objects.append({
'bbox': bbox,
'label': classes_list.index(class_),
'area': area,
'id': a_id
})
a_id += 1
image_filename = loader.imgfileFromRADfile(RAD_filename, path)
example = {
'spectrum': RD_data.astype(np.float32),
'spectrum/filename': RAD_filename,
'sequence/id': int(seq_id),
'image': image_filename,
'spectrum/id': count,
'objects': objects
}
count += 1
yield count, example
| datasets/raddet_builder/raddet.py | colindecourt-darod-ab4878e | [
{
"filename": "datasets/raddet_builder/utils/loader.py",
"retrieved_chunk": " gt_file = os.path.join(prefix, \"gt\") + RAD_file_spec.replace(\"npy\", \"pickle\")\n return gt_file\ndef imgfileFromRADfile(RAD_file, prefix):\n \"\"\" Transfer RAD filename to gt filename \"\"\"\n RAD_file_spec = RAD_file.split(\"RAD\")[-1]\n gt_file = os.path.join(prefix, \"stereo_image\") + RAD_file_spec.replace(\"npy\", \"jpg\")\n return gt_file\ndef readRadarInstances(pickle_file):\n \"\"\" read output radar instances. \"\"\"\n if os.path.exists(pickle_file):",
"score": 0.7685292959213257
},
{
"filename": "datasets/raddet_builder/utils/loader.py",
"retrieved_chunk": " Please check if the file is organized properly.\")\n return sequences\ndef readRAD(filename):\n if os.path.exists(filename):\n return np.load(filename)\n else:\n return None\ndef gtfileFromRADfile(RAD_file, prefix):\n \"\"\" Transfer RAD filename to gt filename \"\"\"\n RAD_file_spec = RAD_file.split(\"RAD\")[-1]",
"score": 0.7678489089012146
},
{
"filename": "datasets/raddet_builder/utils/loader.py",
"retrieved_chunk": " with open(pickle_file, \"rb\") as f:\n radar_instances = pickle.load(f)\n if len(radar_instances['classes']) == 0:\n radar_instances = None\n else:\n radar_instances = None\n return radar_instances",
"score": 0.7358375787734985
},
{
"filename": "eval.py",
"retrieved_chunk": " # Prepare dataset\n if dataset == \"carrada\":\n batched_test_dataset, dataset_info = data_utils.prepare_dataset(split=\"test\", config=config, seed=seed)\n elif dataset == \"raddet\":\n batched_test_dataset, dataset_info = data_utils.prepare_dataset(split=\"test\", config=config, seed=seed)\n else:\n raise NotImplementedError(\"This dataset doesn't exist.\")\n len_test_dataset = data_utils.get_total_item_size(dataset_info, \"test\")\n anchors = bbox_utils.anchors_generation(config, train=False)\n faster_rcnn_model = model.DAROD(config, anchors)",
"score": 0.7340915203094482
},
{
"filename": "datasets/raddet_builder/__init__.py",
"retrieved_chunk": "\"\"\"raddet dataset.\"\"\"",
"score": 0.72673499584198
}
] | python | gtfileFromRADfile(RAD_filename, path) |
import time
import tensorflow as tf
from darod.models import model
from darod.trainers.trainer import Trainer
from darod.utils import data_utils, bbox_utils, io_utils
seed = 42
# Set memory growth to avoid GPU to crash
physical_devices = tf.config.experimental.list_physical_devices('GPU')
tf.config.experimental.set_memory_growth(physical_devices[0], True)
# Load config from arguments
args = io_utils.handle_args()
config = io_utils.args2config(args)
epochs = config["training"]['epochs']
batch_size = config["training"]["batch_size"]
# Prepare dataset
if config["data"]["dataset"] == "carrada":
batched_train_dataset, dataset_info = data_utils.prepare_dataset(split="train", config=config, seed=seed)
num_train_example = data_utils. | get_total_item_size(dataset_info, "train") |
#
batched_test_dataset, _ = data_utils.prepare_dataset(split="test", config=config, seed=seed)
batched_val_dataset, _ = data_utils.prepare_dataset(split="val", config=config, seed=seed)
else:
batched_train_dataset, dataset_info = data_utils.prepare_dataset(split="train[:90%]", config=config, seed=seed)
num_train_example = data_utils.get_total_item_size(dataset_info, "train[:90%]")
#
batched_val_dataset, _ = data_utils.prepare_dataset(split="train[90%:]", config=config, seed=seed)
batched_test_dataset, _ = data_utils.prepare_dataset(split="test", config=config, seed=seed)
labels = data_utils.get_labels(dataset_info)
config["data"]["total_labels"] = len(labels) + 1
labels = ["bg"] + labels
config["training"]["num_steps_epoch"] = num_train_example
config["training"]["seed"] = seed
# Generate anchors
anchors = bbox_utils.anchors_generation(config, train=True)
# Load model
faster_rcnn_model = model.DAROD(config, anchors)
# Build the model
_ = faster_rcnn_model(tf.zeros([1, 256, 64, config["model"]["input_size"][-1]]))
faster_rcnn_model.summary()
# Train model
trainer = Trainer(config=config, model=faster_rcnn_model, experiment_name=config["log"]["exp"],
backbone=config["model"]["backbone"], labels=labels, backup_dir=args.backup_dir)
trainer.train(anchors, batched_train_dataset, batched_val_dataset)
| train.py | colindecourt-darod-ab4878e | [
{
"filename": "vizualize_testdata.py",
"retrieved_chunk": " target_id = args.seq_id\n eval_best = args.eval_best if args.eval_best is not None else False\n # Prepare dataset\n if dataset == \"carrada\":\n batched_test_dataset, dataset_info = data_utils.prepare_dataset(split=\"test\", config=config, seed=seed)\n elif dataset == \"raddet\":\n batched_test_dataset, dataset_info = data_utils.prepare_dataset(split=\"test\", config=config, seed=seed)\n else:\n raise NotImplementedError(\"This dataset doesn't exist.\")\n anchors = bbox_utils.anchors_generation(config, train=False)",
"score": 0.8698157072067261
},
{
"filename": "eval.py",
"retrieved_chunk": "def main():\n args = io_utils.handle_args_eval()\n # summary_writer = tf.summary.create_file_writer(args.path)\n config_pth = os.path.join(args.path, \"config.json\")\n with open(config_pth, 'r') as file:\n config = json.load(file)\n dataset = config[\"data\"][\"dataset\"]\n labels = config[\"data\"][\"labels\"]\n labels = [\"bg\"] + labels\n seed = config[\"training\"][\"seed\"]",
"score": 0.8609024286270142
},
{
"filename": "vizualize_testdata.py",
"retrieved_chunk": "def main():\n args = io_utils.handle_args_viz()\n config_pth = os.path.join(args.path, \"config.json\")\n with open(config_pth, 'r') as file:\n config = json.load(file)\n dataset = config[\"data\"][\"dataset\"]\n labels = config[\"data\"][\"labels\"]\n labels = [\"bg\"] + labels\n seed = config[\"training\"][\"seed\"]\n layout = config[\"model\"][\"layout\"]",
"score": 0.8541474342346191
},
{
"filename": "darod/utils/io_utils.py",
"retrieved_chunk": " \"batch_size\"]\n config[\"training\"][\"epochs\"] = args.n_epochs if args.n_epochs is not None else config[\"training\"][\"epochs\"]\n config[\"training\"][\"use_bn\"] = args.use_bn if args.use_bn is not None else config[\"training\"][\"use_bn\"]\n config[\"training\"][\"use_aug\"] = args.use_aug if args.use_aug is not None else config[\"training\"][\"use_aug\"]\n config[\"training\"][\"use_doppler\"] = args.use_doppler if args.use_doppler is not None else config[\"training\"][\n \"use_doppler\"]\n config[\"training\"][\"use_dropout\"] = args.use_dropout if args.use_dropout is not None else config[\"training\"][\n \"use_dropout\"]\n config[\"training\"][\"optimizer\"] = args.optimizer if args.optimizer is not None else config[\"training\"][\"optimizer\"]\n config[\"training\"][\"lr\"] = args.lr if args.lr is not None else config[\"training\"][\"lr\"]",
"score": 0.8502858877182007
},
{
"filename": "darod/utils/io_utils.py",
"retrieved_chunk": " config[\"training\"][\"scheduler\"] = args.use_scheduler if args.use_scheduler is not None else config[\"training\"][\n \"scheduler\"]\n config[\"training\"][\"pretraining\"] = \"imagenet\" if args.pt is not None else \"None\"\n # Dataset hyper parameters\n config[\"data\"][\"dataset\"] = args.dataset.split(\":\")[0] if args.dataset is not None else config[\"data\"][\"dataset\"]\n config[\"data\"][\"dataset_version\"] = args.dataset.split(\":\")[1] if args.dataset is not None else config[\"data\"][\n \"dataset_version\"]\n return config\ndef handle_args_eval():\n \"\"\"",
"score": 0.8452263474464417
}
] | python | get_total_item_size(dataset_info, "train") |
from collections import OrderedDict
import torch
from torch.functional import norm
import torch.nn as nn
import torch.nn.functional as F
from torchvision.models import vgg16, vgg16_bn
# import fvcore.nn.weight_init as weight_init
from torchvision.models import resnet50
from GCoNet_plus.models.modules import ResBlk, DSLayer, half_DSLayer, CoAttLayer, RefUnet, DBHead
from GCoNet_plus.config import Config
class GCoNet_plus(nn.Module):
def __init__(self):
super(GCoNet_plus, self).__init__()
self.config = Config()
bb = self.config.bb
if bb == 'vgg16':
bb_net = list(vgg16(pretrained=False).children())[0]
bb_convs = OrderedDict({
'conv1': bb_net[:4],
'conv2': bb_net[4:9],
'conv3': bb_net[9:16],
'conv4': bb_net[16:23],
'conv5': bb_net[23:30]
})
channel_scale = 1
elif bb == 'resnet50':
bb_net = list(resnet50(pretrained=False).children())
bb_convs = OrderedDict({
'conv1': nn.Sequential(*bb_net[0:3]),
'conv2': bb_net[4],
'conv3': bb_net[5],
'conv4': bb_net[6],
'conv5': bb_net[7]
})
channel_scale = 4
elif bb == 'vgg16bn':
bb_net = list(vgg16_bn(pretrained=False).children())[0]
bb_convs = OrderedDict({
'conv1': bb_net[:6],
'conv2': bb_net[6:13],
'conv3': bb_net[13:23],
'conv4': bb_net[23:33],
'conv5': bb_net[33:43]
})
channel_scale = 1
self.bb = nn.Sequential(bb_convs)
lateral_channels_in = [512, 512, 256, 128, 64] if 'vgg16' in bb else [2048, 1024, 512, 256, 64]
# channel_scale_latlayer = channel_scale // 2 if bb == 'resnet50' else 1
# channel_last = 32
ch_decoder = lateral_channels_in[0]//2//channel_scale
self.top_layer = ResBlk(lateral_channels_in[0], ch_decoder)
self.enlayer5 = ResBlk(ch_decoder, ch_decoder)
if self.config.conv_after_itp:
self.dslayer5 = DSLayer(ch_decoder, ch_decoder)
self.latlayer5 = ResBlk(lateral_channels_in[1], ch_decoder) if self.config.complex_lateral_connection else nn.Conv2d(lateral_channels_in[1], ch_decoder, 1, 1, 0)
ch_decoder //= 2
self.enlayer4 = ResBlk(ch_decoder*2, ch_decoder)
if self.config.conv_after_itp:
self.dslayer4 = DSLayer(ch_decoder, ch_decoder)
self.latlayer4 = ResBlk(lateral_channels_in[2], ch_decoder) if self.config.complex_lateral_connection else nn.Conv2d(lateral_channels_in[2], ch_decoder, 1, 1, 0)
if self.config.output_number >= 4:
self.conv_out4 = nn.Sequential(nn.Conv2d(ch_decoder, 32, 1, 1, 0), nn.ReLU(inplace=True), nn.Conv2d(32, 1, 1, 1, 0))
ch_decoder //= 2
self.enlayer3 = ResBlk(ch_decoder*2, ch_decoder)
if self.config.conv_after_itp:
self.dslayer3 = DSLayer(ch_decoder, ch_decoder)
self.latlayer3 = ResBlk(lateral_channels_in[3], ch_decoder) if self.config.complex_lateral_connection else nn.Conv2d(lateral_channels_in[3], ch_decoder, 1, 1, 0)
if self.config.output_number >= 3:
self.conv_out3 = nn.Sequential(nn.Conv2d(ch_decoder, 32, 1, 1, 0), nn.ReLU(inplace=True), nn.Conv2d(32, 1, 1, 1, 0))
ch_decoder //= 2
self.enlayer2 = ResBlk(ch_decoder*2, ch_decoder)
if self.config.conv_after_itp:
self.dslayer2 = DSLayer(ch_decoder, ch_decoder)
self.latlayer2 = ResBlk(lateral_channels_in[4], ch_decoder) if self.config.complex_lateral_connection else nn.Conv2d(lateral_channels_in[4], ch_decoder, 1, 1, 0)
if self.config.output_number >= 2:
self.conv_out2 = nn.Sequential(nn.Conv2d(ch_decoder, 32, 1, 1, 0), nn.ReLU(inplace=True), nn.Conv2d(32, 1, 1, 1, 0))
self.enlayer1 = ResBlk(ch_decoder, ch_decoder)
self.conv_out1 = nn.Sequential(nn.Conv2d(ch_decoder, 1, 1, 1, 0))
if self.config.GAM:
self.co_x5 = CoAttLayer(channel_in=lateral_channels_in[0])
if 'contrast' in self.config.loss:
self.pred_layer = half_DSLayer(lateral_channels_in[0])
if {'cls', 'cls_mask'} & set(self.config.loss):
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.classifier = nn.Linear(lateral_channels_in[0], 291) # DUTS_class has 291 classes
# for layer in [self.classifier]:
# weight_init.c2_msra_fill(layer)
if self.config.split_mask:
self.sgm = nn.Sigmoid()
if self.config.refine:
self.refiner = nn.Sequential(RefUnet(self.config.refine, 64))
if self.config.split_mask:
self.conv_out_mask = nn.Sequential(nn.Conv2d(ch_decoder, 1, 1, 1, 0))
if self.config.db_mask:
self.db_mask = DBHead(32)
if self.config.db_output_decoder:
self.db_output_decoder = DBHead(32)
if self.config.cls_mask_operation == 'c':
self.conv_cat_mask = nn.Conv2d(4, 3, 1, 1, 0)
def forward(self, x):
########## Encoder ##########
[N, _, H, W] = x.size()
x1 = self.bb.conv1(x)
x2 = self.bb.conv2(x1)
x3 = self.bb.conv3(x2)
x4 = self.bb.conv4(x3)
x5 = self.bb.conv5(x4)
if 'cls' in self.config.loss:
_x5 = self.avgpool(x5)
_x5 = _x5.view(_x5.size(0), -1)
pred_cls = self.classifier(_x5)
if self.config.GAM:
weighted_x5, neg_x5 = self.co_x5(x5)
if 'contrast' in self.config.loss:
if self.training:
########## contrastive branch #########
cat_x5 = torch.cat([weighted_x5, neg_x5], dim=0)
pred_contrast = self.pred_layer(cat_x5)
pred_contrast = F.interpolate(pred_contrast, size=(H, W), mode='bilinear', align_corners=True)
p5 = self.top_layer(weighted_x5)
else:
p5 = self.top_layer(x5)
########## Decoder ##########
scaled_preds = []
p5 = self.enlayer5(p5)
p5 = F.interpolate(p5, size=x4.shape[2:], mode='bilinear', align_corners=True)
if self.config.conv_after_itp:
p5 = self.dslayer5(p5)
p4 = p5 + self.latlayer5(x4)
p4 = self.enlayer4(p4)
p4 = F.interpolate(p4, size=x3.shape[2:], mode='bilinear', align_corners=True)
if self.config.conv_after_itp:
p4 = self.dslayer4(p4)
if self.config.output_number >= 4:
p4_out = self.conv_out4(p4)
scaled_preds.append(p4_out)
p3 = p4 + self.latlayer4(x3)
p3 = self.enlayer3(p3)
p3 = F.interpolate(p3, size=x2.shape[2:], mode='bilinear', align_corners=True)
if self.config.conv_after_itp:
p3 = self.dslayer3(p3)
if self.config.output_number >= 3:
p3_out = self.conv_out3(p3)
scaled_preds.append(p3_out)
p2 = p3 + self.latlayer3(x2)
p2 = self.enlayer2(p2)
p2 = F.interpolate(p2, size=x1.shape[2:], mode='bilinear', align_corners=True)
if self.config.conv_after_itp:
p2 = self.dslayer2(p2)
if self.config.output_number >= 2:
p2_out = self.conv_out2(p2)
scaled_preds.append(p2_out)
p1 = p2 + self.latlayer2(x1)
p1 = self.enlayer1(p1)
p1 = F.interpolate(p1, size=x.shape[2:], mode='bilinear', align_corners=True)
if self.config.db_output_decoder:
p1_out = self.db_output_decoder(p1)
else:
p1_out = self.conv_out1(p1)
scaled_preds.append(p1_out)
if self.config.refine == 1:
scaled_preds.append(self.refiner(p1_out))
elif self.config.refine == 4:
scaled_preds.append(self.refiner(torch.cat([x, p1_out], dim=1)))
if 'cls_mask' in self.config.loss:
pred_cls_masks = []
norm_features_mask = []
input_features = [x, x1, x2, x3][:self.config.loss_cls_mask_last_layers]
bb_lst = [self.bb.conv1, self.bb.conv2, self.bb.conv3, self.bb.conv4, self.bb.conv5]
for idx_out in range(self.config.loss_cls_mask_last_layers):
if idx_out:
mask_output = scaled_preds[-(idx_out+1+int(bool(self.config.refine)))]
else:
if self.config.split_mask:
if self.config.db_mask:
mask_output = self.db_mask(p1)
else:
mask_output = self.sgm(self.conv_out_mask(p1))
if self.config.cls_mask_operation == 'x':
masked_features = input_features[idx_out] * mask_output
elif self.config.cls_mask_operation == '+':
masked_features = input_features[idx_out] + mask_output
elif self.config.cls_mask_operation == 'c':
masked_features = self.conv_cat_mask(torch.cat((input_features[idx_out], mask_output), dim=1))
norm_feature_mask = self.avgpool(
nn.Sequential(*bb_lst[idx_out:])(
masked_features
)
).view(N, -1)
norm_features_mask.append(norm_feature_mask)
pred_cls_masks.append(
self.classifier(
norm_feature_mask
)
)
if self.training:
return_values = []
if {'sal', 'cls', 'contrast', 'cls_mask'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls, pred_contrast, pred_cls_masks]
elif {'sal', 'cls', 'contrast'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls, pred_contrast]
elif {'sal', 'cls', 'cls_mask'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls, pred_cls_masks]
elif {'sal', 'cls'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls]
elif {'sal', 'contrast'} == set(self.config.loss):
return_values = [scaled_preds, pred_contrast]
elif {'sal', 'cls_mask'} == set(self.config.loss):
return_values = [scaled_preds, pred_cls_masks]
else:
return_values = [scaled_preds]
if self.config. | lambdas_sal_last['triplet']: |
norm_features = []
if '_x5' in self.config.triplet:
norm_features.append(_x5)
if 'mask' in self.config.triplet:
norm_features.append(norm_features_mask[0])
return_values.append(norm_features)
return return_values
else:
return scaled_preds
| GCoNet_plus/models/GCoNet.py | ZhengPeng7-CoSOD_fps_collection-bee3764 | [
{
"filename": "GCoNet_plus/config.py",
"retrieved_chunk": " losses = ['sal', 'cls', 'contrast', 'cls_mask']\n self.loss = losses[:]\n self.cls_mask_operation = ['x', '+', 'c'][0]\n # Loss + Triplet Loss\n self.lambdas_sal_last = {\n # not 0 means opening this loss\n # original rate -- 1 : 30 : 1.5 : 0.2, bce x 30\n 'bce': 30 * 1, # high performance\n 'iou': 0.5 * 1, # 0 / 255\n 'ssim': 1 * 0, # help contours",
"score": 0.8267850279808044
},
{
"filename": "MCCL/models/GCoNet.py",
"retrieved_chunk": " p1_out = self.conv_out1(p1)\n scaled_preds.append(p1_out)\n if self.training:\n return_values = [scaled_preds, x4]\n return return_values\n else:\n return scaled_preds",
"score": 0.8104057312011719
},
{
"filename": "GCoNet_plus/config.py",
"retrieved_chunk": " self.lambdas_sal_last[loss_sal] *= loss_sal_ratio_by_last_layers\n self.lambdas_sal_others[loss_sal] *= loss_sal_ratio_by_last_layers\n self.lambda_cls_mask = 2.5 * self.loss_cls_mask_ratio_by_last_layers\n self.lambda_cls = 3.\n self.lambda_contrast = 250.\n # Performance of GCoNet\n self.val_measures = {\n 'Emax': {'CoCA': 0.760, 'CoSOD3k': 0.860, 'CoSal2015': 0.887},\n 'Smeasure': {'CoCA': 0.673, 'CoSOD3k': 0.802, 'CoSal2015': 0.845},\n 'Fmax': {'CoCA': 0.544, 'CoSOD3k': 0.777, 'CoSal2015': 0.847},",
"score": 0.8050013184547424
},
{
"filename": "GCoNet_plus/config.py",
"retrieved_chunk": " 'mse': 0,\n 'reg': 0,\n 'triplet': 0,\n }\n self.output_number = 1\n self.loss_sal_layers = 4 # used to be last 4 layers\n self.loss_cls_mask_last_layers = 1 # used to be last 4 layers\n if 'keep in range':\n self.loss_sal_layers = min(self.output_number, self.loss_sal_layers)\n self.loss_cls_mask_last_layers = min(self.output_number, self.loss_cls_mask_last_layers)",
"score": 0.8022844791412354
},
{
"filename": "MCCL/config.py",
"retrieved_chunk": " self.loss_cls_mask_ratio_by_last_layers = 4 / self.loss_cls_mask_last_layers\n for loss_sal in self.lambdas_sal_last.keys():\n loss_sal_ratio_by_last_layers = 4 / (int(bool(self.lambdas_sal_others[loss_sal])) * (self.loss_sal_layers - 1) + 1)\n self.lambdas_sal_last[loss_sal] *= loss_sal_ratio_by_last_layers\n self.lambdas_sal_others[loss_sal] *= loss_sal_ratio_by_last_layers\n self.lambda_cls_mask = 2.5 * self.loss_cls_mask_ratio_by_last_layers\n self.lambda_cls = 3.\n self.lambda_contrast = 250.\n # others\n self.self_supervision = False",
"score": 0.8019226789474487
}
] | python | lambdas_sal_last['triplet']: |
# Copyright 2023 Adobe. All rights reserved.
# This file is licensed to you 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 REPRESENTATIONS
# OF ANY KIND, either express or implied. See the License for the specific language
# governing permissions and limitations under the License.
from aepp.schema import Schema
import unittest
from unittest.mock import patch, MagicMock
class SchemaTest(unittest.TestCase):
@patch("aepp.connector.AdobeRequest")
def test_schema_get_resource(self, mock_connector):
instance_conn = mock_connector.return_value
instance_conn.getData.return_value = "foo"
schema_obj = Schema()
result = schema_obj. | getResource(MagicMock(), MagicMock(), MagicMock(), MagicMock()) |
assert(result is not None)
instance_conn.getData.assert_called_once()
@patch("aepp.connector.AdobeRequest")
def test_schema_update_sandbox(self, mock_connector):
schema_obj = Schema()
test_sandbox = "prod"
schema_obj.updateSandbox(test_sandbox)
assert(schema_obj.sandbox == test_sandbox)
@patch("aepp.connector.AdobeRequest")
def test_schema_get_stats(self, mock_connector):
instance_conn = mock_connector.return_value
instance_conn.getData.return_value = MagicMock()
schema_obj = Schema()
stats_result = schema_obj.getStats()
assert (stats_result is not None)
assert(stats_result == instance_conn.getData.return_value)
instance_conn.getData.assert_called_once()
@patch("aepp.connector.AdobeRequest")
def test_schema_get_tenant_id(self, mock_connector):
instance_conn = mock_connector.return_value
instance_conn.getStats.return_value = MagicMock()
schema_obj = Schema()
tenant_id_result = schema_obj.getTenantId()
assert (tenant_id_result is not None)
instance_conn.getData.assert_called_once()
@patch("aepp.connector.AdobeRequest")
def test_schema_get_behavior(self, mock_connector):
instance_conn = mock_connector.return_value
instance_conn.getData.return_value = {"results":[1234,5678]}
schema_obj = Schema()
stats_result = schema_obj.getBehaviors()
assert (stats_result is not None)
assert (stats_result == instance_conn.getData.return_value.get("results"))
instance_conn.getData.assert_called_once() | tests/schema_test.py | adobe-aepp-0e23c55 | [
{
"filename": "tests/destinationinstanceservice_test.py",
"retrieved_chunk": "import unittest\nfrom unittest.mock import patch, MagicMock, ANY\nclass DestinationInstanceServiceTest(unittest.TestCase):\n ADHOC_INPUT = {\"flow1\": [\"dataset1\"], \"flow2\": [\"dataset2\", \"dataset3\"]}\n ADHOC_EXPECTED_PAYLOAD = {'activationInfo': {'destinations': [{'flowId': 'flow1', 'datasets': [{'id': 'dataset1'}]}, {'flowId': 'flow2', 'datasets': [{'id': 'dataset2'}, {'id': 'dataset3'}]}]}}\n @patch(\"aepp.connector.AdobeRequest\")\n def test_create_adhoc_dataset_export(self, mock_connector):\n instance_conn = mock_connector.return_value\n instance_conn.postData.return_value = {'foo'}\n destination_instance_service_obj = DestinationInstanceService()",
"score": 0.8565126061439514
},
{
"filename": "tests/catalog_test.py",
"retrieved_chunk": "import unittest\nfrom unittest.mock import patch, MagicMock\nclass CatalogTest(unittest.TestCase):\n def test_catalog_get_catalog__resource(self):\n assert True\n def test_catalog_decode_stream_batch(self):\n assert True\n def test_catalog_json_stream_messages(self):\n assert True\n def test_catalog_get_batches(self):",
"score": 0.8457338809967041
},
{
"filename": "tests/flowservice_test.py",
"retrieved_chunk": "import unittest\nfrom unittest.mock import patch, MagicMock\nclass FlowserviceTest(unittest.TestCase):\n def test_flowservice_get_resource(self):\n assert True\n def test_flowservice_get_connections(self):\n assert True\n def test_flowservice_create_connection(self):\n assert True\n def test_flowservice_create_streaming_connection(self):",
"score": 0.8351319432258606
},
{
"filename": "tests/dataaccess_test.py",
"retrieved_chunk": "import unittest\nfrom unittest.mock import patch, MagicMock\nclass DataAccessTest(unittest.TestCase):\n def test_dataaccess_get_batch_files(self):\n assert True\n def test_dataaccess_get_batch_failed(self):\n assert True\n def test_dataaccess_get_batch_meta(self):\n assert True\n def test_dataaccess_getHeadFile(self):",
"score": 0.8265147805213928
},
{
"filename": "tests/datasets_test.py",
"retrieved_chunk": "import unittest\nfrom unittest.mock import patch, MagicMock\nclass DatasetsTest(unittest.TestCase):\n def test_datasets_get_label_schema(self):\n assert True\n def test_datasets_head_label(self):\n assert True\n def test_datasets_delete_labels(self):\n assert True\n def test_datasets_create_labels(self):",
"score": 0.8234678506851196
}
] | python | getResource(MagicMock(), MagicMock(), MagicMock(), MagicMock()) |
import time
import numpy as np
import tensorflow as tf
import tensorflow_addons as tfa
from ..utils import bbox_utils
def compute_eta(total_duration, epoch_duration, epoch, total_epochs):
"""Compute training ETA"""
total_duration += epoch_duration
eta = (total_epochs - epoch) * total_duration / (epoch)
return time.strftime("%H:%M:%S", time.gmtime(eta)), total_duration
def randomly_select_xyz_mask(mask, select_xyz, seed):
"""
Selecting x, y, z number of True elements for corresponding batch and replacing others to False
:param mask: (batch_size, [m_bool_value])
:param select_xyz: (batch_size, [m_bool_value])
:param seed: seed
:return: selected_valid_mask = (batch_size, [m_bool_value])
"""
maxval = tf.reduce_max(select_xyz) * 10
random_mask = tf.random.uniform(tf.shape(mask), minval=1, maxval=maxval, dtype=tf.int32, seed=seed)
multiplied_mask = tf.cast(mask, tf.int32) * random_mask
sorted_mask = tf.argsort(multiplied_mask, direction="DESCENDING")
sorted_mask_indices = tf.argsort(sorted_mask)
selected_mask = tf.less(sorted_mask_indices, tf.expand_dims(select_xyz, 1))
return tf.logical_and(mask, selected_mask)
def calculate_rpn_actual_outputs(anchors, gt_boxes, gt_labels, config):
"""
Generating one step data for training or inference. Batch operations supported.
:param anchors: (total_anchors, [y1, x1, y2, x2]) these values in normalized format between [0, 1]
:param gt_boxes: (batch_size, gt_box_size, [y1, x1, y2, x2]) these values in normalized format between [0, 1]
:param gt_labels: (batch_size, gt_box_size)
:param config: dictionary
:return: bbox_deltas = (batch_size, total_anchors, [delta_y, delta_x, delta_h, delta_w])
bbox_labels = (batch_size, feature_map_shape, feature_map_shape, anchor_count)
"""
batch_size = tf.shape(gt_boxes)[0]
anchor_count = config["rpn"]["anchor_count"]
total_pos_bboxes = int(config["rpn"]["rpn_boxes"] / 2)
total_neg_bboxes = int(config["rpn"]["rpn_boxes"] / 2)
variances = config["rpn"]["variances"]
adaptive_ratio = config["rpn"]["adaptive_ratio"]
postive_th = config["rpn"]["positive_th"]
#
output_height, output_width = config["model"]["feature_map_shape"][0], config["model"]["feature_map_shape"][1]
# Calculate iou values between each bboxes and ground truth boxes
iou_map = bbox_utils. | generate_iou_map(anchors, gt_boxes) |
# Get max index value for each row
max_indices_each_row = tf.argmax(iou_map, axis=2, output_type=tf.int32)
# Get max index value for each column
max_indices_each_column = tf.argmax(iou_map, axis=1, output_type=tf.int32)
# IoU map has iou values for every gt boxes and we merge these values column wise
merged_iou_map = tf.reduce_max(iou_map, axis=2)
#
pos_mask = tf.greater(merged_iou_map, postive_th)
#
valid_indices_cond = tf.not_equal(gt_labels, -1)
valid_indices = tf.cast(tf.where(valid_indices_cond), tf.int32)
valid_max_indices = max_indices_each_column[valid_indices_cond]
#
scatter_bbox_indices = tf.stack([valid_indices[..., 0], valid_max_indices], 1)
max_pos_mask = tf.scatter_nd(scatter_bbox_indices, tf.fill((tf.shape(valid_indices)[0],), True), tf.shape(pos_mask))
pos_mask = tf.logical_and(tf.logical_or(pos_mask, max_pos_mask), tf.reduce_sum(anchors, axis=-1) != 0.0)
pos_mask = randomly_select_xyz_mask(pos_mask, tf.constant([total_pos_bboxes], dtype=tf.int32),
seed=config["training"]["seed"])
#
pos_count = tf.reduce_sum(tf.cast(pos_mask, tf.int32), axis=-1)
# Keep a 50%/50% ratio of positive/negative samples
if adaptive_ratio:
neg_count = 2 * pos_count
else:
neg_count = (total_pos_bboxes + total_neg_bboxes) - pos_count
#
neg_mask = tf.logical_and(tf.logical_and(tf.less(merged_iou_map, 0.3), tf.logical_not(pos_mask)),
tf.reduce_sum(anchors, axis=-1) != 0.0)
neg_mask = randomly_select_xyz_mask(neg_mask, neg_count, seed=config["training"]["seed"])
#
pos_labels = tf.where(pos_mask, tf.ones_like(pos_mask, dtype=tf.float32), tf.constant(-1.0, dtype=tf.float32))
neg_labels = tf.cast(neg_mask, dtype=tf.float32)
bbox_labels = tf.add(pos_labels, neg_labels)
#
gt_boxes_map = tf.gather(gt_boxes, max_indices_each_row, batch_dims=1)
# Replace negative bboxes with zeros
expanded_gt_boxes = tf.where(tf.expand_dims(pos_mask, -1), gt_boxes_map, tf.zeros_like(gt_boxes_map))
# Calculate delta values between anchors and ground truth bboxes
bbox_deltas = bbox_utils.get_deltas_from_bboxes(anchors, expanded_gt_boxes) / variances
#
bbox_labels = tf.reshape(bbox_labels, (batch_size, output_height, output_width, anchor_count))
#
return bbox_deltas, bbox_labels
def frcnn_cls_loss(*args):
"""
Calculating faster rcnn class loss value.
:param args: could be (y_true, y_pred) or ((y_true, y_pred), )
:return: CE loss
"""
y_true, y_pred = args if len(args) == 2 else args[0]
loss_fn = tf.losses.CategoricalCrossentropy(reduction=tf.losses.Reduction.NONE, from_logits=True)
loss_for_all = loss_fn(y_true, y_pred)
#
cond = tf.reduce_any(tf.not_equal(y_true, tf.constant(0.0)), axis=-1)
mask = tf.cast(cond, dtype=tf.float32)
#
conf_loss = tf.reduce_sum(mask * loss_for_all)
total_boxes = tf.maximum(1.0, tf.reduce_sum(mask))
return tf.math.divide_no_nan(conf_loss, total_boxes)
def rpn_cls_loss(*args):
"""
Calculating rpn class loss value.
:param args: could be (y_true, y_pred) or ((y_true, y_pred), )
:return: CE loss
"""
y_true, y_pred = args if len(args) == 2 else args[0]
indices = tf.where(tf.not_equal(y_true, tf.constant(-1.0, dtype=tf.float32)))
target = tf.gather_nd(y_true, indices)
output = tf.gather_nd(y_pred, indices)
lf = tf.losses.BinaryCrossentropy(from_logits=True)
return lf(target, output)
def reg_loss(*args):
"""
Calculating rpn / faster rcnn regression loss value.
:param args: could be (y_true, y_pred) or ((y_true, y_pred), )
:return: regression loss val
"""
y_true, y_pred = args if len(args) == 2 else args[0]
y_pred = tf.reshape(y_pred, (tf.shape(y_pred)[0], -1, 4))
#
loss_fn = tf.losses.Huber(reduction=tf.losses.Reduction.NONE, delta=1 / 9)
loss_for_all = loss_fn(y_true, y_pred)
# loss_for_all = tf.reduce_sum(loss_for_all, axis=-1)
#
pos_cond = tf.reduce_any(tf.not_equal(y_true, tf.constant(0.0)), axis=-1)
pos_mask = tf.cast(pos_cond, dtype=tf.float32)
#
loc_loss = tf.reduce_sum(tf.math.multiply_no_nan(pos_mask, loss_for_all))
total_pos_bboxes = tf.maximum(1.0, tf.reduce_sum(pos_mask))
return tf.math.divide_no_nan(loc_loss, total_pos_bboxes)
def giou_loss(y_true, y_pred, roi_bboxes):
"""
Calculating rpn / faster rcnn regression loss value.
:param y_true: ground truth
:param y_pred: predictied deltas
:param roi_bboxes: predicted boxes
:return: regression loss val
"""
y_pred = tf.reshape(y_pred, (tf.shape(y_pred)[0], -1, 4))
y_pred = bbox_utils.get_bboxes_from_deltas(roi_bboxes, y_pred)
#
loss_fn = tfa.losses.GIoULoss(reduction=tf.losses.Reduction.NONE)
loss_for_all = loss_fn(y_true, y_pred)
# loss_for_all = tf.reduce_sum(loss_for_all, axis=-1)
#
pos_cond = tf.reduce_any(tf.not_equal(y_true, tf.constant(0.0)), axis=-1)
pos_mask = tf.cast(pos_cond, dtype=tf.float32)
#
loc_loss = tf.reduce_sum(tf.math.multiply_no_nan(pos_mask, loss_for_all))
total_pos_bboxes = tf.maximum(1.0, tf.reduce_sum(pos_mask))
return tf.math.divide_no_nan(loc_loss, total_pos_bboxes)
def darod_loss(rpn_cls_pred, rpn_delta_pred, frcnn_cls_pred, frcnn_reg_pred,
bbox_labels, bbox_deltas, frcnn_reg_actuals, frcnn_cls_actuals):
"""
Calculate loss function for DAROD model
:param rpn_cls_pred: RPN classification pred
:param rpn_delta_pred: RPN regression pred
:param frcnn_cls_pred: FRCNN classification pred
:param frcnn_reg_pred: FRCNN regression pred
:param bbox_labels: bounding boxes labels
:param bbox_deltas: bounding boxes deltas
:param frcnn_reg_actuals: faster rcnn regression labels
:param frcnn_cls_actuals: faster rcnn classification labels
:return: faster rcnn loss
"""
rpn_regression_loss = reg_loss(bbox_deltas, rpn_delta_pred)
rpn_classif_loss = rpn_cls_loss(bbox_labels, rpn_cls_pred)
frcnn_regression_loss = reg_loss(frcnn_reg_actuals, frcnn_reg_pred)
frcnn_classif_loss = frcnn_cls_loss(frcnn_cls_actuals, frcnn_cls_pred)
return rpn_regression_loss, rpn_classif_loss, frcnn_regression_loss, frcnn_classif_loss
def darod_loss_giou(rpn_cls_pred, rpn_delta_pred, frcnn_cls_pred, frcnn_reg_pred,
bbox_labels, bbox_deltas, frcnn_reg_actuals, frcnn_cls_actuals, roi_bboxes):
rpn_regression_loss = reg_loss(bbox_deltas, rpn_delta_pred)
rpn_classif_loss = rpn_cls_loss(bbox_labels, rpn_cls_pred)
frcnn_regression_loss = giou_loss(frcnn_reg_actuals, frcnn_reg_pred, roi_bboxes) / 10
frcnn_classif_loss = frcnn_cls_loss(frcnn_cls_actuals, frcnn_cls_pred)
return rpn_regression_loss, rpn_classif_loss, frcnn_regression_loss, frcnn_classif_loss
| darod/utils/train_utils.py | colindecourt-darod-ab4878e | [
{
"filename": "darod/layers/frcnn_layers.py",
"retrieved_chunk": " variances = self.config[\"fastrcnn\"][\"variances_boxes\"]\n adaptive_ratio = self.config[\"fastrcnn\"][\"adaptive_ratio\"]\n positive_th = self.config[\"fastrcnn\"][\"positive_th\"]\n batch_size, total_bboxes = tf.shape(roi_bboxes)[0], tf.shape(roi_bboxes)[1]\n # Calculate iou values between each bboxes and ground truth boxes\n iou_map = bbox_utils.generate_iou_map(roi_bboxes, gt_boxes)\n # Get max index value for each row\n max_indices_each_gt_box = tf.argmax(iou_map, axis=2, output_type=tf.int32)\n # IoU map has iou values for every gt boxes and we merge these values column wise\n merged_iou_map = tf.reduce_max(iou_map, axis=2)",
"score": 0.890794038772583
},
{
"filename": "darod/utils/bbox_utils.py",
"retrieved_chunk": " scales, ratios = config[\"rpn\"][\"anchor_scales\"], config[\"rpn\"][\"anchor_ratios\"]\n num_scales, num_ratios = len(scales), len(ratios)\n scale_tensor = tf.convert_to_tensor(scales, dtype=tf.float32)\n ratio_tensor = tf.convert_to_tensor(ratios, dtype=tf.float32)\n boxes_per_pixel = (num_scales + num_ratios - 1)\n #\n offset_h, offset_w = 0.5, 0.5\n steps_h = 1.0 / in_height\n steps_w = 1.0 / in_width\n # Generate all center points for the anchor boxes",
"score": 0.8396467566490173
},
{
"filename": "darod/layers/frcnn_layers.py",
"retrieved_chunk": " #\n pos_mask = tf.greater(merged_iou_map, positive_th)\n pos_mask = train_utils.randomly_select_xyz_mask(pos_mask, tf.constant([total_pos_bboxes], dtype=tf.int32),\n seed=self.config[\"training\"][\"seed\"])\n #\n neg_mask = tf.logical_and(tf.less(merged_iou_map, positive_th), tf.greater_equal(merged_iou_map, 0.0))\n if adaptive_ratio:\n pos_count = tf.reduce_sum(tf.cast(pos_mask, tf.int32), axis=-1)\n # Keep a 33%/66% ratio of positive/negative bboxes\n total_neg_bboxes = tf.multiply(pos_count + 1, 3)",
"score": 0.8359656929969788
},
{
"filename": "darod/utils/bbox_utils.py",
"retrieved_chunk": " \"\"\"\n # Denormalize bboxes for better computation\n bboxes = denormalize_bboxes(bboxes, 256, 64)\n gt_boxes = denormalize_bboxes(gt_boxes, 256, 64)\n #\n bbox_y1, bbox_x1, bbox_y2, bbox_x2 = tf.split(bboxes, 4, axis=-1)\n gt_y1, gt_x1, gt_y2, gt_x2 = tf.split(gt_boxes, 4, axis=-1)\n # Calculate bbox and groud truth centers\n bbox_center_x = bbox_x1 + (bbox_x2 - bbox_x1) / 2\n bbox_center_y = bbox_y1 + (bbox_y2 - bbox_y1) / 2",
"score": 0.8307009935379028
},
{
"filename": "darod/layers/frcnn_layers.py",
"retrieved_chunk": " pos_gt_labels = tf.where(pos_mask, gt_labels_map, tf.constant(-1, dtype=tf.int32))\n neg_gt_labels = tf.cast(neg_mask, dtype=tf.int32)\n expanded_gt_labels = pos_gt_labels + neg_gt_labels\n #\n roi_bbox_deltas = bbox_utils.get_deltas_from_bboxes(roi_bboxes, expanded_gt_boxes) / variances\n #\n roi_bbox_labels = tf.one_hot(expanded_gt_labels, total_labels)\n scatter_indices = tf.tile(tf.expand_dims(roi_bbox_labels, -1), (1, 1, 1, 4))\n roi_bbox_deltas = scatter_indices * tf.expand_dims(roi_bbox_deltas, -2)\n roi_bbox_deltas = tf.reshape(roi_bbox_deltas, (batch_size, total_bboxes * total_labels, 4))",
"score": 0.8305044174194336
}
] | python | generate_iou_map(anchors, gt_boxes) |
"""raddet dataset."""
import numpy as np
import tensorflow as tf
import tensorflow_datasets.public_api as tfds
from utils import loader, helper
# TODO(raddet): Markdown description that will appear on the catalog page.
_DESCRIPTION = """
Description is **formatted** as markdown.
It should also contain any processing which has been applied (if any),
(e.g. corrupted example skipped, images cropped,...):
"""
# TODO(raddet): BibTeX citation
_CITATION = """
"""
class Raddet(tfds.core.GeneratorBasedBuilder):
"""DatasetBuilder for raddet dataset."""
VERSION = tfds.core.Version('1.1.0')
RELEASE_NOTES = {
'1.0.0': 'Initial release.',
}
def _info(self) -> tfds.core.DatasetInfo:
"""Returns the dataset metadata."""
return tfds.core.DatasetInfo(
builder=self,
description=_DESCRIPTION,
features=tfds.features.FeaturesDict({
# No need to keep 'spectrum' and 'image' field. Serialize their filenames is
# enough to load it and allows to save disk space.
'spectrum': tfds.features.Tensor(shape=(256, 64), dtype=tf.float32),
'image': tfds.features.Image(shape=(None, None, 3)),
'spectrum/filename': tfds.features.Text(),
'spectrum/id': tf.int64,
'sequence/id': tf.int64,
'objects': tfds.features.Sequence({
'area': tf.int64,
'bbox': tfds.features.BBoxFeature(),
'id': tf.int64,
'label': tfds.features.ClassLabel(names=["person", "bicycle", "car", "motorcycle", "bus", "truck"])
# Keep 0 class for BG
}),
}),
# If there's a common (input, target) tuple from the
# features, specify them here. They'll be used if
# `as_supervised=True` in `builder.as_dataset`.
supervised_keys=('spectrum', 'objects'), # Set to `None` to disable
homepage="",
citation=_CITATION,
disable_shuffling=True,
)
def _split_generators(self, dl_manager: tfds.download.DownloadManager):
"""Returns SplitGenerators."""
# TODO(carrada): Downloads the data and defines the splits
train_path = "/opt/stomach/radar1/RADDet dataset/train/"
test_path = "/opt/stomach/radar1/RADDet dataset/test/"
# TODO(carrada): Returns the Dict[split names, Iterator[Key, Example]]
return {
'train': self._generate_examples(train_path, 'train'),
'test': self._generate_examples(test_path, 'test'),
}
def _generate_examples(self, path, input_type="RD"):
classes_list = ["person", "bicycle", "car", "motorcycle", "bus", "truck"]
if path.split('/')[-2] == "train":
RAD_sequences = loader.readSequences(path)
else:
RAD_sequences = sorted(loader.readSequences(path))
count = 0
a_id = 0
s_id = 0
global_mean_log = 3.2438383
global_variance_log = 6.8367246
global_max_log = 10.0805629
global_min_log = 0.0
while count < len(RAD_sequences):
objects = []
RAD_filename = RAD_sequences[count]
RAD_complex = loader. | readRAD(RAD_filename) |
if RAD_complex is None:
raise ValueError("RAD file not found, please double check the path.")
RAD_data = helper.complexTo2channels(RAD_complex)
# Normalize data
RAD_data = (RAD_data - global_mean_log) / global_variance_log
# RAD_data = (RAD_data - global_min_log) / (global_max_log - global_min_log)
# Load GT instances
gt_filename = loader.gtfileFromRADfile(RAD_filename, path)
gt_instances = loader.readRadarInstances(gt_filename)
if gt_instances is None:
raise ValueError("gt file not found, please double check the path")
# Get RD spectrum
RD_data = helper.getSumDim(RAD_data, target_axis=1)
# Get RD bboxes
bboxes, classes = helper.readAndEncodeGtRD(gt_instances, RD_data.shape)
seq_id = RAD_filename.split('/')[-2].split('_')[-1]
for (box, class_) in zip(bboxes, classes):
bbox, area = helper.buildTfdsBoxes(box)
objects.append({
'bbox': bbox,
'label': classes_list.index(class_),
'area': area,
'id': a_id
})
a_id += 1
image_filename = loader.imgfileFromRADfile(RAD_filename, path)
example = {
'spectrum': RD_data.astype(np.float32),
'spectrum/filename': RAD_filename,
'sequence/id': int(seq_id),
'image': image_filename,
'spectrum/id': count,
'objects': objects
}
count += 1
yield count, example
| datasets/raddet_builder/raddet.py | colindecourt-darod-ab4878e | [
{
"filename": "datasets/raddet_builder/utils/loader.py",
"retrieved_chunk": " Please check if the file is organized properly.\")\n return sequences\ndef readRAD(filename):\n if os.path.exists(filename):\n return np.load(filename)\n else:\n return None\ndef gtfileFromRADfile(RAD_file, prefix):\n \"\"\" Transfer RAD filename to gt filename \"\"\"\n RAD_file_spec = RAD_file.split(\"RAD\")[-1]",
"score": 0.7474775910377502
},
{
"filename": "darod/utils/viz_utils.py",
"retrieved_chunk": " ax1 = fig.add_subplot(121)\n ax2 = fig.add_subplot(122)\n rd_spectrum = norm2Image(rd_spectrum.numpy().squeeze())\n ax1.imshow(rd_spectrum)\n title = \"Range-Doppler\"\n ax1.set_xticks([0, 16, 32, 48, 63])\n ax1.set_xticklabels([-13, -6.5, 0, 6.5, 13])\n ax1.set_yticks([0, 64, 128, 192, 255])\n ax1.set_yticklabels([50, 37.5, 25, 12.5, 0])\n ax1.set_xlabel(\"velocity (m/s)\")",
"score": 0.7238407731056213
},
{
"filename": "datasets/carrada_builder/carrada.py",
"retrieved_chunk": " sequence_id += 1\n # Load all annotations for current sequence\n current_annotations = annotation[sequence]\n # Iterate over all frames in the current sequence\n for frame in current_annotations:\n objects = []\n # Load all annotations fdor all instances in the frame\n sequence_annot = current_annotations[frame]\n # Define file_name for camera and spectrum data\n spectrum_fn = os.path.join(sequence, spectrum_type + '_processed', frame.zfill(6) + '.npy')",
"score": 0.7188565731048584
},
{
"filename": "datasets/raddet_builder/__init__.py",
"retrieved_chunk": "\"\"\"raddet dataset.\"\"\"",
"score": 0.7182285785675049
},
{
"filename": "datasets/raddet_builder/utils/loader.py",
"retrieved_chunk": " gt_file = os.path.join(prefix, \"gt\") + RAD_file_spec.replace(\"npy\", \"pickle\")\n return gt_file\ndef imgfileFromRADfile(RAD_file, prefix):\n \"\"\" Transfer RAD filename to gt filename \"\"\"\n RAD_file_spec = RAD_file.split(\"RAD\")[-1]\n gt_file = os.path.join(prefix, \"stereo_image\") + RAD_file_spec.replace(\"npy\", \"jpg\")\n return gt_file\ndef readRadarInstances(pickle_file):\n \"\"\" read output radar instances. \"\"\"\n if os.path.exists(pickle_file):",
"score": 0.7143891453742981
}
] | python | readRAD(RAD_filename) |
from collections import OrderedDict
import torch
from torch.functional import norm
import torch.nn as nn
import torch.nn.functional as F
from torchvision.models import vgg16, vgg16_bn
from torchvision.models import resnet50
from MCCL.models.modules import ResBlk, CoAttLayer
from MCCL.models.pvt import pvt_v2_b2
from MCCL.config import Config
class MCCL(nn.Module):
def __init__(self):
super(MCCL, self).__init__()
self.config = Config()
bb = self.config.bb
if bb == 'cnn-vgg16':
bb_net = list(vgg16(pretrained=False).children())[0]
bb_convs = OrderedDict({
'conv1': bb_net[:4],
'conv2': bb_net[4:9],
'conv3': bb_net[9:16],
'conv4': bb_net[16:23]
})
elif bb == 'cnn-vgg16bn':
bb_net = list(vgg16_bn(pretrained=False).children())[0]
bb_convs = OrderedDict({
'conv1': bb_net[:6],
'conv2': bb_net[6:13],
'conv3': bb_net[13:23],
'conv4': bb_net[23:33]
})
elif bb == 'cnn-resnet50':
bb_net = list(resnet50(pretrained=False).children())
bb_convs = OrderedDict({
'conv1': nn.Sequential(*bb_net[0:3]),
'conv2': bb_net[4],
'conv3': bb_net[5],
'conv4': bb_net[6]
})
elif bb == 'trans-pvt':
self.bb = pvt_v2_b2()
# if self.config.pvt_weights:
# save_model = torch.load(self.config.pvt_weights)
# model_dict = self.bb.state_dict()
# state_dict = {k: v for k, v in save_model.items() if k in model_dict.keys()}
# model_dict.update(state_dict)
# self.bb.load_state_dict(model_dict)
if 'cnn-' in bb:
self.bb = nn.Sequential(bb_convs)
lateral_channels_in = {
'cnn-vgg16': [512, 256, 128, 64],
'cnn-vgg16bn': [512, 256, 128, 64],
'cnn-resnet50': [1024, 512, 256, 64],
'trans-pvt': [512, 320, 128, 64],
}
if self.config.consensus == 'GCAM':
self.co_x4 = CoAttLayer(channel_in=lateral_channels_in[bb][0])
elif self.config.consensus == 'SGS':
self.co_x4 = SGS(channel_in=lateral_channels_in[bb][0])
elif self.config.consensus == 'GWM':
self.co_x4 = GWM(channel_in=lateral_channels_in[bb][0])
if self.config. | dec_blk == 'ResBlk': |
DecBlk = ResBlk
self.top_layer = DecBlk(lateral_channels_in[bb][0], lateral_channels_in[bb][1])
self.dec_layer4 = DecBlk(lateral_channels_in[bb][1], lateral_channels_in[bb][1])
self.lat_layer4 = nn.Conv2d(lateral_channels_in[bb][1], lateral_channels_in[bb][1], 1, 1, 0)
self.dec_layer3 = DecBlk(lateral_channels_in[bb][1], lateral_channels_in[bb][2])
self.lat_layer3 = nn.Conv2d(lateral_channels_in[bb][2], lateral_channels_in[bb][2], 1, 1, 0)
self.dec_layer2 = DecBlk(lateral_channels_in[bb][2], lateral_channels_in[bb][3])
self.lat_layer2 = nn.Conv2d(lateral_channels_in[bb][3], lateral_channels_in[bb][3], 1, 1, 0)
self.dec_layer1 = DecBlk(lateral_channels_in[bb][3], lateral_channels_in[bb][3]//2)
self.conv_out1 = nn.Sequential(nn.Conv2d(lateral_channels_in[bb][3]//2, 1, 1, 1, 0))
def forward(self, x):
########## Encoder ##########
if 'trans' in self.config.bb:
x1, x2, x3, x4 = self.bb(x)
else:
x1 = self.bb.conv1(x)
x2 = self.bb.conv2(x1)
x3 = self.bb.conv3(x2)
x4 = self.bb.conv4(x3)
if self.config.consensus:
x4 = self.co_x4(x4)
p4 = self.top_layer(x4)
########## Decoder ##########
scaled_preds = []
p4 = self.dec_layer4(p4)
p4 = F.interpolate(p4, size=x3.shape[2:], mode='bilinear', align_corners=True)
p3 = p4 + self.lat_layer4(x3)
p3 = self.dec_layer3(p3)
p3 = F.interpolate(p3, size=x2.shape[2:], mode='bilinear', align_corners=True)
p2 = p3 + self.lat_layer3(x2)
p2 = self.dec_layer2(p2)
p2 = F.interpolate(p2, size=x1.shape[2:], mode='bilinear', align_corners=True)
p1 = p2 + self.lat_layer2(x1)
p1 = self.dec_layer1(p1)
p1 = F.interpolate(p1, size=x.shape[2:], mode='bilinear', align_corners=True)
if self.config.db_output_decoder:
p1_out = self.db_output_decoder(p1)
else:
p1_out = self.conv_out1(p1)
scaled_preds.append(p1_out)
if self.training:
return_values = [scaled_preds, x4]
return return_values
else:
return scaled_preds
| MCCL/models/GCoNet.py | ZhengPeng7-CoSOD_fps_collection-bee3764 | [
{
"filename": "GCoNet_plus/models/GCoNet.py",
"retrieved_chunk": " 'conv3': bb_net[13:23],\n 'conv4': bb_net[23:33],\n 'conv5': bb_net[33:43]\n })\n channel_scale = 1\n self.bb = nn.Sequential(bb_convs)\n lateral_channels_in = [512, 512, 256, 128, 64] if 'vgg16' in bb else [2048, 1024, 512, 256, 64]\n # channel_scale_latlayer = channel_scale // 2 if bb == 'resnet50' else 1\n # channel_last = 32\n ch_decoder = lateral_channels_in[0]//2//channel_scale",
"score": 0.8657290935516357
},
{
"filename": "GCoNet_plus/models/GCoNet.py",
"retrieved_chunk": " self.enlayer2 = ResBlk(ch_decoder*2, ch_decoder)\n if self.config.conv_after_itp:\n self.dslayer2 = DSLayer(ch_decoder, ch_decoder)\n self.latlayer2 = ResBlk(lateral_channels_in[4], ch_decoder) if self.config.complex_lateral_connection else nn.Conv2d(lateral_channels_in[4], ch_decoder, 1, 1, 0)\n if self.config.output_number >= 2:\n self.conv_out2 = nn.Sequential(nn.Conv2d(ch_decoder, 32, 1, 1, 0), nn.ReLU(inplace=True), nn.Conv2d(32, 1, 1, 1, 0))\n self.enlayer1 = ResBlk(ch_decoder, ch_decoder)\n self.conv_out1 = nn.Sequential(nn.Conv2d(ch_decoder, 1, 1, 1, 0))\n if self.config.GAM:\n self.co_x5 = CoAttLayer(channel_in=lateral_channels_in[0])",
"score": 0.862626850605011
},
{
"filename": "GCoNet_plus/models/GCoNet.py",
"retrieved_chunk": " self.top_layer = ResBlk(lateral_channels_in[0], ch_decoder)\n self.enlayer5 = ResBlk(ch_decoder, ch_decoder)\n if self.config.conv_after_itp:\n self.dslayer5 = DSLayer(ch_decoder, ch_decoder)\n self.latlayer5 = ResBlk(lateral_channels_in[1], ch_decoder) if self.config.complex_lateral_connection else nn.Conv2d(lateral_channels_in[1], ch_decoder, 1, 1, 0)\n ch_decoder //= 2\n self.enlayer4 = ResBlk(ch_decoder*2, ch_decoder)\n if self.config.conv_after_itp:\n self.dslayer4 = DSLayer(ch_decoder, ch_decoder)\n self.latlayer4 = ResBlk(lateral_channels_in[2], ch_decoder) if self.config.complex_lateral_connection else nn.Conv2d(lateral_channels_in[2], ch_decoder, 1, 1, 0)",
"score": 0.8608997464179993
},
{
"filename": "GCoNet_plus/models/GCoNet.py",
"retrieved_chunk": " if self.config.output_number >= 4:\n self.conv_out4 = nn.Sequential(nn.Conv2d(ch_decoder, 32, 1, 1, 0), nn.ReLU(inplace=True), nn.Conv2d(32, 1, 1, 1, 0))\n ch_decoder //= 2\n self.enlayer3 = ResBlk(ch_decoder*2, ch_decoder)\n if self.config.conv_after_itp:\n self.dslayer3 = DSLayer(ch_decoder, ch_decoder)\n self.latlayer3 = ResBlk(lateral_channels_in[3], ch_decoder) if self.config.complex_lateral_connection else nn.Conv2d(lateral_channels_in[3], ch_decoder, 1, 1, 0)\n if self.config.output_number >= 3:\n self.conv_out3 = nn.Sequential(nn.Conv2d(ch_decoder, 32, 1, 1, 0), nn.ReLU(inplace=True), nn.Conv2d(32, 1, 1, 1, 0))\n ch_decoder //= 2",
"score": 0.8586539030075073
},
{
"filename": "GCoNet_plus/models/GCoNet.py",
"retrieved_chunk": " if 'contrast' in self.config.loss:\n self.pred_layer = half_DSLayer(lateral_channels_in[0])\n if {'cls', 'cls_mask'} & set(self.config.loss):\n self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n self.classifier = nn.Linear(lateral_channels_in[0], 291) # DUTS_class has 291 classes\n # for layer in [self.classifier]:\n # weight_init.c2_msra_fill(layer)\n if self.config.split_mask:\n self.sgm = nn.Sigmoid()\n if self.config.refine:",
"score": 0.8465099930763245
}
] | python | dec_blk == 'ResBlk': |
"""raddet dataset."""
import numpy as np
import tensorflow as tf
import tensorflow_datasets.public_api as tfds
from utils import loader, helper
# TODO(raddet): Markdown description that will appear on the catalog page.
_DESCRIPTION = """
Description is **formatted** as markdown.
It should also contain any processing which has been applied (if any),
(e.g. corrupted example skipped, images cropped,...):
"""
# TODO(raddet): BibTeX citation
_CITATION = """
"""
class Raddet(tfds.core.GeneratorBasedBuilder):
"""DatasetBuilder for raddet dataset."""
VERSION = tfds.core.Version('1.1.0')
RELEASE_NOTES = {
'1.0.0': 'Initial release.',
}
def _info(self) -> tfds.core.DatasetInfo:
"""Returns the dataset metadata."""
return tfds.core.DatasetInfo(
builder=self,
description=_DESCRIPTION,
features=tfds.features.FeaturesDict({
# No need to keep 'spectrum' and 'image' field. Serialize their filenames is
# enough to load it and allows to save disk space.
'spectrum': tfds.features.Tensor(shape=(256, 64), dtype=tf.float32),
'image': tfds.features.Image(shape=(None, None, 3)),
'spectrum/filename': tfds.features.Text(),
'spectrum/id': tf.int64,
'sequence/id': tf.int64,
'objects': tfds.features.Sequence({
'area': tf.int64,
'bbox': tfds.features.BBoxFeature(),
'id': tf.int64,
'label': tfds.features.ClassLabel(names=["person", "bicycle", "car", "motorcycle", "bus", "truck"])
# Keep 0 class for BG
}),
}),
# If there's a common (input, target) tuple from the
# features, specify them here. They'll be used if
# `as_supervised=True` in `builder.as_dataset`.
supervised_keys=('spectrum', 'objects'), # Set to `None` to disable
homepage="",
citation=_CITATION,
disable_shuffling=True,
)
def _split_generators(self, dl_manager: tfds.download.DownloadManager):
"""Returns SplitGenerators."""
# TODO(carrada): Downloads the data and defines the splits
train_path = "/opt/stomach/radar1/RADDet dataset/train/"
test_path = "/opt/stomach/radar1/RADDet dataset/test/"
# TODO(carrada): Returns the Dict[split names, Iterator[Key, Example]]
return {
'train': self._generate_examples(train_path, 'train'),
'test': self._generate_examples(test_path, 'test'),
}
def _generate_examples(self, path, input_type="RD"):
classes_list = ["person", "bicycle", "car", "motorcycle", "bus", "truck"]
if path.split('/')[-2] == "train":
RAD_sequences = loader.readSequences(path)
else:
RAD_sequences = sorted(loader.readSequences(path))
count = 0
a_id = 0
s_id = 0
global_mean_log = 3.2438383
global_variance_log = 6.8367246
global_max_log = 10.0805629
global_min_log = 0.0
while count < len(RAD_sequences):
objects = []
RAD_filename = RAD_sequences[count]
RAD_complex = loader.readRAD(RAD_filename)
if RAD_complex is None:
raise ValueError("RAD file not found, please double check the path.")
RAD_data = helper.complexTo2channels(RAD_complex)
# Normalize data
RAD_data = (RAD_data - global_mean_log) / global_variance_log
# RAD_data = (RAD_data - global_min_log) / (global_max_log - global_min_log)
# Load GT instances
gt_filename = loader.gtfileFromRADfile(RAD_filename, path)
gt_instances = loader. | readRadarInstances(gt_filename) |
if gt_instances is None:
raise ValueError("gt file not found, please double check the path")
# Get RD spectrum
RD_data = helper.getSumDim(RAD_data, target_axis=1)
# Get RD bboxes
bboxes, classes = helper.readAndEncodeGtRD(gt_instances, RD_data.shape)
seq_id = RAD_filename.split('/')[-2].split('_')[-1]
for (box, class_) in zip(bboxes, classes):
bbox, area = helper.buildTfdsBoxes(box)
objects.append({
'bbox': bbox,
'label': classes_list.index(class_),
'area': area,
'id': a_id
})
a_id += 1
image_filename = loader.imgfileFromRADfile(RAD_filename, path)
example = {
'spectrum': RD_data.astype(np.float32),
'spectrum/filename': RAD_filename,
'sequence/id': int(seq_id),
'image': image_filename,
'spectrum/id': count,
'objects': objects
}
count += 1
yield count, example
| datasets/raddet_builder/raddet.py | colindecourt-darod-ab4878e | [
{
"filename": "datasets/raddet_builder/utils/loader.py",
"retrieved_chunk": " gt_file = os.path.join(prefix, \"gt\") + RAD_file_spec.replace(\"npy\", \"pickle\")\n return gt_file\ndef imgfileFromRADfile(RAD_file, prefix):\n \"\"\" Transfer RAD filename to gt filename \"\"\"\n RAD_file_spec = RAD_file.split(\"RAD\")[-1]\n gt_file = os.path.join(prefix, \"stereo_image\") + RAD_file_spec.replace(\"npy\", \"jpg\")\n return gt_file\ndef readRadarInstances(pickle_file):\n \"\"\" read output radar instances. \"\"\"\n if os.path.exists(pickle_file):",
"score": 0.7675395607948303
},
{
"filename": "datasets/raddet_builder/utils/loader.py",
"retrieved_chunk": " with open(pickle_file, \"rb\") as f:\n radar_instances = pickle.load(f)\n if len(radar_instances['classes']) == 0:\n radar_instances = None\n else:\n radar_instances = None\n return radar_instances",
"score": 0.7588679790496826
},
{
"filename": "datasets/raddet_builder/utils/loader.py",
"retrieved_chunk": " Please check if the file is organized properly.\")\n return sequences\ndef readRAD(filename):\n if os.path.exists(filename):\n return np.load(filename)\n else:\n return None\ndef gtfileFromRADfile(RAD_file, prefix):\n \"\"\" Transfer RAD filename to gt filename \"\"\"\n RAD_file_spec = RAD_file.split(\"RAD\")[-1]",
"score": 0.7493969202041626
},
{
"filename": "eval.py",
"retrieved_chunk": " # Prepare dataset\n if dataset == \"carrada\":\n batched_test_dataset, dataset_info = data_utils.prepare_dataset(split=\"test\", config=config, seed=seed)\n elif dataset == \"raddet\":\n batched_test_dataset, dataset_info = data_utils.prepare_dataset(split=\"test\", config=config, seed=seed)\n else:\n raise NotImplementedError(\"This dataset doesn't exist.\")\n len_test_dataset = data_utils.get_total_item_size(dataset_info, \"test\")\n anchors = bbox_utils.anchors_generation(config, train=False)\n faster_rcnn_model = model.DAROD(config, anchors)",
"score": 0.7347631454467773
},
{
"filename": "darod/utils/viz_utils.py",
"retrieved_chunk": " ax1 = fig.add_subplot(121)\n ax2 = fig.add_subplot(122)\n rd_spectrum = norm2Image(rd_spectrum.numpy().squeeze())\n ax1.imshow(rd_spectrum)\n title = \"Range-Doppler\"\n ax1.set_xticks([0, 16, 32, 48, 63])\n ax1.set_xticklabels([-13, -6.5, 0, 6.5, 13])\n ax1.set_yticks([0, 64, 128, 192, 255])\n ax1.set_yticklabels([50, 37.5, 25, 12.5, 0])\n ax1.set_xlabel(\"velocity (m/s)\")",
"score": 0.7338569164276123
}
] | python | readRadarInstances(gt_filename) |
"""raddet dataset."""
import numpy as np
import tensorflow as tf
import tensorflow_datasets.public_api as tfds
from utils import loader, helper
# TODO(raddet): Markdown description that will appear on the catalog page.
_DESCRIPTION = """
Description is **formatted** as markdown.
It should also contain any processing which has been applied (if any),
(e.g. corrupted example skipped, images cropped,...):
"""
# TODO(raddet): BibTeX citation
_CITATION = """
"""
class Raddet(tfds.core.GeneratorBasedBuilder):
"""DatasetBuilder for raddet dataset."""
VERSION = tfds.core.Version('1.1.0')
RELEASE_NOTES = {
'1.0.0': 'Initial release.',
}
def _info(self) -> tfds.core.DatasetInfo:
"""Returns the dataset metadata."""
return tfds.core.DatasetInfo(
builder=self,
description=_DESCRIPTION,
features=tfds.features.FeaturesDict({
# No need to keep 'spectrum' and 'image' field. Serialize their filenames is
# enough to load it and allows to save disk space.
'spectrum': tfds.features.Tensor(shape=(256, 64), dtype=tf.float32),
'image': tfds.features.Image(shape=(None, None, 3)),
'spectrum/filename': tfds.features.Text(),
'spectrum/id': tf.int64,
'sequence/id': tf.int64,
'objects': tfds.features.Sequence({
'area': tf.int64,
'bbox': tfds.features.BBoxFeature(),
'id': tf.int64,
'label': tfds.features.ClassLabel(names=["person", "bicycle", "car", "motorcycle", "bus", "truck"])
# Keep 0 class for BG
}),
}),
# If there's a common (input, target) tuple from the
# features, specify them here. They'll be used if
# `as_supervised=True` in `builder.as_dataset`.
supervised_keys=('spectrum', 'objects'), # Set to `None` to disable
homepage="",
citation=_CITATION,
disable_shuffling=True,
)
def _split_generators(self, dl_manager: tfds.download.DownloadManager):
"""Returns SplitGenerators."""
# TODO(carrada): Downloads the data and defines the splits
train_path = "/opt/stomach/radar1/RADDet dataset/train/"
test_path = "/opt/stomach/radar1/RADDet dataset/test/"
# TODO(carrada): Returns the Dict[split names, Iterator[Key, Example]]
return {
'train': self._generate_examples(train_path, 'train'),
'test': self._generate_examples(test_path, 'test'),
}
def _generate_examples(self, path, input_type="RD"):
classes_list = ["person", "bicycle", "car", "motorcycle", "bus", "truck"]
if path.split('/')[-2] == "train":
RAD_sequences = loader.readSequences(path)
else:
RAD_sequences = sorted(loader.readSequences(path))
count = 0
a_id = 0
s_id = 0
global_mean_log = 3.2438383
global_variance_log = 6.8367246
global_max_log = 10.0805629
global_min_log = 0.0
while count < len(RAD_sequences):
objects = []
RAD_filename = RAD_sequences[count]
RAD_complex = loader.readRAD(RAD_filename)
if RAD_complex is None:
raise ValueError("RAD file not found, please double check the path.")
RAD_data = helper. | complexTo2channels(RAD_complex) |
# Normalize data
RAD_data = (RAD_data - global_mean_log) / global_variance_log
# RAD_data = (RAD_data - global_min_log) / (global_max_log - global_min_log)
# Load GT instances
gt_filename = loader.gtfileFromRADfile(RAD_filename, path)
gt_instances = loader.readRadarInstances(gt_filename)
if gt_instances is None:
raise ValueError("gt file not found, please double check the path")
# Get RD spectrum
RD_data = helper.getSumDim(RAD_data, target_axis=1)
# Get RD bboxes
bboxes, classes = helper.readAndEncodeGtRD(gt_instances, RD_data.shape)
seq_id = RAD_filename.split('/')[-2].split('_')[-1]
for (box, class_) in zip(bboxes, classes):
bbox, area = helper.buildTfdsBoxes(box)
objects.append({
'bbox': bbox,
'label': classes_list.index(class_),
'area': area,
'id': a_id
})
a_id += 1
image_filename = loader.imgfileFromRADfile(RAD_filename, path)
example = {
'spectrum': RD_data.astype(np.float32),
'spectrum/filename': RAD_filename,
'sequence/id': int(seq_id),
'image': image_filename,
'spectrum/id': count,
'objects': objects
}
count += 1
yield count, example
| datasets/raddet_builder/raddet.py | colindecourt-darod-ab4878e | [
{
"filename": "datasets/raddet_builder/utils/loader.py",
"retrieved_chunk": " Please check if the file is organized properly.\")\n return sequences\ndef readRAD(filename):\n if os.path.exists(filename):\n return np.load(filename)\n else:\n return None\ndef gtfileFromRADfile(RAD_file, prefix):\n \"\"\" Transfer RAD filename to gt filename \"\"\"\n RAD_file_spec = RAD_file.split(\"RAD\")[-1]",
"score": 0.7477507591247559
},
{
"filename": "darod/utils/viz_utils.py",
"retrieved_chunk": " ax1 = fig.add_subplot(121)\n ax2 = fig.add_subplot(122)\n rd_spectrum = norm2Image(rd_spectrum.numpy().squeeze())\n ax1.imshow(rd_spectrum)\n title = \"Range-Doppler\"\n ax1.set_xticks([0, 16, 32, 48, 63])\n ax1.set_xticklabels([-13, -6.5, 0, 6.5, 13])\n ax1.set_yticks([0, 64, 128, 192, 255])\n ax1.set_yticklabels([50, 37.5, 25, 12.5, 0])\n ax1.set_xlabel(\"velocity (m/s)\")",
"score": 0.7205318212509155
},
{
"filename": "datasets/raddet_builder/utils/loader.py",
"retrieved_chunk": " gt_file = os.path.join(prefix, \"gt\") + RAD_file_spec.replace(\"npy\", \"pickle\")\n return gt_file\ndef imgfileFromRADfile(RAD_file, prefix):\n \"\"\" Transfer RAD filename to gt filename \"\"\"\n RAD_file_spec = RAD_file.split(\"RAD\")[-1]\n gt_file = os.path.join(prefix, \"stereo_image\") + RAD_file_spec.replace(\"npy\", \"jpg\")\n return gt_file\ndef readRadarInstances(pickle_file):\n \"\"\" read output radar instances. \"\"\"\n if os.path.exists(pickle_file):",
"score": 0.7080218195915222
},
{
"filename": "vizualize_testdata.py",
"retrieved_chunk": " else:\n restore_ckpt(config, log_pth=args.path)\n idx = 0\n start_idx = 0\n end_idx = 250\n for data in batched_test_dataset:\n spectrums, gt_boxes, gt_labels, is_same_seq, seq_id, _, images = data\n if seq_id.numpy()[0] != target_id and dataset == \"carrada\":\n continue\n else:",
"score": 0.705161452293396
},
{
"filename": "datasets/raddet_builder/__init__.py",
"retrieved_chunk": "\"\"\"raddet dataset.\"\"\"",
"score": 0.7030503749847412
}
] | python | complexTo2channels(RAD_complex) |
"""raddet dataset."""
import numpy as np
import tensorflow as tf
import tensorflow_datasets.public_api as tfds
from utils import loader, helper
# TODO(raddet): Markdown description that will appear on the catalog page.
_DESCRIPTION = """
Description is **formatted** as markdown.
It should also contain any processing which has been applied (if any),
(e.g. corrupted example skipped, images cropped,...):
"""
# TODO(raddet): BibTeX citation
_CITATION = """
"""
class Raddet(tfds.core.GeneratorBasedBuilder):
"""DatasetBuilder for raddet dataset."""
VERSION = tfds.core.Version('1.1.0')
RELEASE_NOTES = {
'1.0.0': 'Initial release.',
}
def _info(self) -> tfds.core.DatasetInfo:
"""Returns the dataset metadata."""
return tfds.core.DatasetInfo(
builder=self,
description=_DESCRIPTION,
features=tfds.features.FeaturesDict({
# No need to keep 'spectrum' and 'image' field. Serialize their filenames is
# enough to load it and allows to save disk space.
'spectrum': tfds.features.Tensor(shape=(256, 64), dtype=tf.float32),
'image': tfds.features.Image(shape=(None, None, 3)),
'spectrum/filename': tfds.features.Text(),
'spectrum/id': tf.int64,
'sequence/id': tf.int64,
'objects': tfds.features.Sequence({
'area': tf.int64,
'bbox': tfds.features.BBoxFeature(),
'id': tf.int64,
'label': tfds.features.ClassLabel(names=["person", "bicycle", "car", "motorcycle", "bus", "truck"])
# Keep 0 class for BG
}),
}),
# If there's a common (input, target) tuple from the
# features, specify them here. They'll be used if
# `as_supervised=True` in `builder.as_dataset`.
supervised_keys=('spectrum', 'objects'), # Set to `None` to disable
homepage="",
citation=_CITATION,
disable_shuffling=True,
)
def _split_generators(self, dl_manager: tfds.download.DownloadManager):
"""Returns SplitGenerators."""
# TODO(carrada): Downloads the data and defines the splits
train_path = "/opt/stomach/radar1/RADDet dataset/train/"
test_path = "/opt/stomach/radar1/RADDet dataset/test/"
# TODO(carrada): Returns the Dict[split names, Iterator[Key, Example]]
return {
'train': self._generate_examples(train_path, 'train'),
'test': self._generate_examples(test_path, 'test'),
}
def _generate_examples(self, path, input_type="RD"):
classes_list = ["person", "bicycle", "car", "motorcycle", "bus", "truck"]
if path.split('/')[-2] == "train":
RAD_sequences = loader.readSequences(path)
else:
RAD_sequences = sorted(loader.readSequences(path))
count = 0
a_id = 0
s_id = 0
global_mean_log = 3.2438383
global_variance_log = 6.8367246
global_max_log = 10.0805629
global_min_log = 0.0
while count < len(RAD_sequences):
objects = []
RAD_filename = RAD_sequences[count]
RAD_complex = loader.readRAD(RAD_filename)
if RAD_complex is None:
raise ValueError("RAD file not found, please double check the path.")
RAD_data = helper.complexTo2channels(RAD_complex)
# Normalize data
RAD_data = (RAD_data - global_mean_log) / global_variance_log
# RAD_data = (RAD_data - global_min_log) / (global_max_log - global_min_log)
# Load GT instances
gt_filename = loader.gtfileFromRADfile(RAD_filename, path)
gt_instances = loader.readRadarInstances(gt_filename)
if gt_instances is None:
raise ValueError("gt file not found, please double check the path")
# Get RD spectrum
RD_data = helper.getSumDim(RAD_data, target_axis=1)
# Get RD bboxes
bboxes, classes = helper. | readAndEncodeGtRD(gt_instances, RD_data.shape) |
seq_id = RAD_filename.split('/')[-2].split('_')[-1]
for (box, class_) in zip(bboxes, classes):
bbox, area = helper.buildTfdsBoxes(box)
objects.append({
'bbox': bbox,
'label': classes_list.index(class_),
'area': area,
'id': a_id
})
a_id += 1
image_filename = loader.imgfileFromRADfile(RAD_filename, path)
example = {
'spectrum': RD_data.astype(np.float32),
'spectrum/filename': RAD_filename,
'sequence/id': int(seq_id),
'image': image_filename,
'spectrum/id': count,
'objects': objects
}
count += 1
yield count, example
| datasets/raddet_builder/raddet.py | colindecourt-darod-ab4878e | [
{
"filename": "datasets/raddet_builder/utils/loader.py",
"retrieved_chunk": " gt_file = os.path.join(prefix, \"gt\") + RAD_file_spec.replace(\"npy\", \"pickle\")\n return gt_file\ndef imgfileFromRADfile(RAD_file, prefix):\n \"\"\" Transfer RAD filename to gt filename \"\"\"\n RAD_file_spec = RAD_file.split(\"RAD\")[-1]\n gt_file = os.path.join(prefix, \"stereo_image\") + RAD_file_spec.replace(\"npy\", \"jpg\")\n return gt_file\ndef readRadarInstances(pickle_file):\n \"\"\" read output radar instances. \"\"\"\n if os.path.exists(pickle_file):",
"score": 0.7970374822616577
},
{
"filename": "datasets/raddet_builder/utils/helper.py",
"retrieved_chunk": "import numpy as np\nimport tensorflow_datasets as tfds\ndef readAndEncodeGtRD(gt_instance, rd_shape):\n \"\"\" read gt_instance and return bbox\n and class for RD \"\"\"\n x_shape, y_shape = rd_shape[1], rd_shape[0]\n boxes = gt_instance[\"boxes\"]\n classes = gt_instance[\"classes\"]\n new_boxes = []\n new_classes = []",
"score": 0.7889845371246338
},
{
"filename": "datasets/raddet_builder/utils/loader.py",
"retrieved_chunk": " Please check if the file is organized properly.\")\n return sequences\ndef readRAD(filename):\n if os.path.exists(filename):\n return np.load(filename)\n else:\n return None\ndef gtfileFromRADfile(RAD_file, prefix):\n \"\"\" Transfer RAD filename to gt filename \"\"\"\n RAD_file_spec = RAD_file.split(\"RAD\")[-1]",
"score": 0.7802667021751404
},
{
"filename": "eval.py",
"retrieved_chunk": " # Prepare dataset\n if dataset == \"carrada\":\n batched_test_dataset, dataset_info = data_utils.prepare_dataset(split=\"test\", config=config, seed=seed)\n elif dataset == \"raddet\":\n batched_test_dataset, dataset_info = data_utils.prepare_dataset(split=\"test\", config=config, seed=seed)\n else:\n raise NotImplementedError(\"This dataset doesn't exist.\")\n len_test_dataset = data_utils.get_total_item_size(dataset_info, \"test\")\n anchors = bbox_utils.anchors_generation(config, train=False)\n faster_rcnn_model = model.DAROD(config, anchors)",
"score": 0.7765352725982666
},
{
"filename": "eval.py",
"retrieved_chunk": " gt_labels, valid_idxs)\n if spectrums.shape[0] != 0:\n start = time.time()\n _, _, _, _, _, decoder_output = faster_rcnn_model(spectrums, training=False)\n end = time.time() - start\n total_time += end\n pred_boxes, pred_labels, pred_scores = decoder_output\n pred_labels = pred_labels - 1\n gt_labels = gt_labels - 1\n for batch_id in range(gt_labels.shape[0]):",
"score": 0.7664055824279785
}
] | python | readAndEncodeGtRD(gt_instances, RD_data.shape) |
"""raddet dataset."""
import numpy as np
import tensorflow as tf
import tensorflow_datasets.public_api as tfds
from utils import loader, helper
# TODO(raddet): Markdown description that will appear on the catalog page.
_DESCRIPTION = """
Description is **formatted** as markdown.
It should also contain any processing which has been applied (if any),
(e.g. corrupted example skipped, images cropped,...):
"""
# TODO(raddet): BibTeX citation
_CITATION = """
"""
class Raddet(tfds.core.GeneratorBasedBuilder):
"""DatasetBuilder for raddet dataset."""
VERSION = tfds.core.Version('1.1.0')
RELEASE_NOTES = {
'1.0.0': 'Initial release.',
}
def _info(self) -> tfds.core.DatasetInfo:
"""Returns the dataset metadata."""
return tfds.core.DatasetInfo(
builder=self,
description=_DESCRIPTION,
features=tfds.features.FeaturesDict({
# No need to keep 'spectrum' and 'image' field. Serialize their filenames is
# enough to load it and allows to save disk space.
'spectrum': tfds.features.Tensor(shape=(256, 64), dtype=tf.float32),
'image': tfds.features.Image(shape=(None, None, 3)),
'spectrum/filename': tfds.features.Text(),
'spectrum/id': tf.int64,
'sequence/id': tf.int64,
'objects': tfds.features.Sequence({
'area': tf.int64,
'bbox': tfds.features.BBoxFeature(),
'id': tf.int64,
'label': tfds.features.ClassLabel(names=["person", "bicycle", "car", "motorcycle", "bus", "truck"])
# Keep 0 class for BG
}),
}),
# If there's a common (input, target) tuple from the
# features, specify them here. They'll be used if
# `as_supervised=True` in `builder.as_dataset`.
supervised_keys=('spectrum', 'objects'), # Set to `None` to disable
homepage="",
citation=_CITATION,
disable_shuffling=True,
)
def _split_generators(self, dl_manager: tfds.download.DownloadManager):
"""Returns SplitGenerators."""
# TODO(carrada): Downloads the data and defines the splits
train_path = "/opt/stomach/radar1/RADDet dataset/train/"
test_path = "/opt/stomach/radar1/RADDet dataset/test/"
# TODO(carrada): Returns the Dict[split names, Iterator[Key, Example]]
return {
'train': self._generate_examples(train_path, 'train'),
'test': self._generate_examples(test_path, 'test'),
}
def _generate_examples(self, path, input_type="RD"):
classes_list = ["person", "bicycle", "car", "motorcycle", "bus", "truck"]
if path.split('/')[-2] == "train":
RAD_sequences = loader.readSequences(path)
else:
RAD_sequences = sorted(loader.readSequences(path))
count = 0
a_id = 0
s_id = 0
global_mean_log = 3.2438383
global_variance_log = 6.8367246
global_max_log = 10.0805629
global_min_log = 0.0
while count < len(RAD_sequences):
objects = []
RAD_filename = RAD_sequences[count]
RAD_complex = loader.readRAD(RAD_filename)
if RAD_complex is None:
raise ValueError("RAD file not found, please double check the path.")
RAD_data = helper.complexTo2channels(RAD_complex)
# Normalize data
RAD_data = (RAD_data - global_mean_log) / global_variance_log
# RAD_data = (RAD_data - global_min_log) / (global_max_log - global_min_log)
# Load GT instances
gt_filename = loader.gtfileFromRADfile(RAD_filename, path)
gt_instances = loader.readRadarInstances(gt_filename)
if gt_instances is None:
raise ValueError("gt file not found, please double check the path")
# Get RD spectrum
RD_data = helper. | getSumDim(RAD_data, target_axis=1) |
# Get RD bboxes
bboxes, classes = helper.readAndEncodeGtRD(gt_instances, RD_data.shape)
seq_id = RAD_filename.split('/')[-2].split('_')[-1]
for (box, class_) in zip(bboxes, classes):
bbox, area = helper.buildTfdsBoxes(box)
objects.append({
'bbox': bbox,
'label': classes_list.index(class_),
'area': area,
'id': a_id
})
a_id += 1
image_filename = loader.imgfileFromRADfile(RAD_filename, path)
example = {
'spectrum': RD_data.astype(np.float32),
'spectrum/filename': RAD_filename,
'sequence/id': int(seq_id),
'image': image_filename,
'spectrum/id': count,
'objects': objects
}
count += 1
yield count, example
| datasets/raddet_builder/raddet.py | colindecourt-darod-ab4878e | [
{
"filename": "datasets/raddet_builder/utils/loader.py",
"retrieved_chunk": " gt_file = os.path.join(prefix, \"gt\") + RAD_file_spec.replace(\"npy\", \"pickle\")\n return gt_file\ndef imgfileFromRADfile(RAD_file, prefix):\n \"\"\" Transfer RAD filename to gt filename \"\"\"\n RAD_file_spec = RAD_file.split(\"RAD\")[-1]\n gt_file = os.path.join(prefix, \"stereo_image\") + RAD_file_spec.replace(\"npy\", \"jpg\")\n return gt_file\ndef readRadarInstances(pickle_file):\n \"\"\" read output radar instances. \"\"\"\n if os.path.exists(pickle_file):",
"score": 0.7609596848487854
},
{
"filename": "darod/utils/viz_utils.py",
"retrieved_chunk": " ax1 = fig.add_subplot(121)\n ax2 = fig.add_subplot(122)\n rd_spectrum = norm2Image(rd_spectrum.numpy().squeeze())\n ax1.imshow(rd_spectrum)\n title = \"Range-Doppler\"\n ax1.set_xticks([0, 16, 32, 48, 63])\n ax1.set_xticklabels([-13, -6.5, 0, 6.5, 13])\n ax1.set_yticks([0, 64, 128, 192, 255])\n ax1.set_yticklabels([50, 37.5, 25, 12.5, 0])\n ax1.set_xlabel(\"velocity (m/s)\")",
"score": 0.7485033273696899
},
{
"filename": "datasets/raddet_builder/utils/loader.py",
"retrieved_chunk": " Please check if the file is organized properly.\")\n return sequences\ndef readRAD(filename):\n if os.path.exists(filename):\n return np.load(filename)\n else:\n return None\ndef gtfileFromRADfile(RAD_file, prefix):\n \"\"\" Transfer RAD filename to gt filename \"\"\"\n RAD_file_spec = RAD_file.split(\"RAD\")[-1]",
"score": 0.7409945726394653
},
{
"filename": "datasets/raddet_builder/utils/helper.py",
"retrieved_chunk": " \"\"\" get Log values \"\"\"\n if log_10:\n return scalar * np.log10(target_array + 1.)\n else:\n return target_array\ndef getSumDim(target_array, target_axis):\n \"\"\" sum up one dimension \"\"\"\n output = np.sum(target_array, axis=target_axis)\n return output",
"score": 0.738183856010437
},
{
"filename": "datasets/raddet_builder/__init__.py",
"retrieved_chunk": "\"\"\"raddet dataset.\"\"\"",
"score": 0.7373797297477722
}
] | python | getSumDim(RAD_data, target_axis=1) |
"""raddet dataset."""
import numpy as np
import tensorflow as tf
import tensorflow_datasets.public_api as tfds
from utils import loader, helper
# TODO(raddet): Markdown description that will appear on the catalog page.
_DESCRIPTION = """
Description is **formatted** as markdown.
It should also contain any processing which has been applied (if any),
(e.g. corrupted example skipped, images cropped,...):
"""
# TODO(raddet): BibTeX citation
_CITATION = """
"""
class Raddet(tfds.core.GeneratorBasedBuilder):
"""DatasetBuilder for raddet dataset."""
VERSION = tfds.core.Version('1.1.0')
RELEASE_NOTES = {
'1.0.0': 'Initial release.',
}
def _info(self) -> tfds.core.DatasetInfo:
"""Returns the dataset metadata."""
return tfds.core.DatasetInfo(
builder=self,
description=_DESCRIPTION,
features=tfds.features.FeaturesDict({
# No need to keep 'spectrum' and 'image' field. Serialize their filenames is
# enough to load it and allows to save disk space.
'spectrum': tfds.features.Tensor(shape=(256, 64), dtype=tf.float32),
'image': tfds.features.Image(shape=(None, None, 3)),
'spectrum/filename': tfds.features.Text(),
'spectrum/id': tf.int64,
'sequence/id': tf.int64,
'objects': tfds.features.Sequence({
'area': tf.int64,
'bbox': tfds.features.BBoxFeature(),
'id': tf.int64,
'label': tfds.features.ClassLabel(names=["person", "bicycle", "car", "motorcycle", "bus", "truck"])
# Keep 0 class for BG
}),
}),
# If there's a common (input, target) tuple from the
# features, specify them here. They'll be used if
# `as_supervised=True` in `builder.as_dataset`.
supervised_keys=('spectrum', 'objects'), # Set to `None` to disable
homepage="",
citation=_CITATION,
disable_shuffling=True,
)
def _split_generators(self, dl_manager: tfds.download.DownloadManager):
"""Returns SplitGenerators."""
# TODO(carrada): Downloads the data and defines the splits
train_path = "/opt/stomach/radar1/RADDet dataset/train/"
test_path = "/opt/stomach/radar1/RADDet dataset/test/"
# TODO(carrada): Returns the Dict[split names, Iterator[Key, Example]]
return {
'train': self._generate_examples(train_path, 'train'),
'test': self._generate_examples(test_path, 'test'),
}
def _generate_examples(self, path, input_type="RD"):
classes_list = ["person", "bicycle", "car", "motorcycle", "bus", "truck"]
if path.split('/')[-2] == "train":
RAD_sequences = loader.readSequences(path)
else:
RAD_sequences = sorted(loader.readSequences(path))
count = 0
a_id = 0
s_id = 0
global_mean_log = 3.2438383
global_variance_log = 6.8367246
global_max_log = 10.0805629
global_min_log = 0.0
while count < len(RAD_sequences):
objects = []
RAD_filename = RAD_sequences[count]
RAD_complex = loader.readRAD(RAD_filename)
if RAD_complex is None:
raise ValueError("RAD file not found, please double check the path.")
RAD_data = helper.complexTo2channels(RAD_complex)
# Normalize data
RAD_data = (RAD_data - global_mean_log) / global_variance_log
# RAD_data = (RAD_data - global_min_log) / (global_max_log - global_min_log)
# Load GT instances
gt_filename = loader.gtfileFromRADfile(RAD_filename, path)
gt_instances = loader.readRadarInstances(gt_filename)
if gt_instances is None:
raise ValueError("gt file not found, please double check the path")
# Get RD spectrum
RD_data = helper.getSumDim(RAD_data, target_axis=1)
# Get RD bboxes
bboxes, classes = helper.readAndEncodeGtRD(gt_instances, RD_data.shape)
seq_id = RAD_filename.split('/')[-2].split('_')[-1]
for (box, class_) in zip(bboxes, classes):
bbox, area = helper.buildTfdsBoxes(box)
objects.append({
'bbox': bbox,
'label': classes_list.index(class_),
'area': area,
'id': a_id
})
a_id += 1
image_filename = loader. | imgfileFromRADfile(RAD_filename, path) |
example = {
'spectrum': RD_data.astype(np.float32),
'spectrum/filename': RAD_filename,
'sequence/id': int(seq_id),
'image': image_filename,
'spectrum/id': count,
'objects': objects
}
count += 1
yield count, example
| datasets/raddet_builder/raddet.py | colindecourt-darod-ab4878e | [
{
"filename": "datasets/carrada_builder/carrada.py",
"retrieved_chunk": " 'label': label - 1,\n 'area': area,\n 'id': a_id\n })\n a_id += 1\n example = {\n 'spectrum': np.load(os.path.join(path, spectrum_fn)).astype(np.float32),\n 'spectrum/filename': spectrum_fn,\n 'sequence/id': sequence_id,\n 'image': os.path.join(path, image_fn),",
"score": 0.7720256447792053
},
{
"filename": "datasets/raddet_builder/utils/helper.py",
"retrieved_chunk": " for (box, class_) in zip(boxes, classes):\n yc, xc, h, w = box[0], box[2], box[3], box[5]\n y1, y2, x1, x2 = int(yc - h / 2), int(yc + h / 2), int(xc - w / 2), int(xc + w / 2)\n if x1 < 0:\n # Create 2 boxes\n x1 += x_shape\n box1 = [y1 / y_shape, x1 / x_shape, y2 / y_shape, x_shape / x_shape]\n box2 = [y1 / y_shape, 0 / x_shape, y2 / y_shape, x2 / x_shape]\n #\n new_boxes.append(box1)",
"score": 0.7583960294723511
},
{
"filename": "datasets/raddet_builder/utils/helper.py",
"retrieved_chunk": " new_classes.append(class_)\n #\n new_boxes.append(box2)\n new_classes.append(class_)\n else:\n new_boxes.append([y1 / y_shape, x1 / x_shape, y2 / y_shape, x2 / x_shape])\n new_classes.append(class_)\n return new_boxes, new_classes\ndef buildTfdsBoxes(box):\n ymin, xmin, ymax, xmax = box",
"score": 0.7481303215026855
},
{
"filename": "eval.py",
"retrieved_chunk": " # Prepare dataset\n if dataset == \"carrada\":\n batched_test_dataset, dataset_info = data_utils.prepare_dataset(split=\"test\", config=config, seed=seed)\n elif dataset == \"raddet\":\n batched_test_dataset, dataset_info = data_utils.prepare_dataset(split=\"test\", config=config, seed=seed)\n else:\n raise NotImplementedError(\"This dataset doesn't exist.\")\n len_test_dataset = data_utils.get_total_item_size(dataset_info, \"test\")\n anchors = bbox_utils.anchors_generation(config, train=False)\n faster_rcnn_model = model.DAROD(config, anchors)",
"score": 0.7471563816070557
},
{
"filename": "darod/utils/viz_utils.py",
"retrieved_chunk": " linestyle=\"dashed\", color=color, facecolor=facecolor, edgecolor=color, fill=False)\n ax.add_patch(rect)\n label = int(label.numpy())\n ax.text(x1 + 1, y1 - 3, class_names[label - 1] + \" \" + str(score), size=10, verticalalignment='baseline',\n color='w', backgroundcolor=\"none\",\n bbox={'facecolor': color, 'alpha': 0.5,\n 'pad': 2, 'edgecolor': 'none'})\ndef showCameraRD(camera_image, rd_spectrum, boxes, labels, class_names, scores=None, gt_boxes=None, gt_labels=None,\n dataset=\"carrada\"):\n fig = plt.figure(figsize=(15, 5))",
"score": 0.7463016510009766
}
] | python | imgfileFromRADfile(RAD_filename, path) |
import time
import tensorflow as tf
from darod.models import model
from darod.trainers.trainer import Trainer
from darod.utils import data_utils, bbox_utils, io_utils
seed = 42
# Set memory growth to avoid GPU to crash
physical_devices = tf.config.experimental.list_physical_devices('GPU')
tf.config.experimental.set_memory_growth(physical_devices[0], True)
# Load config from arguments
args = io_utils.handle_args()
config = io_utils.args2config(args)
epochs = config["training"]['epochs']
batch_size = config["training"]["batch_size"]
# Prepare dataset
if config["data"]["dataset"] == "carrada":
batched_train_dataset, dataset_info = data_utils. | prepare_dataset(split="train", config=config, seed=seed) |
num_train_example = data_utils.get_total_item_size(dataset_info, "train")
#
batched_test_dataset, _ = data_utils.prepare_dataset(split="test", config=config, seed=seed)
batched_val_dataset, _ = data_utils.prepare_dataset(split="val", config=config, seed=seed)
else:
batched_train_dataset, dataset_info = data_utils.prepare_dataset(split="train[:90%]", config=config, seed=seed)
num_train_example = data_utils.get_total_item_size(dataset_info, "train[:90%]")
#
batched_val_dataset, _ = data_utils.prepare_dataset(split="train[90%:]", config=config, seed=seed)
batched_test_dataset, _ = data_utils.prepare_dataset(split="test", config=config, seed=seed)
labels = data_utils.get_labels(dataset_info)
config["data"]["total_labels"] = len(labels) + 1
labels = ["bg"] + labels
config["training"]["num_steps_epoch"] = num_train_example
config["training"]["seed"] = seed
# Generate anchors
anchors = bbox_utils.anchors_generation(config, train=True)
# Load model
faster_rcnn_model = model.DAROD(config, anchors)
# Build the model
_ = faster_rcnn_model(tf.zeros([1, 256, 64, config["model"]["input_size"][-1]]))
faster_rcnn_model.summary()
# Train model
trainer = Trainer(config=config, model=faster_rcnn_model, experiment_name=config["log"]["exp"],
backbone=config["model"]["backbone"], labels=labels, backup_dir=args.backup_dir)
trainer.train(anchors, batched_train_dataset, batched_val_dataset)
| train.py | colindecourt-darod-ab4878e | [
{
"filename": "vizualize_testdata.py",
"retrieved_chunk": " target_id = args.seq_id\n eval_best = args.eval_best if args.eval_best is not None else False\n # Prepare dataset\n if dataset == \"carrada\":\n batched_test_dataset, dataset_info = data_utils.prepare_dataset(split=\"test\", config=config, seed=seed)\n elif dataset == \"raddet\":\n batched_test_dataset, dataset_info = data_utils.prepare_dataset(split=\"test\", config=config, seed=seed)\n else:\n raise NotImplementedError(\"This dataset doesn't exist.\")\n anchors = bbox_utils.anchors_generation(config, train=False)",
"score": 0.845569908618927
},
{
"filename": "eval.py",
"retrieved_chunk": "def main():\n args = io_utils.handle_args_eval()\n # summary_writer = tf.summary.create_file_writer(args.path)\n config_pth = os.path.join(args.path, \"config.json\")\n with open(config_pth, 'r') as file:\n config = json.load(file)\n dataset = config[\"data\"][\"dataset\"]\n labels = config[\"data\"][\"labels\"]\n labels = [\"bg\"] + labels\n seed = config[\"training\"][\"seed\"]",
"score": 0.8359775543212891
},
{
"filename": "eval.py",
"retrieved_chunk": " # Prepare dataset\n if dataset == \"carrada\":\n batched_test_dataset, dataset_info = data_utils.prepare_dataset(split=\"test\", config=config, seed=seed)\n elif dataset == \"raddet\":\n batched_test_dataset, dataset_info = data_utils.prepare_dataset(split=\"test\", config=config, seed=seed)\n else:\n raise NotImplementedError(\"This dataset doesn't exist.\")\n len_test_dataset = data_utils.get_total_item_size(dataset_info, \"test\")\n anchors = bbox_utils.anchors_generation(config, train=False)\n faster_rcnn_model = model.DAROD(config, anchors)",
"score": 0.8335272073745728
},
{
"filename": "vizualize_testdata.py",
"retrieved_chunk": "def main():\n args = io_utils.handle_args_viz()\n config_pth = os.path.join(args.path, \"config.json\")\n with open(config_pth, 'r') as file:\n config = json.load(file)\n dataset = config[\"data\"][\"dataset\"]\n labels = config[\"data\"][\"labels\"]\n labels = [\"bg\"] + labels\n seed = config[\"training\"][\"seed\"]\n layout = config[\"model\"][\"layout\"]",
"score": 0.8301860094070435
},
{
"filename": "darod/utils/io_utils.py",
"retrieved_chunk": " \"batch_size\"]\n config[\"training\"][\"epochs\"] = args.n_epochs if args.n_epochs is not None else config[\"training\"][\"epochs\"]\n config[\"training\"][\"use_bn\"] = args.use_bn if args.use_bn is not None else config[\"training\"][\"use_bn\"]\n config[\"training\"][\"use_aug\"] = args.use_aug if args.use_aug is not None else config[\"training\"][\"use_aug\"]\n config[\"training\"][\"use_doppler\"] = args.use_doppler if args.use_doppler is not None else config[\"training\"][\n \"use_doppler\"]\n config[\"training\"][\"use_dropout\"] = args.use_dropout if args.use_dropout is not None else config[\"training\"][\n \"use_dropout\"]\n config[\"training\"][\"optimizer\"] = args.optimizer if args.optimizer is not None else config[\"training\"][\"optimizer\"]\n config[\"training\"][\"lr\"] = args.lr if args.lr is not None else config[\"training\"][\"lr\"]",
"score": 0.8224732279777527
}
] | python | prepare_dataset(split="train", config=config, seed=seed) |
import time
import tensorflow as tf
from darod.models import model
from darod.trainers.trainer import Trainer
from darod.utils import data_utils, bbox_utils, io_utils
seed = 42
# Set memory growth to avoid GPU to crash
physical_devices = tf.config.experimental.list_physical_devices('GPU')
tf.config.experimental.set_memory_growth(physical_devices[0], True)
# Load config from arguments
args = io_utils.handle_args()
config = io_utils.args2config(args)
epochs = config["training"]['epochs']
batch_size = config["training"]["batch_size"]
# Prepare dataset
if config["data"]["dataset"] == "carrada":
batched_train_dataset, dataset_info = data_utils.prepare_dataset(split="train", config=config, seed=seed)
num_train_example = data_utils.get_total_item_size(dataset_info, "train")
#
batched_test_dataset, _ = data_utils.prepare_dataset(split="test", config=config, seed=seed)
batched_val_dataset, _ = data_utils.prepare_dataset(split="val", config=config, seed=seed)
else:
batched_train_dataset, dataset_info = data_utils.prepare_dataset(split="train[:90%]", config=config, seed=seed)
num_train_example = data_utils.get_total_item_size(dataset_info, "train[:90%]")
#
batched_val_dataset, _ = data_utils.prepare_dataset(split="train[90%:]", config=config, seed=seed)
batched_test_dataset, _ = data_utils.prepare_dataset(split="test", config=config, seed=seed)
labels = data_utils.get_labels(dataset_info)
config["data"]["total_labels"] = len(labels) + 1
labels = ["bg"] + labels
config["training"]["num_steps_epoch"] = num_train_example
config["training"]["seed"] = seed
# Generate anchors
anchors = bbox_utils.anchors_generation(config, train=True)
# Load model
faster_rcnn_model = model.DAROD(config, anchors)
# Build the model
_ = faster_rcnn_model(tf.zeros([1, 256, 64, config["model"]["input_size"][-1]]))
faster_rcnn_model.summary()
# Train model
trainer = Trainer(config=config, model=faster_rcnn_model, experiment_name=config["log"]["exp"],
backbone=config["model"]["backbone"], labels=labels, backup_dir=args.backup_dir)
trainer. | train(anchors, batched_train_dataset, batched_val_dataset) | train.py | colindecourt-darod-ab4878e | [
{
"filename": "vizualize_testdata.py",
"retrieved_chunk": " faster_rcnn_model = model.R2D2(config, anchors)\n if layout == \"2D\":\n faster_rcnn_model.build(input_shape=(None, 256, 64, 1))\n else:\n fake_input = tf.zeros(shape=(config[\"training\"][\"batch_size\"], config[\"model\"][\"sequence_len\"], 256, 64, 1))\n _ = faster_rcnn_model(fake_input)\n faster_rcnn_model.summary()\n def restore_ckpt(config, log_pth):\n optimizer = config[\"training\"][\"optimizer\"]\n lr = config[\"training\"][\"lr\"]",
"score": 0.8789032697677612
},
{
"filename": "eval.py",
"retrieved_chunk": " # Prepare dataset\n if dataset == \"carrada\":\n batched_test_dataset, dataset_info = data_utils.prepare_dataset(split=\"test\", config=config, seed=seed)\n elif dataset == \"raddet\":\n batched_test_dataset, dataset_info = data_utils.prepare_dataset(split=\"test\", config=config, seed=seed)\n else:\n raise NotImplementedError(\"This dataset doesn't exist.\")\n len_test_dataset = data_utils.get_total_item_size(dataset_info, \"test\")\n anchors = bbox_utils.anchors_generation(config, train=False)\n faster_rcnn_model = model.DAROD(config, anchors)",
"score": 0.8537411689758301
},
{
"filename": "eval.py",
"retrieved_chunk": " faster_rcnn_model.build(input_shape=(None, 256, 64, config[\"model\"][\"input_size\"][-1]))\n faster_rcnn_model.summary()\n def restore_ckpt(config, log_pth):\n optimizer = config[\"training\"][\"optimizer\"]\n lr = config[\"training\"][\"lr\"]\n use_scheduler = config[\"training\"][\"scheduler\"]\n momentum = config[\"training\"][\"momentum\"]\n if optimizer == \"SGD\":\n optimizer = tf.optimizers.SGD(learning_rate=lr, momentum=momentum)\n elif optimizer == \"adam\":",
"score": 0.8521423935890198
},
{
"filename": "vizualize_testdata.py",
"retrieved_chunk": " else:\n raise NotImplemented(\"Not supported optimizer {}\".format(optimizer))\n global_step = tf.Variable(1, trainable=False, dtype=tf.int64)\n ckpt = tf.train.Checkpoint(optimizer=optimizer, model=faster_rcnn_model, step=global_step)\n manager = tf.train.CheckpointManager(ckpt, log_pth, max_to_keep=5)\n ckpt.restore(manager.latest_checkpoint)\n # ------ Start evaluation with latest ckpt ------ #\n print(\"Start creation of animation using the latest checkpoint.\")\n if eval_best:\n faster_rcnn_model.load_weights(os.path.join(args.path, \"best-model.h5\"))",
"score": 0.8356677889823914
},
{
"filename": "darod/models/model.py",
"retrieved_chunk": " iou_threshold=self.iou_threshold,\n max_output_size_per_class=self.max_total_size,\n max_total_size=self.max_total_size,\n score_threshold=self.score_threshold)\n #\n return tf.stop_gradient(final_bboxes), tf.stop_gradient(final_labels), tf.stop_gradient(final_scores)\nclass DAROD(tf.keras.Model):\n def __init__(self, config, anchors):\n \"\"\"\n Implement DAROD model",
"score": 0.8333883881568909
}
] | python | train(anchors, batched_train_dataset, batched_val_dataset) |
|
import time
import numpy as np
import tensorflow as tf
import tensorflow_addons as tfa
from ..utils import bbox_utils
def compute_eta(total_duration, epoch_duration, epoch, total_epochs):
"""Compute training ETA"""
total_duration += epoch_duration
eta = (total_epochs - epoch) * total_duration / (epoch)
return time.strftime("%H:%M:%S", time.gmtime(eta)), total_duration
def randomly_select_xyz_mask(mask, select_xyz, seed):
"""
Selecting x, y, z number of True elements for corresponding batch and replacing others to False
:param mask: (batch_size, [m_bool_value])
:param select_xyz: (batch_size, [m_bool_value])
:param seed: seed
:return: selected_valid_mask = (batch_size, [m_bool_value])
"""
maxval = tf.reduce_max(select_xyz) * 10
random_mask = tf.random.uniform(tf.shape(mask), minval=1, maxval=maxval, dtype=tf.int32, seed=seed)
multiplied_mask = tf.cast(mask, tf.int32) * random_mask
sorted_mask = tf.argsort(multiplied_mask, direction="DESCENDING")
sorted_mask_indices = tf.argsort(sorted_mask)
selected_mask = tf.less(sorted_mask_indices, tf.expand_dims(select_xyz, 1))
return tf.logical_and(mask, selected_mask)
def calculate_rpn_actual_outputs(anchors, gt_boxes, gt_labels, config):
"""
Generating one step data for training or inference. Batch operations supported.
:param anchors: (total_anchors, [y1, x1, y2, x2]) these values in normalized format between [0, 1]
:param gt_boxes: (batch_size, gt_box_size, [y1, x1, y2, x2]) these values in normalized format between [0, 1]
:param gt_labels: (batch_size, gt_box_size)
:param config: dictionary
:return: bbox_deltas = (batch_size, total_anchors, [delta_y, delta_x, delta_h, delta_w])
bbox_labels = (batch_size, feature_map_shape, feature_map_shape, anchor_count)
"""
batch_size = tf.shape(gt_boxes)[0]
anchor_count = config["rpn"]["anchor_count"]
total_pos_bboxes = int(config["rpn"]["rpn_boxes"] / 2)
total_neg_bboxes = int(config["rpn"]["rpn_boxes"] / 2)
variances = config["rpn"]["variances"]
adaptive_ratio = config["rpn"]["adaptive_ratio"]
postive_th = config["rpn"]["positive_th"]
#
output_height, output_width = config["model"]["feature_map_shape"][0], config["model"]["feature_map_shape"][1]
# Calculate iou values between each bboxes and ground truth boxes
iou_map = bbox_utils.generate_iou_map(anchors, gt_boxes)
# Get max index value for each row
max_indices_each_row = tf.argmax(iou_map, axis=2, output_type=tf.int32)
# Get max index value for each column
max_indices_each_column = tf.argmax(iou_map, axis=1, output_type=tf.int32)
# IoU map has iou values for every gt boxes and we merge these values column wise
merged_iou_map = tf.reduce_max(iou_map, axis=2)
#
pos_mask = tf.greater(merged_iou_map, postive_th)
#
valid_indices_cond = tf.not_equal(gt_labels, -1)
valid_indices = tf.cast(tf.where(valid_indices_cond), tf.int32)
valid_max_indices = max_indices_each_column[valid_indices_cond]
#
scatter_bbox_indices = tf.stack([valid_indices[..., 0], valid_max_indices], 1)
max_pos_mask = tf.scatter_nd(scatter_bbox_indices, tf.fill((tf.shape(valid_indices)[0],), True), tf.shape(pos_mask))
pos_mask = tf.logical_and(tf.logical_or(pos_mask, max_pos_mask), tf.reduce_sum(anchors, axis=-1) != 0.0)
pos_mask = randomly_select_xyz_mask(pos_mask, tf.constant([total_pos_bboxes], dtype=tf.int32),
seed=config["training"]["seed"])
#
pos_count = tf.reduce_sum(tf.cast(pos_mask, tf.int32), axis=-1)
# Keep a 50%/50% ratio of positive/negative samples
if adaptive_ratio:
neg_count = 2 * pos_count
else:
neg_count = (total_pos_bboxes + total_neg_bboxes) - pos_count
#
neg_mask = tf.logical_and(tf.logical_and(tf.less(merged_iou_map, 0.3), tf.logical_not(pos_mask)),
tf.reduce_sum(anchors, axis=-1) != 0.0)
neg_mask = randomly_select_xyz_mask(neg_mask, neg_count, seed=config["training"]["seed"])
#
pos_labels = tf.where(pos_mask, tf.ones_like(pos_mask, dtype=tf.float32), tf.constant(-1.0, dtype=tf.float32))
neg_labels = tf.cast(neg_mask, dtype=tf.float32)
bbox_labels = tf.add(pos_labels, neg_labels)
#
gt_boxes_map = tf.gather(gt_boxes, max_indices_each_row, batch_dims=1)
# Replace negative bboxes with zeros
expanded_gt_boxes = tf.where(tf.expand_dims(pos_mask, -1), gt_boxes_map, tf.zeros_like(gt_boxes_map))
# Calculate delta values between anchors and ground truth bboxes
bbox_deltas = bbox_utils. | get_deltas_from_bboxes(anchors, expanded_gt_boxes) / variances |
#
bbox_labels = tf.reshape(bbox_labels, (batch_size, output_height, output_width, anchor_count))
#
return bbox_deltas, bbox_labels
def frcnn_cls_loss(*args):
"""
Calculating faster rcnn class loss value.
:param args: could be (y_true, y_pred) or ((y_true, y_pred), )
:return: CE loss
"""
y_true, y_pred = args if len(args) == 2 else args[0]
loss_fn = tf.losses.CategoricalCrossentropy(reduction=tf.losses.Reduction.NONE, from_logits=True)
loss_for_all = loss_fn(y_true, y_pred)
#
cond = tf.reduce_any(tf.not_equal(y_true, tf.constant(0.0)), axis=-1)
mask = tf.cast(cond, dtype=tf.float32)
#
conf_loss = tf.reduce_sum(mask * loss_for_all)
total_boxes = tf.maximum(1.0, tf.reduce_sum(mask))
return tf.math.divide_no_nan(conf_loss, total_boxes)
def rpn_cls_loss(*args):
"""
Calculating rpn class loss value.
:param args: could be (y_true, y_pred) or ((y_true, y_pred), )
:return: CE loss
"""
y_true, y_pred = args if len(args) == 2 else args[0]
indices = tf.where(tf.not_equal(y_true, tf.constant(-1.0, dtype=tf.float32)))
target = tf.gather_nd(y_true, indices)
output = tf.gather_nd(y_pred, indices)
lf = tf.losses.BinaryCrossentropy(from_logits=True)
return lf(target, output)
def reg_loss(*args):
"""
Calculating rpn / faster rcnn regression loss value.
:param args: could be (y_true, y_pred) or ((y_true, y_pred), )
:return: regression loss val
"""
y_true, y_pred = args if len(args) == 2 else args[0]
y_pred = tf.reshape(y_pred, (tf.shape(y_pred)[0], -1, 4))
#
loss_fn = tf.losses.Huber(reduction=tf.losses.Reduction.NONE, delta=1 / 9)
loss_for_all = loss_fn(y_true, y_pred)
# loss_for_all = tf.reduce_sum(loss_for_all, axis=-1)
#
pos_cond = tf.reduce_any(tf.not_equal(y_true, tf.constant(0.0)), axis=-1)
pos_mask = tf.cast(pos_cond, dtype=tf.float32)
#
loc_loss = tf.reduce_sum(tf.math.multiply_no_nan(pos_mask, loss_for_all))
total_pos_bboxes = tf.maximum(1.0, tf.reduce_sum(pos_mask))
return tf.math.divide_no_nan(loc_loss, total_pos_bboxes)
def giou_loss(y_true, y_pred, roi_bboxes):
"""
Calculating rpn / faster rcnn regression loss value.
:param y_true: ground truth
:param y_pred: predictied deltas
:param roi_bboxes: predicted boxes
:return: regression loss val
"""
y_pred = tf.reshape(y_pred, (tf.shape(y_pred)[0], -1, 4))
y_pred = bbox_utils.get_bboxes_from_deltas(roi_bboxes, y_pred)
#
loss_fn = tfa.losses.GIoULoss(reduction=tf.losses.Reduction.NONE)
loss_for_all = loss_fn(y_true, y_pred)
# loss_for_all = tf.reduce_sum(loss_for_all, axis=-1)
#
pos_cond = tf.reduce_any(tf.not_equal(y_true, tf.constant(0.0)), axis=-1)
pos_mask = tf.cast(pos_cond, dtype=tf.float32)
#
loc_loss = tf.reduce_sum(tf.math.multiply_no_nan(pos_mask, loss_for_all))
total_pos_bboxes = tf.maximum(1.0, tf.reduce_sum(pos_mask))
return tf.math.divide_no_nan(loc_loss, total_pos_bboxes)
def darod_loss(rpn_cls_pred, rpn_delta_pred, frcnn_cls_pred, frcnn_reg_pred,
bbox_labels, bbox_deltas, frcnn_reg_actuals, frcnn_cls_actuals):
"""
Calculate loss function for DAROD model
:param rpn_cls_pred: RPN classification pred
:param rpn_delta_pred: RPN regression pred
:param frcnn_cls_pred: FRCNN classification pred
:param frcnn_reg_pred: FRCNN regression pred
:param bbox_labels: bounding boxes labels
:param bbox_deltas: bounding boxes deltas
:param frcnn_reg_actuals: faster rcnn regression labels
:param frcnn_cls_actuals: faster rcnn classification labels
:return: faster rcnn loss
"""
rpn_regression_loss = reg_loss(bbox_deltas, rpn_delta_pred)
rpn_classif_loss = rpn_cls_loss(bbox_labels, rpn_cls_pred)
frcnn_regression_loss = reg_loss(frcnn_reg_actuals, frcnn_reg_pred)
frcnn_classif_loss = frcnn_cls_loss(frcnn_cls_actuals, frcnn_cls_pred)
return rpn_regression_loss, rpn_classif_loss, frcnn_regression_loss, frcnn_classif_loss
def darod_loss_giou(rpn_cls_pred, rpn_delta_pred, frcnn_cls_pred, frcnn_reg_pred,
bbox_labels, bbox_deltas, frcnn_reg_actuals, frcnn_cls_actuals, roi_bboxes):
rpn_regression_loss = reg_loss(bbox_deltas, rpn_delta_pred)
rpn_classif_loss = rpn_cls_loss(bbox_labels, rpn_cls_pred)
frcnn_regression_loss = giou_loss(frcnn_reg_actuals, frcnn_reg_pred, roi_bboxes) / 10
frcnn_classif_loss = frcnn_cls_loss(frcnn_cls_actuals, frcnn_cls_pred)
return rpn_regression_loss, rpn_classif_loss, frcnn_regression_loss, frcnn_classif_loss
| darod/utils/train_utils.py | colindecourt-darod-ab4878e | [
{
"filename": "darod/layers/frcnn_layers.py",
"retrieved_chunk": " pos_gt_labels = tf.where(pos_mask, gt_labels_map, tf.constant(-1, dtype=tf.int32))\n neg_gt_labels = tf.cast(neg_mask, dtype=tf.int32)\n expanded_gt_labels = pos_gt_labels + neg_gt_labels\n #\n roi_bbox_deltas = bbox_utils.get_deltas_from_bboxes(roi_bboxes, expanded_gt_boxes) / variances\n #\n roi_bbox_labels = tf.one_hot(expanded_gt_labels, total_labels)\n scatter_indices = tf.tile(tf.expand_dims(roi_bbox_labels, -1), (1, 1, 1, 4))\n roi_bbox_deltas = scatter_indices * tf.expand_dims(roi_bbox_deltas, -2)\n roi_bbox_deltas = tf.reshape(roi_bbox_deltas, (batch_size, total_bboxes * total_labels, 4))",
"score": 0.9409282207489014
},
{
"filename": "darod/layers/frcnn_layers.py",
"retrieved_chunk": " neg_mask = train_utils.randomly_select_xyz_mask(neg_mask, total_neg_bboxes,\n seed=self.config[\"training\"][\"seed\"])\n else:\n neg_mask = train_utils.randomly_select_xyz_mask(neg_mask, tf.constant([total_neg_bboxes], dtype=tf.int32),\n seed=self.config[\"training\"][\"seed\"])\n #\n gt_boxes_map = tf.gather(gt_boxes, max_indices_each_gt_box, batch_dims=1)\n expanded_gt_boxes = tf.where(tf.expand_dims(pos_mask, axis=-1), gt_boxes_map, tf.zeros_like(gt_boxes_map))\n #\n gt_labels_map = tf.gather(gt_labels, max_indices_each_gt_box, batch_dims=1)",
"score": 0.8998781442642212
},
{
"filename": "darod/layers/frcnn_layers.py",
"retrieved_chunk": " variances = self.config[\"fastrcnn\"][\"variances_boxes\"]\n adaptive_ratio = self.config[\"fastrcnn\"][\"adaptive_ratio\"]\n positive_th = self.config[\"fastrcnn\"][\"positive_th\"]\n batch_size, total_bboxes = tf.shape(roi_bboxes)[0], tf.shape(roi_bboxes)[1]\n # Calculate iou values between each bboxes and ground truth boxes\n iou_map = bbox_utils.generate_iou_map(roi_bboxes, gt_boxes)\n # Get max index value for each row\n max_indices_each_gt_box = tf.argmax(iou_map, axis=2, output_type=tf.int32)\n # IoU map has iou values for every gt boxes and we merge these values column wise\n merged_iou_map = tf.reduce_max(iou_map, axis=2)",
"score": 0.8495885729789734
},
{
"filename": "darod/layers/frcnn_layers.py",
"retrieved_chunk": " #\n pos_mask = tf.greater(merged_iou_map, positive_th)\n pos_mask = train_utils.randomly_select_xyz_mask(pos_mask, tf.constant([total_pos_bboxes], dtype=tf.int32),\n seed=self.config[\"training\"][\"seed\"])\n #\n neg_mask = tf.logical_and(tf.less(merged_iou_map, positive_th), tf.greater_equal(merged_iou_map, 0.0))\n if adaptive_ratio:\n pos_count = tf.reduce_sum(tf.cast(pos_mask, tf.int32), axis=-1)\n # Keep a 33%/66% ratio of positive/negative bboxes\n total_neg_bboxes = tf.multiply(pos_count + 1, 3)",
"score": 0.8398391008377075
},
{
"filename": "darod/layers/frcnn_layers.py",
"retrieved_chunk": " batch_size = tf.shape(rpn_bbox_deltas)[0]\n rpn_bbox_deltas = tf.reshape(rpn_bbox_deltas, (batch_size, total_anchors, 4))\n # Apply softmax to rpn_labels to obtain probabilities\n rpn_labels = tf.nn.softmax(rpn_labels)\n rpn_labels = tf.reshape(rpn_labels, (batch_size, total_anchors))\n #\n rpn_bbox_deltas *= variances\n rpn_bboxes = bbox_utils.get_bboxes_from_deltas(anchors, rpn_bbox_deltas)\n _, pre_indices = tf.nn.top_k(rpn_labels, pre_nms_topn)\n #",
"score": 0.8352044820785522
}
] | python | get_deltas_from_bboxes(anchors, expanded_gt_boxes) / variances |
import time
import numpy as np
import tensorflow as tf
import tensorflow_addons as tfa
from ..utils import bbox_utils
def compute_eta(total_duration, epoch_duration, epoch, total_epochs):
"""Compute training ETA"""
total_duration += epoch_duration
eta = (total_epochs - epoch) * total_duration / (epoch)
return time.strftime("%H:%M:%S", time.gmtime(eta)), total_duration
def randomly_select_xyz_mask(mask, select_xyz, seed):
"""
Selecting x, y, z number of True elements for corresponding batch and replacing others to False
:param mask: (batch_size, [m_bool_value])
:param select_xyz: (batch_size, [m_bool_value])
:param seed: seed
:return: selected_valid_mask = (batch_size, [m_bool_value])
"""
maxval = tf.reduce_max(select_xyz) * 10
random_mask = tf.random.uniform(tf.shape(mask), minval=1, maxval=maxval, dtype=tf.int32, seed=seed)
multiplied_mask = tf.cast(mask, tf.int32) * random_mask
sorted_mask = tf.argsort(multiplied_mask, direction="DESCENDING")
sorted_mask_indices = tf.argsort(sorted_mask)
selected_mask = tf.less(sorted_mask_indices, tf.expand_dims(select_xyz, 1))
return tf.logical_and(mask, selected_mask)
def calculate_rpn_actual_outputs(anchors, gt_boxes, gt_labels, config):
"""
Generating one step data for training or inference. Batch operations supported.
:param anchors: (total_anchors, [y1, x1, y2, x2]) these values in normalized format between [0, 1]
:param gt_boxes: (batch_size, gt_box_size, [y1, x1, y2, x2]) these values in normalized format between [0, 1]
:param gt_labels: (batch_size, gt_box_size)
:param config: dictionary
:return: bbox_deltas = (batch_size, total_anchors, [delta_y, delta_x, delta_h, delta_w])
bbox_labels = (batch_size, feature_map_shape, feature_map_shape, anchor_count)
"""
batch_size = tf.shape(gt_boxes)[0]
anchor_count = config["rpn"]["anchor_count"]
total_pos_bboxes = int(config["rpn"]["rpn_boxes"] / 2)
total_neg_bboxes = int(config["rpn"]["rpn_boxes"] / 2)
variances = config["rpn"]["variances"]
adaptive_ratio = config["rpn"]["adaptive_ratio"]
postive_th = config["rpn"]["positive_th"]
#
output_height, output_width = config["model"]["feature_map_shape"][0], config["model"]["feature_map_shape"][1]
# Calculate iou values between each bboxes and ground truth boxes
iou_map = bbox_utils.generate_iou_map(anchors, gt_boxes)
# Get max index value for each row
max_indices_each_row = tf.argmax(iou_map, axis=2, output_type=tf.int32)
# Get max index value for each column
max_indices_each_column = tf.argmax(iou_map, axis=1, output_type=tf.int32)
# IoU map has iou values for every gt boxes and we merge these values column wise
merged_iou_map = tf.reduce_max(iou_map, axis=2)
#
pos_mask = tf.greater(merged_iou_map, postive_th)
#
valid_indices_cond = tf.not_equal(gt_labels, -1)
valid_indices = tf.cast(tf.where(valid_indices_cond), tf.int32)
valid_max_indices = max_indices_each_column[valid_indices_cond]
#
scatter_bbox_indices = tf.stack([valid_indices[..., 0], valid_max_indices], 1)
max_pos_mask = tf.scatter_nd(scatter_bbox_indices, tf.fill((tf.shape(valid_indices)[0],), True), tf.shape(pos_mask))
pos_mask = tf.logical_and(tf.logical_or(pos_mask, max_pos_mask), tf.reduce_sum(anchors, axis=-1) != 0.0)
pos_mask = randomly_select_xyz_mask(pos_mask, tf.constant([total_pos_bboxes], dtype=tf.int32),
seed=config["training"]["seed"])
#
pos_count = tf.reduce_sum(tf.cast(pos_mask, tf.int32), axis=-1)
# Keep a 50%/50% ratio of positive/negative samples
if adaptive_ratio:
neg_count = 2 * pos_count
else:
neg_count = (total_pos_bboxes + total_neg_bboxes) - pos_count
#
neg_mask = tf.logical_and(tf.logical_and(tf.less(merged_iou_map, 0.3), tf.logical_not(pos_mask)),
tf.reduce_sum(anchors, axis=-1) != 0.0)
neg_mask = randomly_select_xyz_mask(neg_mask, neg_count, seed=config["training"]["seed"])
#
pos_labels = tf.where(pos_mask, tf.ones_like(pos_mask, dtype=tf.float32), tf.constant(-1.0, dtype=tf.float32))
neg_labels = tf.cast(neg_mask, dtype=tf.float32)
bbox_labels = tf.add(pos_labels, neg_labels)
#
gt_boxes_map = tf.gather(gt_boxes, max_indices_each_row, batch_dims=1)
# Replace negative bboxes with zeros
expanded_gt_boxes = tf.where(tf.expand_dims(pos_mask, -1), gt_boxes_map, tf.zeros_like(gt_boxes_map))
# Calculate delta values between anchors and ground truth bboxes
bbox_deltas = bbox_utils.get_deltas_from_bboxes(anchors, expanded_gt_boxes) / variances
#
bbox_labels = tf.reshape(bbox_labels, (batch_size, output_height, output_width, anchor_count))
#
return bbox_deltas, bbox_labels
def frcnn_cls_loss(*args):
"""
Calculating faster rcnn class loss value.
:param args: could be (y_true, y_pred) or ((y_true, y_pred), )
:return: CE loss
"""
y_true, y_pred = args if len(args) == 2 else args[0]
loss_fn = tf.losses.CategoricalCrossentropy(reduction=tf.losses.Reduction.NONE, from_logits=True)
loss_for_all = loss_fn(y_true, y_pred)
#
cond = tf.reduce_any(tf.not_equal(y_true, tf.constant(0.0)), axis=-1)
mask = tf.cast(cond, dtype=tf.float32)
#
conf_loss = tf.reduce_sum(mask * loss_for_all)
total_boxes = tf.maximum(1.0, tf.reduce_sum(mask))
return tf.math.divide_no_nan(conf_loss, total_boxes)
def rpn_cls_loss(*args):
"""
Calculating rpn class loss value.
:param args: could be (y_true, y_pred) or ((y_true, y_pred), )
:return: CE loss
"""
y_true, y_pred = args if len(args) == 2 else args[0]
indices = tf.where(tf.not_equal(y_true, tf.constant(-1.0, dtype=tf.float32)))
target = tf.gather_nd(y_true, indices)
output = tf.gather_nd(y_pred, indices)
lf = tf.losses.BinaryCrossentropy(from_logits=True)
return lf(target, output)
def reg_loss(*args):
"""
Calculating rpn / faster rcnn regression loss value.
:param args: could be (y_true, y_pred) or ((y_true, y_pred), )
:return: regression loss val
"""
y_true, y_pred = args if len(args) == 2 else args[0]
y_pred = tf.reshape(y_pred, (tf.shape(y_pred)[0], -1, 4))
#
loss_fn = tf.losses.Huber(reduction=tf.losses.Reduction.NONE, delta=1 / 9)
loss_for_all = loss_fn(y_true, y_pred)
# loss_for_all = tf.reduce_sum(loss_for_all, axis=-1)
#
pos_cond = tf.reduce_any(tf.not_equal(y_true, tf.constant(0.0)), axis=-1)
pos_mask = tf.cast(pos_cond, dtype=tf.float32)
#
loc_loss = tf.reduce_sum(tf.math.multiply_no_nan(pos_mask, loss_for_all))
total_pos_bboxes = tf.maximum(1.0, tf.reduce_sum(pos_mask))
return tf.math.divide_no_nan(loc_loss, total_pos_bboxes)
def giou_loss(y_true, y_pred, roi_bboxes):
"""
Calculating rpn / faster rcnn regression loss value.
:param y_true: ground truth
:param y_pred: predictied deltas
:param roi_bboxes: predicted boxes
:return: regression loss val
"""
y_pred = tf.reshape(y_pred, (tf.shape(y_pred)[0], -1, 4))
y_pred = bbox_utils. | get_bboxes_from_deltas(roi_bboxes, y_pred) |
#
loss_fn = tfa.losses.GIoULoss(reduction=tf.losses.Reduction.NONE)
loss_for_all = loss_fn(y_true, y_pred)
# loss_for_all = tf.reduce_sum(loss_for_all, axis=-1)
#
pos_cond = tf.reduce_any(tf.not_equal(y_true, tf.constant(0.0)), axis=-1)
pos_mask = tf.cast(pos_cond, dtype=tf.float32)
#
loc_loss = tf.reduce_sum(tf.math.multiply_no_nan(pos_mask, loss_for_all))
total_pos_bboxes = tf.maximum(1.0, tf.reduce_sum(pos_mask))
return tf.math.divide_no_nan(loc_loss, total_pos_bboxes)
def darod_loss(rpn_cls_pred, rpn_delta_pred, frcnn_cls_pred, frcnn_reg_pred,
bbox_labels, bbox_deltas, frcnn_reg_actuals, frcnn_cls_actuals):
"""
Calculate loss function for DAROD model
:param rpn_cls_pred: RPN classification pred
:param rpn_delta_pred: RPN regression pred
:param frcnn_cls_pred: FRCNN classification pred
:param frcnn_reg_pred: FRCNN regression pred
:param bbox_labels: bounding boxes labels
:param bbox_deltas: bounding boxes deltas
:param frcnn_reg_actuals: faster rcnn regression labels
:param frcnn_cls_actuals: faster rcnn classification labels
:return: faster rcnn loss
"""
rpn_regression_loss = reg_loss(bbox_deltas, rpn_delta_pred)
rpn_classif_loss = rpn_cls_loss(bbox_labels, rpn_cls_pred)
frcnn_regression_loss = reg_loss(frcnn_reg_actuals, frcnn_reg_pred)
frcnn_classif_loss = frcnn_cls_loss(frcnn_cls_actuals, frcnn_cls_pred)
return rpn_regression_loss, rpn_classif_loss, frcnn_regression_loss, frcnn_classif_loss
def darod_loss_giou(rpn_cls_pred, rpn_delta_pred, frcnn_cls_pred, frcnn_reg_pred,
bbox_labels, bbox_deltas, frcnn_reg_actuals, frcnn_cls_actuals, roi_bboxes):
rpn_regression_loss = reg_loss(bbox_deltas, rpn_delta_pred)
rpn_classif_loss = rpn_cls_loss(bbox_labels, rpn_cls_pred)
frcnn_regression_loss = giou_loss(frcnn_reg_actuals, frcnn_reg_pred, roi_bboxes) / 10
frcnn_classif_loss = frcnn_cls_loss(frcnn_cls_actuals, frcnn_cls_pred)
return rpn_regression_loss, rpn_classif_loss, frcnn_regression_loss, frcnn_classif_loss
| darod/utils/train_utils.py | colindecourt-darod-ab4878e | [
{
"filename": "darod/utils/bbox_utils.py",
"retrieved_chunk": " y1 = pred_ctr_y - 0.5 * pred_h\n x1 = pred_ctr_x - 0.5 * pred_w\n y2 = pred_ctr_y + 0.5 * pred_h\n x2 = pred_ctr_y + 0.5 * pred_w\n return tf.stack([y1, x1, y2, x2], axis=-1)\ndef get_deltas_from_bboxes(bboxes, gt_boxes):\n \"\"\"\n Calculating bounding box deltas for given bounding box and ground truth boxes.\n :param bboxes: (batch_size, total_bboxes, [y1, x1, y2, x2])\n :param gt_boxes: (batch_size, total_bboxes, [y1, x1, y2, x2])",
"score": 0.808845579624176
},
{
"filename": "darod/models/model.py",
"retrieved_chunk": " #\n expanded_roi_bboxes = tf.tile(tf.expand_dims(roi_bboxes, -2), (1, 1, self.total_labels, 1))\n pred_bboxes = bbox_utils.get_bboxes_from_deltas(expanded_roi_bboxes, pred_deltas)\n pred_bboxes = tf.clip_by_value(pred_bboxes, clip_value_min=0.0, clip_value_max=1.0)\n #\n pred_labels_map = tf.expand_dims(tf.argmax(pred_label_probs, -1), -1)\n pred_labels = tf.where(tf.not_equal(pred_labels_map, 0), pred_label_probs, tf.zeros_like(pred_label_probs))\n #\n final_bboxes, final_scores, final_labels, _ = bbox_utils.non_max_suppression(\n pred_bboxes, pred_labels,",
"score": 0.8075956106185913
},
{
"filename": "darod/layers/frcnn_layers.py",
"retrieved_chunk": " variances = self.config[\"fastrcnn\"][\"variances_boxes\"]\n adaptive_ratio = self.config[\"fastrcnn\"][\"adaptive_ratio\"]\n positive_th = self.config[\"fastrcnn\"][\"positive_th\"]\n batch_size, total_bboxes = tf.shape(roi_bboxes)[0], tf.shape(roi_bboxes)[1]\n # Calculate iou values between each bboxes and ground truth boxes\n iou_map = bbox_utils.generate_iou_map(roi_bboxes, gt_boxes)\n # Get max index value for each row\n max_indices_each_gt_box = tf.argmax(iou_map, axis=2, output_type=tf.int32)\n # IoU map has iou values for every gt boxes and we merge these values column wise\n merged_iou_map = tf.reduce_max(iou_map, axis=2)",
"score": 0.7924187183380127
},
{
"filename": "darod/utils/bbox_utils.py",
"retrieved_chunk": " return tf.stack([delta_y, delta_x, delta_h, delta_w], axis=-1)\ndef generate_iou_map(bboxes, gt_boxes):\n \"\"\"\n Calculating iou values for each ground truth boxes in batched manner.\n :param bboxes: (batch_size, total_bboxes, [y1, x1, y2, x2])\n :param gt_boxes: (batch_size, total_gt_boxes, [y1, x1, y2, x2])\n :return: iou_map = (batch_size, total_bboxes, total_gt_boxes)\n \"\"\"\n bbox_y1, bbox_x1, bbox_y2, bbox_x2 = tf.split(bboxes, 4, axis=-1)\n gt_y1, gt_x1, gt_y2, gt_x2 = tf.split(gt_boxes, 4, axis=-1)",
"score": 0.7923393845558167
},
{
"filename": "darod/utils/bbox_utils.py",
"retrieved_chunk": " \"\"\"\n # Denormalize bboxes for better computation\n bboxes = denormalize_bboxes(bboxes, 256, 64)\n gt_boxes = denormalize_bboxes(gt_boxes, 256, 64)\n #\n bbox_y1, bbox_x1, bbox_y2, bbox_x2 = tf.split(bboxes, 4, axis=-1)\n gt_y1, gt_x1, gt_y2, gt_x2 = tf.split(gt_boxes, 4, axis=-1)\n # Calculate bbox and groud truth centers\n bbox_center_x = bbox_x1 + (bbox_x2 - bbox_x1) / 2\n bbox_center_y = bbox_y1 + (bbox_y2 - bbox_y1) / 2",
"score": 0.789636492729187
}
] | python | get_bboxes_from_deltas(roi_bboxes, y_pred) |
from typing import List, Optional
from codegen.data import ContainerModel, GenericType, ModelType, OptionType, PolymorphicModel, PolymorphicType, PrimitiveType, PrimitiveTypeEnum, UnionType
from swagger import Schema, SwaggerDataType
from transformations.data import MutableContext
from transformations.util import attach_model, to_model_name
from transformations.primitive import primitive_mapping
def is_schema_union(schema: Schema) -> bool:
return isinstance(schema.type,List)
union_mapping = primitive_mapping | {SwaggerDataType.Object: GenericType().to_polymorphic()}
def types_to_union(non_null_types: List[SwaggerDataType]) -> PolymorphicType:
types: List[PolymorphicType] = [union_mapping[type] for type in non_null_types]
return UnionType(types).to_polymorphic()
def transform_schema_as_union(ctx: MutableContext, schema: Schema, _suggested_name: str, _parent: Optional[PolymorphicModel]) -> PolymorphicType:
assert is_schema_union(schema)
assert isinstance(schema.type,List)
types = schema.type
assert len(types) > 0, "empty type detected"
is_nullable = SwaggerDataType. | Null in types |
non_null_types = [type for type in types if type != SwaggerDataType.Null]
# avoid a union for a singular type
type = types_to_union(non_null_types) if len(non_null_types) > 1 else union_mapping[non_null_types[0]]
if is_nullable:
return OptionType(type).to_polymorphic()
else:
return type
| src/transformations/union.py | UMEssen-matrix-scala-bd97a56 | [
{
"filename": "src/transformations/array.py",
"retrieved_chunk": " return [transform_schema(ctx, item_schema, suggested_name, parent) for item_schema in schema.items]\n else:\n # singular type\n return [transform_schema(ctx, schema.items, suggested_name, parent)]\ndef transform_schema_as_array(ctx: MutableContext, schema: Schema, suggested_name: str, parent: Optional[PolymorphicModel]) -> PolymorphicType:\n assert is_schema_array(schema)\n assert schema.items\n item_types = transform_item_types(ctx, schema, suggested_name, parent)\n assert len(item_types) > 0\n inner_type = UnionType(item_types).to_polymorphic() if len(item_types) > 1 else item_types[0]",
"score": 0.8681527376174927
},
{
"filename": "src/transformations/enum.py",
"retrieved_chunk": "from os import name\nfrom typing import Optional\nfrom codegen.data import GenericType, MapType, ModelType, PolymorphicModel, PolymorphicType, StringEnumModel\nfrom swagger import Schema, SwaggerDataType\nfrom transformations.data import MutableContext\nfrom transformations.util import attach_model, to_model_name\ndef is_schema_enum(schema: Schema) -> bool:\n return schema.enum is not None\ndef transform_schema_as_enum(ctx: MutableContext, schema: Schema, suggested_name: str, parent: Optional[PolymorphicModel]) -> PolymorphicType:\n assert is_schema_enum(schema)",
"score": 0.8632585406303406
},
{
"filename": "src/transformations/map.py",
"retrieved_chunk": "from typing import Optional, Union\nfrom codegen.data import MapType, PolymorphicModel, PolymorphicType\nfrom swagger import Reference, Schema\nfrom transformations.data import MutableContext\ndef is_schema_map(schema: Schema) -> bool:\n return isinstance(schema.additionalProperties, Union[Schema, Reference]) and schema.properties is None and schema.allOf is None\ndef transform_schema_as_map(ctx: MutableContext, schema: Schema, suggested_name: str, parent: Optional[PolymorphicModel]) -> PolymorphicType:\n assert is_schema_map(schema)\n assert isinstance(schema.additionalProperties, Union[Schema,Reference])\n from transformations.types import transform_schema # avoid circular import",
"score": 0.8586151599884033
},
{
"filename": "src/transformations/model.py",
"retrieved_chunk": " return GenericValueType().to_polymorphic()\n if isinstance(schema.additionalProperties, Union[Schema, Reference]):\n return transform_schema(ctx, schema.additionalProperties, \"Additional\", parent)\n raise Exception(\"reached unreachable\")\ndef transform_schema_as_model(ctx: MutableContext, schema: Schema, suggested_name: str, parent: Optional[PolymorphicModel]) -> PolymorphicType:\n assert is_schema_model(schema)\n properties = schema.properties or {}\n model_name = to_model_name(schema.title) if schema.title is not None else to_model_name(suggested_name)\n model = DataModel(\n model_name=model_name,",
"score": 0.8544507026672363
},
{
"filename": "src/transformations/generic.py",
"retrieved_chunk": "from codegen.data import GenericType, PolymorphicType\nfrom swagger import Schema, SwaggerDataType\nfrom transformations.data import MutableContext\ndef is_schema_generic(schema: Schema) -> bool:\n no_additional_properties = schema.properties is None or schema.properties == False\n return (schema.type == SwaggerDataType.Object or schema.type is None) and (schema.properties is None) and no_additional_properties and schema.allOf is None\ndef transform_schema_as_generic(ctx: MutableContext, schema: Schema) -> PolymorphicType:\n assert is_schema_generic(schema)\n return GenericType().to_polymorphic()",
"score": 0.8492426872253418
}
] | python | Null in types |
import subprocess
import os
import shutil
import sys
import inspect
import json
from concurrent import futures
from cakework import cakework_pb2
from cakework import cakework_pb2_grpc
from .task_server import TaskServer
import importlib
import logging
logging.basicConfig(level=logging.INFO)
class Cakework:
def __init__(self, name, local=False): # TODO remove local when release as open source
self.name = name
self.local = local
logging.info("Created project with name: " + self.name)
def add_task(self, task):
activity_server = TaskServer(task, self.local)
activity_server.start()
def serve():
port = '50051'
server = grpc.server(futures.ThreadPoolExecutor(max_workers=1)) # what should the default be?
cakework_pb2_grpc. | add_CakeworkServicer_to_server(cakework_pb2_grpc.Cakework(), server) |
server.add_insecure_port('[::]:' + port)
server.start()
logging.info("Server started, listening on " + port)
server.wait_for_termination() | sdk/python/src/cakework/cakework.py | usecakework-async-backend-c288d0b | [
{
"filename": "sdk/python/src/cakework/task_server.py",
"retrieved_chunk": " def __init__(self, user_task, local=False):\n self.user_task = user_task\n self.server = grpc.server(futures.ThreadPoolExecutor(max_workers=1)) # what should the default be?\n self.local = local\n def start(self): \n port = '50051'\n cakework_pb2_grpc.add_CakeworkServicer_to_server(Cakework(self.user_task, self.local), self.server)\n self.server.add_insecure_port('[::]:' + port)\n self.server.start()\n logging.info(\"Server started, listening on \" + port)",
"score": 0.9341219067573547
},
{
"filename": "sdk/python/src/cakework/task_server.py",
"retrieved_chunk": " server = grpc.server(futures.ThreadPoolExecutor(max_workers=1)) # what should the default be?\n cakework_pb2_grpc.add_CakeworkServicer_to_server(Cakework(), server)\n server.add_insecure_port('[::]:' + port)\n server.start()\n logging.info(\"Server started, listening on \" + port)\n server.wait_for_termination()\nif __name__ == '__main__':\n logging.basicConfig()\n serve()\nclass TaskServer:",
"score": 0.9176508188247681
},
{
"filename": "sdk/python/src/cakework/task_server.py",
"retrieved_chunk": "logging.basicConfig(level=logging.INFO)\ndef get_token(context):\n metadict = dict(context.invocation_metadata())\n authorization = metadict['authorization']\n split = authorization.split(' ')\n return split[1]\nclass Cakework(cakework_pb2_grpc.CakeworkServicer):\n def __init__(self, user_task, local=False):\n self.user_task = user_task\n self.local = local",
"score": 0.8406063914299011
},
{
"filename": "sdk/python/src/cakework/task_server.py",
"retrieved_chunk": "from concurrent import futures\nimport logging\nimport grpc\nfrom cakework import cakework_pb2\nfrom cakework import cakework_pb2_grpc\nimport json\nimport threading\nimport requests\nimport os\nimport logging",
"score": 0.8262561559677124
},
{
"filename": "examples/react-example/react-example-backend/react_example_backend/main.py",
"retrieved_chunk": "from cakework import Cakework\nimport time\ndef say_hello(params):\n time.sleep(5)\n return \"Hello \" + params['name'] + \"!\"\nif __name__ == \"__main__\":\n cakework = Cakework(\"react-example-backend\")\n cakework.add_task(say_hello)",
"score": 0.8011237978935242
}
] | python | add_CakeworkServicer_to_server(cakework_pb2_grpc.Cakework(), server) |
from concurrent import futures
import logging
import grpc
from cakework import cakework_pb2
from cakework import cakework_pb2_grpc
import json
import threading
import requests
import os
import logging
logging.basicConfig(level=logging.INFO)
def get_token(context):
metadict = dict(context.invocation_metadata())
authorization = metadict['authorization']
split = authorization.split(' ')
return split[1]
class Cakework(cakework_pb2_grpc.CakeworkServicer):
def __init__(self, user_task, local=False):
self.user_task = user_task
self.local = local
if self.local:
self.frontend_url = "http://localhost:8080"
else:
self.frontend_url = "https://cakework-frontend.fly.dev"
def Run(self, request, context):
token = get_token(context)
headers = {'content-type': 'application/json', 'authorization': 'Bearer ' + token, 'project': request.project}
response = requests.post(f"{self.frontend_url}/runs/{request.runId}/status", json={"runId": request.runId, "status": "IN_PROGRESS"}, headers=headers)
# TODO check the response
parameters = json.loads(request.parameters)
# parameters = json.loads(request.parameters) # instead of passing a dict (parameters), pass a variable number of parameters
task = threading.Thread(target=self.background, args=[request.userId, request.project, request.runId, parameters, token])
task.daemon = True # Q: does returning kill the task?
task.start()
# what should we return? now, the client is no longer hitting the grpc server
return cakework_pb2.Reply(result=json.dumps("worker started task")) # TODO this should return the request id
# note: we need to get the request id in here as well
def background(self, user_id, project, run_id, parameters, token):
res = ""
# logging.info("starting background task with parameters: " + str(parameters))
headers = {'content-type': 'application/json', 'authorization': 'Bearer ' + token, 'project': project}
try:
logging.info("Starting run with id:" + run_id)
res = self.user_task(parameters)
# TODO call the frontend api to update the status and result
logging.info("Finished request " + run_id)
response = requests.post(f"{self.frontend_url}/runs/{run_id}/result", json={"runId": run_id, "result": json.dumps(res)}, headers=headers)
if response.status_code != 200:
logging.error("Failed to update run status")
response.raise_for_status()
logging.info("Got successful response to update status")
# TODO check the response
response = requests.post(f"{self.frontend_url}/runs/{run_id}/status", json={"runId": run_id, "status": "SUCCEEDED"}, headers=headers)
if response.status_code != 200:
logging.error("Failed to update run status")
response.raise_for_status()
logging.info("Got successful response to update result")
except Exception as e:
logging.exception("Error occurred while running task", exc_info=True)
# logging.info(e)
response = requests.post(f"{self.frontend_url}/runs/{run_id}/status", json={"runId": run_id, "status": "FAILED"}, headers=headers)
# TODO: handle case if updating the status in the db failed; then user may keep polling forever
return cakework_pb2.Reply(result=None)
finally:
logging.info("Request complete, exiting")
os._exit(1)
# Q: who are we returning to here? instead of returning, we can just write this to the database. or emit a message and have the poller be in charge of writing to db
return cakework_pb2.Reply(result=json.dumps(res))
def serve():
port = '50051'
server = grpc.server(futures.ThreadPoolExecutor(max_workers=1)) # what should the default be?
cakework_pb2_grpc. | add_CakeworkServicer_to_server(Cakework(), server) |
server.add_insecure_port('[::]:' + port)
server.start()
logging.info("Server started, listening on " + port)
server.wait_for_termination()
if __name__ == '__main__':
logging.basicConfig()
serve()
class TaskServer:
def __init__(self, user_task, local=False):
self.user_task = user_task
self.server = grpc.server(futures.ThreadPoolExecutor(max_workers=1)) # what should the default be?
self.local = local
def start(self):
port = '50051'
cakework_pb2_grpc.add_CakeworkServicer_to_server(Cakework(self.user_task, self.local), self.server)
self.server.add_insecure_port('[::]:' + port)
self.server.start()
logging.info("Server started, listening on " + port)
self.server.wait_for_termination() | sdk/python/src/cakework/task_server.py | usecakework-async-backend-c288d0b | [
{
"filename": "sdk/python/src/cakework/cakework.py",
"retrieved_chunk": "\t\tactivity_server.start()\ndef serve():\n port = '50051'\n server = grpc.server(futures.ThreadPoolExecutor(max_workers=1)) # what should the default be?\n cakework_pb2_grpc.add_CakeworkServicer_to_server(cakework_pb2_grpc.Cakework(), server)\n server.add_insecure_port('[::]:' + port)\n server.start()\n logging.info(\"Server started, listening on \" + port)\n server.wait_for_termination()",
"score": 0.9198273420333862
},
{
"filename": "sdk/python/src/cakework/cakework_pb2_grpc.py",
"retrieved_chunk": " response_serializer=cakework__pb2.Reply.SerializeToString,\n ),\n }\n generic_handler = grpc.method_handlers_generic_handler(\n 'cakework.Cakework', rpc_method_handlers)\n server.add_generic_rpc_handlers((generic_handler,))\n # This class is part of an EXPERIMENTAL API.\nclass Cakework(object):\n \"\"\"Missing associated documentation comment in .proto file.\"\"\"\n @staticmethod",
"score": 0.8082683086395264
},
{
"filename": "sdk/python/src/cakework/cakework.py",
"retrieved_chunk": "import subprocess\nimport os\nimport shutil\nimport sys\nimport inspect\nimport json\nfrom concurrent import futures\nfrom cakework import cakework_pb2\nfrom cakework import cakework_pb2_grpc\nfrom .task_server import TaskServer",
"score": 0.8029460310935974
},
{
"filename": "sdk/python/src/cakework/cakework_pb2_grpc.py",
"retrieved_chunk": " return grpc.experimental.unary_unary(request, target, '/cakework.Cakework/Run',\n cakework__pb2.Request.SerializeToString,\n cakework__pb2.Reply.FromString,\n options, channel_credentials,\n insecure, call_credentials, compression, wait_for_ready, timeout, metadata)",
"score": 0.8001949787139893
},
{
"filename": "examples/image_generation/backend/tests/bake.py",
"retrieved_chunk": "from cakework import Client\nimport time\nfrom pathlib import Path\nif __name__ == \"__main__\":\n p = Path(__file__).with_name('.env')\n with p.open('r') as f:\n CAKEWORK_CLIENT_TOKEN = f.readline().strip('\\n')\n client = Client(\"backend\", CAKEWORK_CLIENT_TOKEN)\n # You can persist this run ID to get status of the job later\n run_id = client.say_hello(\"from Cakework\")",
"score": 0.7969129085540771
}
] | python | add_CakeworkServicer_to_server(Cakework(), server) |
from typing import TypeVar
import re
from codegen.data import OptionType, PolymorphicModel, PolymorphicType
T = TypeVar("T")
def PLACEHOLDER(x: T) -> T:
return x
def flatten_2d(outer: list[list[T]]) -> list[T]:
return [item for sublist in outer for item in sublist]
# "Some cool name" => "SomeCoolName"
def to_model_name(s: str) -> str:
word_regex = r'[a-zA-Z][a-zA-Z0-9]*'
def capitalize_first_char(s: str) -> str:
return s[0].capitalize() + s[1:]
return "".join(map(capitalize_first_char, re.findall(word_regex, s)))
# avoid child/parent inconsistent state
# TODO: make this less imperative
def attach_model(model: PolymorphicModel, parent: PolymorphicModel):
model.data.parent = parent
if parent.data.inner_models is None:
parent.data.inner_models = [model]
else:
parent.data.inner_models.append(model)
def wrap_in_option(is_required: bool, t: PolymorphicType) -> PolymorphicType:
# wrap in option if not required
wrapped = OptionType(t). | to_polymorphic() if not is_required else t |
return wrapped
| src/transformations/util.py | UMEssen-matrix-scala-bd97a56 | [
{
"filename": "src/codegen/data.py",
"retrieved_chunk": " model_name: str\n inner_models: Optional[list[PolymorphicModel]] = None\n parent: Optional[PolymorphicModel] = None\n description: Optional[str] = None\n def to_polymorphic(self) -> PolymorphicModel:\n return PolymorphicModel.from_basic(self)\n@dataclass\nclass PolymorphicModel:\n data: BaseModel\n is_container_model: bool = False",
"score": 0.8085336685180664
},
{
"filename": "src/transformations/enum.py",
"retrieved_chunk": " attach_model(enum_model, parent)\n model_type = ModelType(\n model= enum_model,\n ).to_polymorphic()\n return model_type",
"score": 0.7914071083068848
},
{
"filename": "src/transformations/model.py",
"retrieved_chunk": " return (schema.properties is not None) or (schema.allOf is not None)\n@dataclass\nclass FieldTransformation:\n arg: Argument\ndef transform_model_field(ctx: MutableContext, field_name: str, field_schema: Union[Schema, Reference], is_required: bool, model: PolymorphicModel) -> FieldTransformation:\n from transformations.types import transform_schema # avoid circular import\n t = wrap_in_option(is_required, transform_schema(ctx, field_schema, to_model_name(field_name), model))\n arg = Argument(\n name=field_name,\n type=t,",
"score": 0.7854714393615723
},
{
"filename": "src/codegen/data.py",
"retrieved_chunk": " Float = \"Float\"\n@dataclass\nclass BaseType:\n def to_polymorphic(self) -> PolymorphicType:\n return PolymorphicType.from_basic(self)\n@dataclass\nclass OptionType(BaseType):\n inner_type: PolymorphicType\n@dataclass\nclass PrimitiveType(BaseType):",
"score": 0.7787270545959473
},
{
"filename": "src/codegen/data.py",
"retrieved_chunk": " is_data_model: bool = False\n is_string_enum: bool = False\n is_responses_trait: bool = False\n is_response_box: bool = False\n @staticmethod\n def from_basic(data: BaseModel) -> PolymorphicModel:\n if isinstance(data, DataModel):\n return PolymorphicModel(data, is_data_model=True)\n if isinstance(data, ContainerModel):\n return PolymorphicModel(data, is_container_model=True)",
"score": 0.7768588066101074
}
] | python | to_polymorphic() if not is_required else t |
from typing import List, Optional
from codegen.data import ListyType, PolymorphicModel, PolymorphicType, UnionType
from swagger import Schema
from transformations.data import MutableContext
def is_schema_array(schema: Schema) -> bool:
return schema.items is not None
def transform_item_types(ctx: MutableContext, schema: Schema, suggested_name: str, parent: Optional[PolymorphicModel]) -> List[PolymorphicType]:
from transformations.types import transform_schema # avoid circular import
assert schema.items
if isinstance(schema.items, List):
return [transform_schema(ctx, item_schema, suggested_name, parent) for item_schema in schema.items]
else:
# singular type
return [transform_schema(ctx, schema.items, suggested_name, parent)]
def transform_schema_as_array(ctx: MutableContext, schema: Schema, suggested_name: str, parent: Optional[PolymorphicModel]) -> PolymorphicType:
assert is_schema_array(schema)
assert schema.items
item_types = transform_item_types(ctx, schema, suggested_name, parent)
assert len(item_types) > 0
inner_type = UnionType(item_types). | to_polymorphic() if len(item_types) > 1 else item_types[0] |
array_type = ListyType(
inner_type=inner_type,
)
return array_type.to_polymorphic()
| src/transformations/array.py | UMEssen-matrix-scala-bd97a56 | [
{
"filename": "src/transformations/model.py",
"retrieved_chunk": " return GenericValueType().to_polymorphic()\n if isinstance(schema.additionalProperties, Union[Schema, Reference]):\n return transform_schema(ctx, schema.additionalProperties, \"Additional\", parent)\n raise Exception(\"reached unreachable\")\ndef transform_schema_as_model(ctx: MutableContext, schema: Schema, suggested_name: str, parent: Optional[PolymorphicModel]) -> PolymorphicType:\n assert is_schema_model(schema)\n properties = schema.properties or {}\n model_name = to_model_name(schema.title) if schema.title is not None else to_model_name(suggested_name)\n model = DataModel(\n model_name=model_name,",
"score": 0.8838537931442261
},
{
"filename": "src/transformations/union.py",
"retrieved_chunk": " types: List[PolymorphicType] = [union_mapping[type] for type in non_null_types]\n return UnionType(types).to_polymorphic()\ndef transform_schema_as_union(ctx: MutableContext, schema: Schema, _suggested_name: str, _parent: Optional[PolymorphicModel]) -> PolymorphicType:\n assert is_schema_union(schema)\n assert isinstance(schema.type,List)\n types = schema.type\n assert len(types) > 0, \"empty type detected\"\n is_nullable = SwaggerDataType.Null in types\n non_null_types = [type for type in types if type != SwaggerDataType.Null]\n # avoid a union for a singular type",
"score": 0.8808954358100891
},
{
"filename": "src/transformations/map.py",
"retrieved_chunk": " value_type = transform_schema(ctx, schema.additionalProperties, suggested_name, parent)\n map_type = MapType(\n inner_type=value_type,\n ).to_polymorphic()\n return map_type",
"score": 0.8767038583755493
},
{
"filename": "src/transformations/types.py",
"retrieved_chunk": " return transform_schema_as_file(ctx, schema)\n if is_schema_primitive(schema):\n return transform_schema_as_primitive(ctx, schema)\n if is_schema_map(schema):\n return transform_schema_as_map(ctx, schema, suggested_name, parent)\n if is_schema_model(schema):\n return transform_schema_as_model(ctx, schema, suggested_name, parent)\n if is_schema_array(schema):\n return transform_schema_as_array(ctx, schema, suggested_name, parent)\n if is_schema_generic(schema):",
"score": 0.8722885847091675
},
{
"filename": "src/transformations/map.py",
"retrieved_chunk": "from typing import Optional, Union\nfrom codegen.data import MapType, PolymorphicModel, PolymorphicType\nfrom swagger import Reference, Schema\nfrom transformations.data import MutableContext\ndef is_schema_map(schema: Schema) -> bool:\n return isinstance(schema.additionalProperties, Union[Schema, Reference]) and schema.properties is None and schema.allOf is None\ndef transform_schema_as_map(ctx: MutableContext, schema: Schema, suggested_name: str, parent: Optional[PolymorphicModel]) -> PolymorphicType:\n assert is_schema_map(schema)\n assert isinstance(schema.additionalProperties, Union[Schema,Reference])\n from transformations.types import transform_schema # avoid circular import",
"score": 0.871021032333374
}
] | python | to_polymorphic() if len(item_types) > 1 else item_types[0] |
# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
# Copyright (c) 2021-2023 NVIDIA CORPORATION & AFFILIATES. 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.
#
# SPDX-License-Identifier: Apache-2.0
"""CPU profiler class to measure performance of benchmark tests."""
from enum import Enum
import numbers
from pathlib import Path
from threading import Thread
import numpy as np
import psutil
from .profiler import Profiler
class CPUProfilingMetrics(Enum):
"""Metrics for CPU profiling."""
MAX_CPU_UTIL = 'Max. CPU Util. (%)'
MIN_CPU_UTIL = 'Min. CPU Util. (%)'
MEAN_CPU_UTIL = 'Mean CPU Util. (%)'
STD_DEV_CPU_UTIL = 'Std. Deviation CPU Util. (%)'
BASELINE_CPU_UTIL = 'Baseline CPU Util. (%)'
class CPUProfiler(Profiler):
"""CPU profiler class to measure CPU performance of benchmark tests."""
def __init__(self):
"""Construct CPU profiler."""
super().__init__()
def start_profiling(self, interval: float = 1.0) -> Path:
"""
Start CPU profiling thread to keep track of performance metrics.
Parameters
----------
interval: float
The interval between measurements, in seconds
"""
super().start_profiling()
# While the is_running flag is true, log CPU usage
def psutil_log():
with open(self._log_file_path, 'w+') as logfile:
while self._is_running:
logfile.write(
f'{psutil.cpu_percent(interval=interval, percpu=True)}\n')
self.psutil_thread = Thread(target=psutil_log)
self.psutil_thread.start()
return self._log_file_path
def stop_profiling(self):
"""Stop profiling."""
if self._is_running:
super().stop_profiling()
# Wait for thread to stop
self.psutil_thread.join()
@staticmethod
def get_current_cpu_usage():
"""Return current CPU usage."""
return np.mean(psutil.cpu_percent(interval=1.0, percpu=True))
def get_results(self, log_file_path=None) -> dict:
"""Return CPU profiling results."""
assert not self._is_running, 'Cannot collect results until profiler has been stopped!'
log_file_path = self._log_file_path if log_file_path is None else log_file_path
assert self._log_file_path is not None, 'No log file for reading CPU profiling results.'
profile_data = {}
with open(log_file_path) as logfile:
cpu_values = []
for line in logfile.readlines():
# Remove brackets from line before splitting entries by comma
cpu_values.append(np.mean([float(v)
for v in line[1:-2].split(',')]))
cpu_values = np.array(cpu_values)
profile_data[CPUProfilingMetrics.MAX_CPU_UTIL] = np.max(cpu_values)
profile_data[CPUProfilingMetrics.MIN_CPU_UTIL] = np.min(cpu_values)
profile_data[CPUProfilingMetrics.MEAN_CPU_UTIL] = np.mean(cpu_values)
profile_data[CPUProfilingMetrics.STD_DEV_CPU_UTIL] = np.std(cpu_values)
profile_data[CPUProfilingMetrics.BASELINE_CPU_UTIL] = cpu_values[0]
self. | _profile_data_list.append(profile_data) |
return profile_data
def reset(self):
"""Reset the profiler state."""
self._profile_data_list.clear()
return
def conclude_results(self) -> dict:
"""Conclude final profiling outcome based on all previous results."""
if len(self._profile_data_list) == 0:
self.get_logger().warn('No prior profile data to conclude')
return {}
MEAN_METRICS = [
CPUProfilingMetrics.MEAN_CPU_UTIL,
CPUProfilingMetrics.STD_DEV_CPU_UTIL,
CPUProfilingMetrics.BASELINE_CPU_UTIL
]
MAX_METRICS = [
CPUProfilingMetrics.MAX_CPU_UTIL
]
MIN_METRICS = [
CPUProfilingMetrics.MIN_CPU_UTIL
]
final_profile_data = {}
for metric in CPUProfilingMetrics:
metric_value_list = [profile_data.get(metric, None) for
profile_data in self._profile_data_list]
if not all(isinstance(value, numbers.Number) for value in metric_value_list):
continue
# Remove the best and the worst before concluding the metric
metric_value_list.remove(max(metric_value_list))
metric_value_list.remove(min(metric_value_list))
if metric in MEAN_METRICS:
final_profile_data[metric] = sum(metric_value_list)/len(metric_value_list)
elif metric in MAX_METRICS:
final_profile_data[metric] = max(metric_value_list)
elif metric in MIN_METRICS:
final_profile_data[metric] = min(metric_value_list)
else:
final_profile_data[metric] = 'INVALID VALUES: NO CONCLUDED METHOD ASSIGNED'
self.reset()
return final_profile_data
| ros2_benchmark/ros2_benchmark/utils/cpu_profiler.py | NVIDIA-ISAAC-ROS-ros2_benchmark-d7725da | [
{
"filename": "ros2_benchmark/ros2_benchmark/ros2_benchmark_test.py",
"retrieved_chunk": " end_timestamps = {}\n for i in range(len(monitor_response.timestamps.keys)):\n key = monitor_response.timestamps.keys[i]\n end_timestamp = monitor_response.timestamps.timestamps_ns[i]\n end_timestamps[key] = end_timestamp\n monitor_end_timestamps_map[monitor_info.service_name] = end_timestamps\n # Stop CPU profiler\n if self.config.enable_cpu_profiler:\n self._cpu_profiler.stop_profiling()\n self.get_logger().info('CPU profiling stopped.')",
"score": 0.7673757076263428
},
{
"filename": "ros2_benchmark/ros2_benchmark/basic_performance_calculator.py",
"retrieved_chunk": " final_perf_data[metric] = sum(metric_value_list)/len(metric_value_list)\n elif metric in MAX_METRICS:\n final_perf_data[metric] = max(metric_value_list)\n elif metric in MIN_METRICS:\n final_perf_data[metric] = min(metric_value_list)\n else:\n final_perf_data[metric] = 'INVALID VALUES: NO CONCLUDED METHOD ASSIGNED'\n self.reset()\n return final_perf_data",
"score": 0.7671828269958496
},
{
"filename": "ros2_benchmark/ros2_benchmark/basic_performance_calculator.py",
"retrieved_chunk": " perf_data[BasicPerformanceMetrics.MIN_LATENCY] = \\\n min(end_to_end_latencies_ms)\n perf_data[BasicPerformanceMetrics.MEAN_LATENCY] = \\\n sum(end_to_end_latencies_ms) / len(end_to_end_latencies_ms)\n else:\n self.get_logger().warning('No end-to-end latency data available.')\n # Calculate frame-to-frame jitter if at least 3 valid end timestamps are received\n if len(end_timestamps_ns) > 2:\n np_end_timestamps_ms = (numpy.array(list(end_timestamps_ns.values())))/(10**6)\n jitters = numpy.abs(numpy.diff(numpy.diff(np_end_timestamps_ms)))",
"score": 0.7667176127433777
},
{
"filename": "ros2_benchmark/ros2_benchmark/basic_performance_calculator.py",
"retrieved_chunk": " ]\n final_perf_data = {}\n for metric in BasicPerformanceMetrics:\n metric_value_list = [perf_data.get(metric, None) for perf_data in self._perf_data_list]\n if not all(isinstance(value, numbers.Number) for value in metric_value_list):\n continue\n # Remove the best and the worst before concluding the metric\n metric_value_list.remove(max(metric_value_list))\n metric_value_list.remove(min(metric_value_list))\n if metric in MEAN_METRICS:",
"score": 0.7614959478378296
},
{
"filename": "ros2_benchmark/ros2_benchmark/basic_performance_calculator.py",
"retrieved_chunk": " if message_key in end_timestamps_ns:\n end_to_end_latencies_ms.append(\n (end_timestamps_ns[message_key] - start_timestamp_ns) / 10**6)\n if len(end_to_end_latencies_ms) > 0:\n perf_data[BasicPerformanceMetrics.FIRST_INPUT_LATENCY] = \\\n end_to_end_latencies_ms[0]\n perf_data[BasicPerformanceMetrics.LAST_INPUT_LATENCY] = \\\n end_to_end_latencies_ms[-1]\n perf_data[BasicPerformanceMetrics.MAX_LATENCY] = \\\n max(end_to_end_latencies_ms)",
"score": 0.7573649883270264
}
] | python | _profile_data_list.append(profile_data) |
# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
# Copyright (c) 2021-2023 NVIDIA CORPORATION & AFFILIATES. 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.
#
# SPDX-License-Identifier: Apache-2.0
"""CPU profiler class to measure performance of benchmark tests."""
from enum import Enum
import numbers
from pathlib import Path
from threading import Thread
import numpy as np
import psutil
from .profiler import Profiler
class CPUProfilingMetrics(Enum):
"""Metrics for CPU profiling."""
MAX_CPU_UTIL = 'Max. CPU Util. (%)'
MIN_CPU_UTIL = 'Min. CPU Util. (%)'
MEAN_CPU_UTIL = 'Mean CPU Util. (%)'
STD_DEV_CPU_UTIL = 'Std. Deviation CPU Util. (%)'
BASELINE_CPU_UTIL = 'Baseline CPU Util. (%)'
class CPUProfiler(Profiler):
"""CPU profiler class to measure CPU performance of benchmark tests."""
def __init__(self):
"""Construct CPU profiler."""
super().__init__()
def start_profiling(self, interval: float = 1.0) -> Path:
"""
Start CPU profiling thread to keep track of performance metrics.
Parameters
----------
interval: float
The interval between measurements, in seconds
"""
super().start_profiling()
# While the is_running flag is true, log CPU usage
def psutil_log():
with open(self. | _log_file_path, 'w+') as logfile: |
while self._is_running:
logfile.write(
f'{psutil.cpu_percent(interval=interval, percpu=True)}\n')
self.psutil_thread = Thread(target=psutil_log)
self.psutil_thread.start()
return self._log_file_path
def stop_profiling(self):
"""Stop profiling."""
if self._is_running:
super().stop_profiling()
# Wait for thread to stop
self.psutil_thread.join()
@staticmethod
def get_current_cpu_usage():
"""Return current CPU usage."""
return np.mean(psutil.cpu_percent(interval=1.0, percpu=True))
def get_results(self, log_file_path=None) -> dict:
"""Return CPU profiling results."""
assert not self._is_running, 'Cannot collect results until profiler has been stopped!'
log_file_path = self._log_file_path if log_file_path is None else log_file_path
assert self._log_file_path is not None, 'No log file for reading CPU profiling results.'
profile_data = {}
with open(log_file_path) as logfile:
cpu_values = []
for line in logfile.readlines():
# Remove brackets from line before splitting entries by comma
cpu_values.append(np.mean([float(v)
for v in line[1:-2].split(',')]))
cpu_values = np.array(cpu_values)
profile_data[CPUProfilingMetrics.MAX_CPU_UTIL] = np.max(cpu_values)
profile_data[CPUProfilingMetrics.MIN_CPU_UTIL] = np.min(cpu_values)
profile_data[CPUProfilingMetrics.MEAN_CPU_UTIL] = np.mean(cpu_values)
profile_data[CPUProfilingMetrics.STD_DEV_CPU_UTIL] = np.std(cpu_values)
profile_data[CPUProfilingMetrics.BASELINE_CPU_UTIL] = cpu_values[0]
self._profile_data_list.append(profile_data)
return profile_data
def reset(self):
"""Reset the profiler state."""
self._profile_data_list.clear()
return
def conclude_results(self) -> dict:
"""Conclude final profiling outcome based on all previous results."""
if len(self._profile_data_list) == 0:
self.get_logger().warn('No prior profile data to conclude')
return {}
MEAN_METRICS = [
CPUProfilingMetrics.MEAN_CPU_UTIL,
CPUProfilingMetrics.STD_DEV_CPU_UTIL,
CPUProfilingMetrics.BASELINE_CPU_UTIL
]
MAX_METRICS = [
CPUProfilingMetrics.MAX_CPU_UTIL
]
MIN_METRICS = [
CPUProfilingMetrics.MIN_CPU_UTIL
]
final_profile_data = {}
for metric in CPUProfilingMetrics:
metric_value_list = [profile_data.get(metric, None) for
profile_data in self._profile_data_list]
if not all(isinstance(value, numbers.Number) for value in metric_value_list):
continue
# Remove the best and the worst before concluding the metric
metric_value_list.remove(max(metric_value_list))
metric_value_list.remove(min(metric_value_list))
if metric in MEAN_METRICS:
final_profile_data[metric] = sum(metric_value_list)/len(metric_value_list)
elif metric in MAX_METRICS:
final_profile_data[metric] = max(metric_value_list)
elif metric in MIN_METRICS:
final_profile_data[metric] = min(metric_value_list)
else:
final_profile_data[metric] = 'INVALID VALUES: NO CONCLUDED METHOD ASSIGNED'
self.reset()
return final_profile_data
| ros2_benchmark/ros2_benchmark/utils/cpu_profiler.py | NVIDIA-ISAAC-ROS-ros2_benchmark-d7725da | [
{
"filename": "ros2_benchmark/ros2_benchmark/ros2_benchmark_test.py",
"retrieved_chunk": " rclpy.logging.get_logger('r2b').info(\n 'Waiting 10 seconds for measuring idle system CPU utilization...')\n time.sleep(10)\n global idle_cpu_util\n idle_cpu_util = CPUProfiler.get_current_cpu_usage()\n launch_args = NsysUtility.generate_launch_args()\n bound_launch_setup = partial(\n NsysUtility.launch_setup_wrapper,\n launch_setup=launch_setup)\n nodes = launch_args + [OpaqueFunction(function=bound_launch_setup)]",
"score": 0.752030074596405
},
{
"filename": "ros2_benchmark/ros2_benchmark/utils/profiler.py",
"retrieved_chunk": " @abstractmethod\n def start_profiling(self, log_dir=DEFAILT_LOG_DIR) -> None:\n \"\"\"\n Run profiling program to keep track of performance metrics.\n Parameters\n ----------\n log_dir\n Path to write the logs to\n \"\"\"\n assert not self._is_running, 'Profiler has already been started!'",
"score": 0.7481958270072937
},
{
"filename": "ros2_benchmark/ros2_benchmark/utils/profiler.py",
"retrieved_chunk": " self._is_running = True\n # Create log file folders if they don't exist already\n os.makedirs(log_dir, exist_ok=True)\n self._log_file_path = os.path.join(\n log_dir,\n f'{type(self).__name__}_{datetime.timestamp(datetime.now())}.log')\n return self._log_file_path\n @abstractmethod\n def stop_profiling(self) -> None:\n \"\"\"Stop profiling.\"\"\"",
"score": 0.7477296590805054
},
{
"filename": "ros2_benchmark/ros2_benchmark/ros2_benchmark_test.py",
"retrieved_chunk": " # Run benchmark iterations\n self.reset_performance_calculators()\n self._cpu_profiler.reset()\n for i in range(self.config.test_iterations):\n self.get_logger().info(f'Starting Iteration {i+1}')\n performance_results = self.benchmark_body(\n playback_message_count,\n target_freq)\n self.print_report(performance_results, sub_heading=f'{target_freq}Hz #{i+1}')\n # Conclude performance measurements from the iteratoins",
"score": 0.7472000122070312
},
{
"filename": "ros2_benchmark/ros2_benchmark/ros2_benchmark_test.py",
"retrieved_chunk": " self.get_logger().info('CPU profiling stared.')\n # Start playing messages\n self.get_logger().info(\n f'Requesting to play messages in playback_mode = {self.config.benchmark_mode}.')\n play_messages_request = PlayMessages.Request()\n play_messages_request.playback_mode = self.config.benchmark_mode.value\n play_messages_request.target_publisher_rate = target_freq\n play_messages_request.message_count = playback_message_count\n play_messages_request.enforce_publisher_rate = self.config.enforce_publisher_rate\n play_messages_request.revise_timestamps_as_message_ids = \\",
"score": 0.7418481111526489
}
] | python | _log_file_path, 'w+') as logfile: |
'''
* Copyright (c) 2023, Salesforce, Inc.
* All rights reserved.
* SPDX-License-Identifier: BSD-3-Clause
* For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
'''
import re
import numpy as np
from ..llm_wrapper import OpenAILLM, LocalLLM
from .openAIscorers.constants import prompt_templates
from .utils import get_instruction, retrieve_global_knowledge
from tqdm import tqdm
import numpy as np
def gpt3_score(model_name, data, global_knowledge=''):
template = prompt_templates['gpt3_score']
gpt3model = OpenAILLM(model_name)
scores, meta_data = [], []
for sample in tqdm(data):
instruction = get_instruction(sample)
target = sample["output"]
if not target.endswith("\n"):
target += "\n"
local_knowledge = sample["knowledge"]
input_ = template.format(instruction=instruction,
local_knowledge=local_knowledge,
global_knowledge=retrieve_global_knowledge(target, global_knowledge),
output="")
gen_param = {
"temperature":0,
"logprobs":0,
"stop":'\n',
"echo":True,
"n": None,
}
response = gpt3model.generate(input_ + target, **gen_param)
result = gpt3model.responses[-1]['choices'][0]
i = result['logprobs']['text_offset'].index(len(input_) - 1)
if i == 0:
i = 1
loss = -sum(result['logprobs']["token_logprobs"][i:-1])
avg_loss = loss / (len(result['logprobs']['text_offset']) - i - 1) # 1 is the last '.'
ppl = np.exp(avg_loss)
scores.append(1 / ppl)
meta_data.append(f"PPL:{ppl}")
return scores, meta_data
def chatgpt_score(model_name, data, global_knowledge=''):
chatgptmodel = OpenAILLM(model_name)
template = prompt_templates['chatgpt_evaluator']
stars_mapping = {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5}
scores = []
for sample in tqdm(data):
instruction = get_instruction(sample)
target = sample["output"]
local_knowledge = sample["knowledge"]
input_ = template.format(instruction=instruction,
local_knowledge=local_knowledge,
global_knowledge=retrieve_global_knowledge(target, global_knowledge),
output=target)
response = chatgptmodel.generate(input_)
result = chatgptmodel.responses[-1]['choices'][0]['message']['content']
rating = re.search(r'\b(\w+)\s+(?:star|stars)\b', result.lower())
try:
scores.append(stars_mapping[rating.group(1)] / 5)
except:
scores.append(0.5)
# scores.append(f"Couldn't match regex, ChatGPT output:{result}")
return scores
def localllm_score(method, data, global_knowledge=''):
task = "text-generation" if "gpt" in method else "text2text-generation"
model = LocalLLM(model_name = method, task = task)
template = prompt_templates['localllm_score']
stars_mapping = {'one': 1, 'two': 2, 'three': 3, '1': 1, '2': 2, '3': 3}
scores = []
for sample in tqdm(data):
instruction = get_instruction(sample)
target = sample["output"]
local_knowledge = sample["knowledge"]
input_ = template.format(instruction=instruction,
local_knowledge=local_knowledge,
global_knowledge=retrieve_global_knowledge(target, global_knowledge),
output=target)
result = model.generate(input_)
try:
rating = re.search(r'\d+', result).group()
scores.append(stars_mapping[rating] / 3)
except:
scores.append(0.5)
# scores.append(f"Couldn't match regex, LocalLLM output: {result}")
return scores
def unieval(data, global_knowledge, use_cuda, gpu_device):
from .unieval_utils.evaluator import FactEvaluator
device = "cpu"
if use_cuda:
device = f"cuda:{gpu_device}"
evaluator = FactEvaluator(device=device)
scores = evaluator.evaluate(data, global_knowledge)
return scores
def opt_score(method, data, global_knowledge):
task = "llm-scorer"
evaluator = LocalLLM(method, task=task)
template = prompt_templates['opt_score']
scores, meta_data = [], []
for sample in tqdm(data):
target = sample["output"]
local_knowledge = sample["knowledge"]
prompt = """Generate a text that is factually correct and consistent with the instruction.\n"""
instruction = template.format(instruction=get_instruction(sample),
local_knowledge=local_knowledge,
global_knowledge=retrieve_global_knowledge(target, global_knowledge))
score = evaluator. | score(instruction, target, prompt) |
ppl = np.exp(avg_loss)
scores.append(1 / ppl)
meta_data.append(f"PPL:{ppl}")
return scores, meta_data
def summac_metric(data, global_knowledge, use_cuda, gpu_device):
from .summac_utils.evaluator import SummacEvaluator
device = "cpu"
if use_cuda:
device = f"cuda:{gpu_device}"
evaluator = SummacEvaluator(device=device)
scores = evaluator.evaluate(data, global_knowledge)
return scores
def qafacteval_metric(data, global_knowledge, use_cuda, gpu_device):
from .qafacteval_utils.evaluator import QAFactEvalEvaluator
evaluator = QAFactEvalEvaluator(device=gpu_device if use_cuda else -1)
scores = evaluator.evaluate(data, global_knowledge)
return scores
| src/auditnlg/factualness/classifier.py | salesforce-AuditNLG-c473044 | [
{
"filename": "src/auditnlg/constraint/constraint_checker.py",
"retrieved_chunk": "\"\"\"\ndef evaluate_2step_prompt(method, data, global_knowledge=''):\n constraint_scores = []\n score_reasoning = []\n if \"openai\" in method:\n model = OpenAILLM(model_name = method.split(\"/\")[-1])\n else:\n model_task = \"text-generation\" if \"gpt\" in method else \"text2text-generation\"\n model = LocalLLM(model_name = method, task = model_task)\n for sample in tqdm(data):",
"score": 0.8658890724182129
},
{
"filename": "src/auditnlg/explain.py",
"retrieved_chunk": " data = example_format_checker(data)\n gen_kwargs = {\n \"max_tokens\": 128\n }\n explanations = []\n for i, sample in enumerate(tqdm(data)):\n input_ = explain_template.format(\n instruction = get_instruction(sample),\n local_knowledge = sample[\"knowledge\"],\n global_knowledge = retrieve_global_knowledge(sample[\"output\"], global_knowledge),",
"score": 0.8640522956848145
},
{
"filename": "src/auditnlg/factualness/unieval_utils/evaluator.py",
"retrieved_chunk": " n_sents = [] # the number of sentences in the claim\n for sample in data:\n source = '\\n'.join([get_instruction(sample),\n sample['knowledge'],\n retrieve_global_knowledge(sample['output'], global_knowledge)])\n system_outputs = sent_tokenize(sample['output'])\n n_sents.append(len(system_outputs))\n for system_output in system_outputs:\n input_list.append('question: Is this claim consistent with the document? </s> claim: ' + system_output + ' </s> document: ' + source)\n sent_score = self.scorer.score(input_list)",
"score": 0.8490583896636963
},
{
"filename": "src/auditnlg/factualness/summac_utils/evaluator.py",
"retrieved_chunk": " \"\"\" Set up evaluator for factual consistency detection \"\"\"\n import nltk\n nltk.download('punkt')\n self.model_conv = SummaCConv(models=[\"vitc\"], bins='percentile', granularity=\"sentence\", \\\n nli_labels=\"e\", device=device, start_file=\"default\", agg=\"mean\")\n def evaluate(self, data, global_knowledge):\n sources = []\n generateds = []\n for sample in data:\n source = '\\n'.join([get_instruction(sample),",
"score": 0.8486839532852173
},
{
"filename": "src/auditnlg/constraint/exam.py",
"retrieved_chunk": " data = [], \n global_knowledge = \"\"\n ):\n data = example_format_checker(data)\n scores, meta_data = evaluate_2step_prompt(method, data, global_knowledge)\n return scores, meta_data",
"score": 0.8450549840927124
}
] | python | score(instruction, target, prompt) |
'''
* Copyright (c) 2023, Salesforce, Inc.
* All rights reserved.
* SPDX-License-Identifier: BSD-3-Clause
* For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
'''
import os
import shutil
import gdown
import wget
from .overall_model import QAFactEval
from ..utils import retrieve_global_knowledge, get_instruction
class QAFactEvalEvaluator:
def __init__(self, device=0):
""" Set up evaluator for factual consistency detection """
os.makedirs("models/answering", exist_ok=True)
if not os.listdir("models/answering"):
model_url = "https://drive.google.com/uc?id=1q2Z3FPP9AYNz0RJKHMlaweNhmLQoyPA8"
output_path = "models/answering/model.zip"
gdown.download(model_url, output_path, quiet=False)
shutil.unpack_archive(output_path, "models/answering")
os.remove(output_path)
if not os.path.exists("models/quip-512-mocha") or not os.listdir("models/quip-512-mocha"):
model_url = "https://storage.googleapis.com/sfr-qafacteval-research/quip-512-mocha.tar.gz"
output_path = "models/quip-512-mocha.tar.gz"
try:
_ = wget.download(model_url, output_path)
except:
raise Exception("Error while downloading 'quip-512-mocha'")
shutil.unpack_archive(output_path, "models/")
os.remove(output_path)
self.qafacteval = QAFactEval(cuda_device=device, use_lerc_quip=True, \
verbose=False, generation_batch_size=32, \
answering_batch_size=32, lerc_batch_size=8, \
lerc_quip_path=f"models/quip-512-mocha", \
answering_model_dir=f"models/answering")
def evaluate(self, data, global_knowledge):
sources = []
generateds = []
for sample in data:
source = '\n'.join([get_instruction(sample),
sample['knowledge'],
retrieve_global_knowledge(sample['output'], global_knowledge)])
sources.append(source)
generateds.append([sample['output']])
results = self.qafacteval. | score_batch_qafacteval(sources, generateds, return_qa_pairs=True) |
scores = [x[0]['qa-eval']['lerc_quip'] if x[1][0] else 0.5 for x in results]
meta = []
for x in results:
answer_list = [y for y in x[1][0] if y["prediction"]["f1"] <= 0.60]
meta.append(answer_list)
return scores, meta
| src/auditnlg/factualness/qafacteval_utils/evaluator.py | salesforce-AuditNLG-c473044 | [
{
"filename": "src/auditnlg/factualness/unieval_utils/evaluator.py",
"retrieved_chunk": " n_sents = [] # the number of sentences in the claim\n for sample in data:\n source = '\\n'.join([get_instruction(sample),\n sample['knowledge'],\n retrieve_global_knowledge(sample['output'], global_knowledge)])\n system_outputs = sent_tokenize(sample['output'])\n n_sents.append(len(system_outputs))\n for system_output in system_outputs:\n input_list.append('question: Is this claim consistent with the document? </s> claim: ' + system_output + ' </s> document: ' + source)\n sent_score = self.scorer.score(input_list)",
"score": 0.8706825971603394
},
{
"filename": "src/auditnlg/factualness/classifier.py",
"retrieved_chunk": " template = prompt_templates['opt_score']\n scores, meta_data = [], []\n for sample in tqdm(data):\n target = sample[\"output\"]\n local_knowledge = sample[\"knowledge\"]\n prompt = \"\"\"Generate a text that is factually correct and consistent with the instruction.\\n\"\"\"\n instruction = template.format(instruction=get_instruction(sample),\n local_knowledge=local_knowledge,\n global_knowledge=retrieve_global_knowledge(target, global_knowledge))\n score = evaluator.score(instruction, target, prompt)",
"score": 0.8563969135284424
},
{
"filename": "src/auditnlg/factualness/classifier.py",
"retrieved_chunk": " scores = evaluator.evaluate(data, global_knowledge)\n return scores\ndef qafacteval_metric(data, global_knowledge, use_cuda, gpu_device):\n from .qafacteval_utils.evaluator import QAFactEvalEvaluator\n evaluator = QAFactEvalEvaluator(device=gpu_device if use_cuda else -1)\n scores = evaluator.evaluate(data, global_knowledge)\n return scores",
"score": 0.8467994928359985
},
{
"filename": "src/auditnlg/constraint/constraint_checker.py",
"retrieved_chunk": "\"\"\"\ndef evaluate_2step_prompt(method, data, global_knowledge=''):\n constraint_scores = []\n score_reasoning = []\n if \"openai\" in method:\n model = OpenAILLM(model_name = method.split(\"/\")[-1])\n else:\n model_task = \"text-generation\" if \"gpt\" in method else \"text2text-generation\"\n model = LocalLLM(model_name = method, task = model_task)\n for sample in tqdm(data):",
"score": 0.8380756378173828
},
{
"filename": "src/auditnlg/factualness/classifier.py",
"retrieved_chunk": "from .utils import get_instruction, retrieve_global_knowledge\nfrom tqdm import tqdm\nimport numpy as np\ndef gpt3_score(model_name, data, global_knowledge=''):\n template = prompt_templates['gpt3_score']\n gpt3model = OpenAILLM(model_name)\n scores, meta_data = [], []\n for sample in tqdm(data):\n instruction = get_instruction(sample)\n target = sample[\"output\"]",
"score": 0.8362417221069336
}
] | python | score_batch_qafacteval(sources, generateds, return_qa_pairs=True) |
#!/usr/bin/env python3 -u
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
"""
Translate pre-processed data with a trained model.
"""
import ast
import logging
import math
import os
import sys
from argparse import Namespace
from itertools import chain
import numpy as np
import torch
from omegaconf import DictConfig
from fairseq import checkpoint_utils, options, scoring, tasks, utils
from fairseq.dataclass.utils import convert_namespace_to_omegaconf
from fairseq.logging import progress_bar
from fairseq.logging.meters import StopwatchMeter, TimeMeter
import utils as distributed_utils
def main(cfg: DictConfig):
if isinstance(cfg, Namespace):
cfg = convert_namespace_to_omegaconf(cfg)
assert cfg.common_eval.path is not None, "--path required for generation!"
assert (
not cfg.generation.sampling or cfg.generation.nbest == cfg.generation.beam
), "--sampling requires --nbest to be equal to --beam"
assert (
cfg.generation.replace_unk is None or cfg.dataset.dataset_impl == "raw"
), "--replace-unk requires a raw text dataset (--dataset-impl=raw)"
if cfg.common_eval.results_path is not None:
os.makedirs(cfg.common_eval.results_path, exist_ok=True)
output_path = os.path.join(
cfg.common_eval.results_path,
"generate-{}.txt".format(cfg.dataset.gen_subset),
)
with open(output_path, "w", buffering=1, encoding="utf-8") as h:
return _main(cfg, h)
else:
return _main(cfg, sys.stdout)
def get_symbols_to_strip_from_output(generator):
if hasattr(generator, "symbols_to_strip_from_output"):
return generator.symbols_to_strip_from_output
else:
return {generator.eos}
def _main(cfg: DictConfig, output_file):
logging.basicConfig(
format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
datefmt="%Y-%m-%d %H:%M:%S",
level=os.environ.get("LOGLEVEL", "INFO").upper(),
stream=output_file,
)
logger = logging.getLogger("fairseq_cli.generate")
utils.import_user_module(cfg.common)
if cfg.dataset.max_tokens is None and cfg.dataset.batch_size is None:
cfg.dataset.max_tokens = 12000
logger.info(cfg)
# Fix seed for stochastic decoding
if cfg.common.seed is not None and not cfg.generation.no_seed_provided:
np.random.seed(cfg.common.seed)
utils.set_torch_seed(cfg.common.seed)
use_cuda = torch.cuda.is_available() and not cfg.common.cpu
# Load dataset splits
task = tasks.setup_task(cfg.task)
# Set dictionaries
try:
src_dict = getattr(task, "source_dictionary", None)
except NotImplementedError:
src_dict = None
tgt_dict = task.target_dictionary
overrides = ast.literal_eval(cfg.common_eval.model_overrides)
logger.info("cfg.checkpoint.checkpoint_suffix {}".format(cfg.checkpoint.checkpoint_suffix))
# Load ensemble
logger.info("loading model(s) from {}".format(cfg.common_eval.path))
models, saved_cfg = checkpoint_utils.load_model_ensemble(
utils.split_paths(cfg.common_eval.path),
arg_overrides=overrides,
task=task,
suffix=cfg.checkpoint.checkpoint_suffix,
strict=(cfg.checkpoint.checkpoint_shard_count == 1),
num_shards=cfg.checkpoint.checkpoint_shard_count,
)
# loading the dataset should happen after the checkpoint has been loaded so we can give it the saved task config
task.load_dataset(cfg.dataset.gen_subset, task_cfg=saved_cfg.task)
if cfg.generation.lm_path is not None:
overrides["data"] = cfg.task.data
try:
lms, _ = checkpoint_utils.load_model_ensemble(
[cfg.generation.lm_path], arg_overrides=overrides, task=None
)
except:
logger.warning(
f"Failed to load language model! Please make sure that the language model dict is the same "
f"as target dict and is located in the data dir ({cfg.task.data})"
)
raise
assert len(lms) == 1
else:
lms = [None]
# Optimize ensemble for generation
for model in chain(models, lms):
if model is None:
continue
if cfg.common.fp16:
model.half()
if use_cuda and not cfg.distributed_training.pipeline_model_parallel:
model.cuda()
model.prepare_for_inference_(cfg)
# Load alignment dictionary for unknown word replacement
# (None if no unknown word replacement, empty if no path to align dictionary)
align_dict = utils.load_align_dict(cfg.generation.replace_unk)
# Load dataset (possibly sharded)
itr = task.get_batch_iterator(
dataset=task.dataset(cfg.dataset.gen_subset),
max_tokens=cfg.dataset.max_tokens,
max_sentences=cfg.dataset.batch_size,
max_positions=utils.resolve_max_positions(
task.max_positions(), *[m.max_positions() for m in models]
),
ignore_invalid_inputs=cfg.dataset.skip_invalid_size_inputs_valid_test,
required_batch_size_multiple=cfg.dataset.required_batch_size_multiple,
seed=cfg.common.seed,
num_shards=cfg.distributed_training.distributed_world_size,
shard_id=cfg.distributed_training.distributed_rank,
num_workers=cfg.dataset.num_workers,
data_buffer_size=cfg.dataset.data_buffer_size,
).next_epoch_itr(shuffle=False)
progress = progress_bar.progress_bar(
itr,
log_format=cfg.common.log_format,
log_interval=cfg.common.log_interval,
default_log_format=("tqdm" if not cfg.common.no_progress_bar else "simple"),
)
# Initialize generator
gen_timer = StopwatchMeter()
generator = task.build_generator(models, args=cfg.generation)
# Handle tokenization and BPE
tokenizer = task.build_tokenizer(cfg.tokenizer)
bpe = task.build_bpe(cfg.bpe)
def decode_fn(x):
if bpe is not None:
x = bpe.decode(x.tolist())
if tokenizer is not None:
x = tokenizer.decode(x)
return x
scorer = scoring.build_scorer(cfg.scoring, tgt_dict)
num_sentences = 0
has_target = True
wps_meter = TimeMeter()
for sample in progress:
sample = utils.move_to_cuda(sample) if use_cuda else sample
if "net_input" not in sample:
continue
prefix_tokens = None
if cfg.generation.prefix_size > 0:
prefix_tokens = sample["target"][:, : cfg.generation.prefix_size]
constraints = None
if "constraints" in sample:
constraints = sample["constraints"]
gen_timer.start()
hypos = task.inference_step(
generator,
models,
sample,
prefix_tokens=prefix_tokens,
constraints=constraints,
)
num_generated_tokens = sum(len(h[0]["tokens"]) for h in hypos)
gen_timer.stop(num_generated_tokens)
for i, sample_id in enumerate(sample["id"].tolist()):
has_target = sample["target"] is not None
# Remove padding
if "src_tokens" in sample["net_input"]:
src_tokens = utils.strip_pad(
sample["net_input"]["src_tokens"][i, :], tgt_dict.pad()
)
else:
src_tokens = None
target_tokens = None
if has_target:
target_tokens = (
utils.strip_pad(sample["target"][i, :], tgt_dict.pad()).int().cpu()
)
# Either retrieve the original sentences or regenerate them from tokens.
if align_dict is not None:
src_str = task.dataset(cfg.dataset.gen_subset).src.get_original_text(
sample_id
)
target_str = task.dataset(cfg.dataset.gen_subset).tgt.get_original_text(
sample_id
)
else:
if src_dict is not None:
src_str = src_dict.string(src_tokens, cfg.common_eval.post_process)
else:
src_str = ""
if has_target:
target_str = tgt_dict.string(
target_tokens,
cfg.common_eval.post_process,
escape_unk=True,
extra_symbols_to_ignore=get_symbols_to_strip_from_output(
generator
),
)
src_str = decode_fn(src_tokens)
if has_target:
target_str = decode_fn(target_tokens)
if "-model_part" in cfg.checkpoint.checkpoint_suffix and "-model_part-0" not in cfg.checkpoint.checkpoint_suffix:
print(distributed_utils. | get_model_parallel_rank()) |
continue
if not cfg.common_eval.quiet:
if src_dict is not None:
print("S-{}\t{}".format(sample_id, src_str), file=output_file)
# if has_target:
# print("T-{}\t{}".format(sample_id, target_str), file=output_file)
# Process top predictions
for j, hypo in enumerate(hypos[i][: cfg.generation.nbest]):
hypo_tokens, hypo_str, alignment = utils.post_process_prediction(
hypo_tokens=hypo["tokens"].int().cpu(),
src_str=src_str,
alignment=hypo["alignment"],
align_dict=align_dict,
tgt_dict=tgt_dict,
remove_bpe=cfg.common_eval.post_process,
extra_symbols_to_ignore=get_symbols_to_strip_from_output(generator),
)
detok_hypo_str = decode_fn(hypo_tokens)
if not cfg.common_eval.quiet:
score = hypo["score"] / math.log(2) # convert to base 2
# original hypothesis (after tokenization and BPE)
print(
"H-{}\t{}\t{}".format(sample_id, score, hypo_str),
file=output_file,
)
# detokenized hypothesis
print(
"D-{}\t{}\t{}".format(sample_id, score, detok_hypo_str),
file=output_file,
)
# print(
# "P-{}\t{}".format(
# sample_id,
# " ".join(
# map(
# lambda x: "{:.4f}".format(x),
# # convert from base e to base 2
# hypo["positional_scores"]
# .div_(math.log(2))
# .tolist(),
# )
# ),
# ),
# file=output_file,
# )
if cfg.generation.print_alignment == "hard":
print(
"A-{}\t{}".format(
sample_id,
" ".join(
[
"{}-{}".format(src_idx, tgt_idx)
for src_idx, tgt_idx in alignment
]
),
),
file=output_file,
)
if cfg.generation.print_alignment == "soft":
print(
"A-{}\t{}".format(
sample_id,
" ".join(
[",".join(src_probs) for src_probs in alignment]
),
),
file=output_file,
)
if cfg.generation.print_step:
print(
"I-{}\t{}".format(sample_id, hypo["steps"]),
file=output_file,
)
if cfg.generation.retain_iter_history:
for step, h in enumerate(hypo["history"]):
_, h_str, _ = utils.post_process_prediction(
hypo_tokens=h["tokens"].int().cpu(),
src_str=src_str,
alignment=None,
align_dict=None,
tgt_dict=tgt_dict,
remove_bpe=None,
)
print(
"E-{}_{}\t{}".format(sample_id, step, h_str),
file=output_file,
)
# Score only the top hypothesis
if has_target and j == 0:
if (
align_dict is not None
or cfg.common_eval.post_process is not None
):
# Convert back to tokens for evaluation with unk replacement and/or without BPE
target_tokens = tgt_dict.encode_line(
target_str, add_if_not_exist=True
)
hypo_tokens = tgt_dict.encode_line(
detok_hypo_str, add_if_not_exist=True
)
if hasattr(scorer, "add_string"):
scorer.add_string(target_str, detok_hypo_str)
else:
scorer.add(target_tokens, hypo_tokens)
wps_meter.update(num_generated_tokens)
progress.log({"wps": round(wps_meter.avg)})
num_sentences += (
sample["nsentences"] if "nsentences" in sample else sample["id"].numel()
)
logger.info("NOTE: hypothesis and token scores are output in base 2")
logger.info(
"Translated {:,} sentences ({:,} tokens) in {:.1f}s ({:.2f} sentences/s, {:.2f} tokens/s)".format(
num_sentences,
gen_timer.n,
gen_timer.sum,
num_sentences / gen_timer.sum,
1.0 / gen_timer.avg,
)
)
# if has_target:
# if cfg.bpe and not cfg.generation.sacrebleu:
# if cfg.common_eval.post_process:
# logger.warning(
# "BLEU score is being computed by splitting detokenized string on spaces, this is probably not what you want. Use --sacrebleu for standard 13a BLEU tokenization"
# )
# else:
# logger.warning(
# "If you are using BPE on the target side, the BLEU score is computed on BPE tokens, not on proper words. Use --sacrebleu for standard 13a BLEU tokenization"
# )
# # use print to be consistent with other main outputs: S-, H-, T-, D- and so on
# print(
# "Generate {} with beam={}: {}".format(
# cfg.dataset.gen_subset, cfg.generation.beam, scorer.result_string()
# ),
# file=output_file,
# )
return scorer
def cli_main():
parser = options.get_generation_parser()
# TODO: replace this workaround with refactoring of `AudioPretraining`
parser.add_argument(
"--arch",
"-a",
metavar="ARCH",
default="wav2vec2",
help="Model architecture. For constructing tasks that rely on "
"model args (e.g. `AudioPretraining`)",
)
args = options.parse_args_and_arch(parser)
if args.model_parallel_size > 1:
print("run megatron mode...")
distributed_utils.call_main(convert_namespace_to_omegaconf(args), main)
else:
main(args)
if __name__ == "__main__":
cli_main()
| xlmr/src/generate.py | dropreg-ChatMLM-273477a | [
{
"filename": "xlmr/src/generate2.py",
"retrieved_chunk": " target_str = tgt_dict.string(\n target_tokens,\n cfg.common_eval.post_process,\n escape_unk=True,\n extra_symbols_to_ignore=get_symbols_to_strip_from_output(\n generator\n ),\n )\n src_str = decode_fn(src_str)\n if has_target:",
"score": 0.8741445541381836
},
{
"filename": "xlmr/src/nar_generate.py",
"retrieved_chunk": " hypo_tokens, hypo_str, alignment = utils.post_process_prediction(\n hypo_tokens=hypo[\"tokens\"].int().cpu(),\n src_str=src_str,\n alignment=hypo[\"alignment\"],\n align_dict=align_dict,\n tgt_dict=tgt_dict,\n remove_bpe=cfg.common_eval.post_process,\n extra_symbols_to_ignore=get_symbols_to_strip_from_output(generator),\n )\n detok_hypo_str = decode_fn(hypo_str)",
"score": 0.8420302271842957
},
{
"filename": "xlmr/src/nar_generate.py",
"retrieved_chunk": " src_str = \"\"\n if has_target:\n target_str = tgt_dict.string(\n target_tokens,\n cfg.common_eval.post_process,\n escape_unk=True,\n extra_symbols_to_ignore=get_symbols_to_strip_from_output(\n generator\n ),\n )",
"score": 0.8397323489189148
},
{
"filename": "xlmr/src/generate2.py",
"retrieved_chunk": " target_str = decode_fn(target_str)\n if not cfg.common_eval.quiet:\n if src_dict is not None:\n print(\"S-{}\\t{}\".format(sample_id, src_str), file=output_file)\n if has_target:\n print(\"T-{}\\t{}\".format(sample_id, target_str), file=output_file)\n # Process top predictions\n for j, hypo in enumerate(hypos[i][: cfg.generation.nbest]):\n hypo_tokens, hypo_str, alignment = utils.post_process_prediction(\n hypo_tokens=hypo[\"tokens\"].int().cpu(),",
"score": 0.8394893407821655
},
{
"filename": "xlmr/src/nar_generate.py",
"retrieved_chunk": " src_str = decode_fn(src_str)\n if has_target:\n target_str = decode_fn(target_str)\n if not cfg.common_eval.quiet:\n if src_dict is not None:\n print(\"S-{}\\t{}\".format(sample_id, src_str), file=output_file)\n if has_target:\n print(\"T-{}\\t{}\".format(sample_id, target_str), file=output_file)\n # Process top predictions\n for j, hypo in enumerate(hypos[i][: cfg.generation.nbest]):",
"score": 0.8312344551086426
}
] | python | get_model_parallel_rank()) |
'''
* Copyright (c) 2023, Salesforce, Inc.
* All rights reserved.
* SPDX-License-Identifier: BSD-3-Clause
* For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
'''
import re
import numpy as np
from ..llm_wrapper import OpenAILLM, LocalLLM
from .openAIscorers.constants import prompt_templates
from .utils import get_instruction, retrieve_global_knowledge
from tqdm import tqdm
import numpy as np
def gpt3_score(model_name, data, global_knowledge=''):
template = prompt_templates['gpt3_score']
gpt3model = OpenAILLM(model_name)
scores, meta_data = [], []
for sample in tqdm(data):
instruction = get_instruction(sample)
target = sample["output"]
if not target.endswith("\n"):
target += "\n"
local_knowledge = sample["knowledge"]
input_ = template.format(instruction=instruction,
local_knowledge=local_knowledge,
global_knowledge=retrieve_global_knowledge(target, global_knowledge),
output="")
gen_param = {
"temperature":0,
"logprobs":0,
"stop":'\n',
"echo":True,
"n": None,
}
response = gpt3model.generate(input_ + target, **gen_param)
result = gpt3model. | responses[-1]['choices'][0] |
i = result['logprobs']['text_offset'].index(len(input_) - 1)
if i == 0:
i = 1
loss = -sum(result['logprobs']["token_logprobs"][i:-1])
avg_loss = loss / (len(result['logprobs']['text_offset']) - i - 1) # 1 is the last '.'
ppl = np.exp(avg_loss)
scores.append(1 / ppl)
meta_data.append(f"PPL:{ppl}")
return scores, meta_data
def chatgpt_score(model_name, data, global_knowledge=''):
chatgptmodel = OpenAILLM(model_name)
template = prompt_templates['chatgpt_evaluator']
stars_mapping = {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5}
scores = []
for sample in tqdm(data):
instruction = get_instruction(sample)
target = sample["output"]
local_knowledge = sample["knowledge"]
input_ = template.format(instruction=instruction,
local_knowledge=local_knowledge,
global_knowledge=retrieve_global_knowledge(target, global_knowledge),
output=target)
response = chatgptmodel.generate(input_)
result = chatgptmodel.responses[-1]['choices'][0]['message']['content']
rating = re.search(r'\b(\w+)\s+(?:star|stars)\b', result.lower())
try:
scores.append(stars_mapping[rating.group(1)] / 5)
except:
scores.append(0.5)
# scores.append(f"Couldn't match regex, ChatGPT output:{result}")
return scores
def localllm_score(method, data, global_knowledge=''):
task = "text-generation" if "gpt" in method else "text2text-generation"
model = LocalLLM(model_name = method, task = task)
template = prompt_templates['localllm_score']
stars_mapping = {'one': 1, 'two': 2, 'three': 3, '1': 1, '2': 2, '3': 3}
scores = []
for sample in tqdm(data):
instruction = get_instruction(sample)
target = sample["output"]
local_knowledge = sample["knowledge"]
input_ = template.format(instruction=instruction,
local_knowledge=local_knowledge,
global_knowledge=retrieve_global_knowledge(target, global_knowledge),
output=target)
result = model.generate(input_)
try:
rating = re.search(r'\d+', result).group()
scores.append(stars_mapping[rating] / 3)
except:
scores.append(0.5)
# scores.append(f"Couldn't match regex, LocalLLM output: {result}")
return scores
def unieval(data, global_knowledge, use_cuda, gpu_device):
from .unieval_utils.evaluator import FactEvaluator
device = "cpu"
if use_cuda:
device = f"cuda:{gpu_device}"
evaluator = FactEvaluator(device=device)
scores = evaluator.evaluate(data, global_knowledge)
return scores
def opt_score(method, data, global_knowledge):
task = "llm-scorer"
evaluator = LocalLLM(method, task=task)
template = prompt_templates['opt_score']
scores, meta_data = [], []
for sample in tqdm(data):
target = sample["output"]
local_knowledge = sample["knowledge"]
prompt = """Generate a text that is factually correct and consistent with the instruction.\n"""
instruction = template.format(instruction=get_instruction(sample),
local_knowledge=local_knowledge,
global_knowledge=retrieve_global_knowledge(target, global_knowledge))
score = evaluator.score(instruction, target, prompt)
ppl = np.exp(avg_loss)
scores.append(1 / ppl)
meta_data.append(f"PPL:{ppl}")
return scores, meta_data
def summac_metric(data, global_knowledge, use_cuda, gpu_device):
from .summac_utils.evaluator import SummacEvaluator
device = "cpu"
if use_cuda:
device = f"cuda:{gpu_device}"
evaluator = SummacEvaluator(device=device)
scores = evaluator.evaluate(data, global_knowledge)
return scores
def qafacteval_metric(data, global_knowledge, use_cuda, gpu_device):
from .qafacteval_utils.evaluator import QAFactEvalEvaluator
evaluator = QAFactEvalEvaluator(device=gpu_device if use_cuda else -1)
scores = evaluator.evaluate(data, global_knowledge)
return scores
| src/auditnlg/factualness/classifier.py | salesforce-AuditNLG-c473044 | [
{
"filename": "src/auditnlg/regeneration/self_refine/pipeline.py",
"retrieved_chunk": " gen_param = {\n \"max_tokens\":128\n }\n return model.generate(input_txt, **gen_param)",
"score": 0.8071563839912415
},
{
"filename": "src/auditnlg/regeneration/prompt_expansion/prompt_with_guidelines.py",
"retrieved_chunk": " model_input=model_input, model_output=model_output\n )\n gen_param = {\n \"max_tokens\": 128\n }\n guideline = model.generate(prompt, **gen_param)\n prompt = revised_factuality_prompt_template.format(\n model_input=model_input, guideline=guideline\n )\n revise = model.generate(prompt, **gen_param)",
"score": 0.8028876781463623
},
{
"filename": "src/auditnlg/llm_wrapper.py",
"retrieved_chunk": " output_ids = self.model.generate(\n **input_ids,\n do_sample=True,\n temperature=0.9,\n max_new_tokens=64,\n # min_new_tokens=5,\n # **gen_kwargs\n )\n output_text = self.tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0]\n if self.task == 'text2text-generation':",
"score": 0.8015057444572449
},
{
"filename": "src/auditnlg/safety/self_diagnosis/modeling.py",
"retrieved_chunk": " output_texts = ['<extra_id_0>'] * len(input_texts)\n inputs = self._tokenizer.batch_encode_plus(input_texts, padding=True, return_tensors='pt')\n inputs = {key: val.to(self._device) for key, val in inputs.items()}\n output_ids = self._tokenizer.batch_encode_plus(output_texts, return_tensors='pt')['input_ids'].to(self._device)\n return self._model(labels=output_ids, **inputs)['logits'][:, 1, :]\n def generate(self, input_text: str, **kwargs):\n assert '<extra_id_0>' in input_text\n input_ids = self._tokenizer.encode(input_text, return_tensors='pt').to(self._device)\n output_ids = self._model.generate(input_ids, **kwargs)[0]\n return self._tokenizer.decode(output_ids)",
"score": 0.7872215509414673
},
{
"filename": "src/auditnlg/llm_wrapper.py",
"retrieved_chunk": " response = openai.Completion.create(\n model=self.model_name,\n prompt=prompt,\n **gen_kwargs\n )\n message = response[\"choices\"][0][\"text\"]\n self.responses.append(response)\n self.usages.append(response[\"usage\"])\n self.completions.append(response[\"choices\"])\n return message",
"score": 0.7863095998764038
}
] | python | responses[-1]['choices'][0] |
'''
* Copyright (c) 2023, Salesforce, Inc.
* All rights reserved.
* SPDX-License-Identifier: BSD-3-Clause
* For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
'''
import re
import numpy as np
from ..llm_wrapper import OpenAILLM, LocalLLM
from .openAIscorers.constants import prompt_templates
from .utils import get_instruction, retrieve_global_knowledge
from tqdm import tqdm
import numpy as np
def gpt3_score(model_name, data, global_knowledge=''):
template = prompt_templates['gpt3_score']
gpt3model = OpenAILLM(model_name)
scores, meta_data = [], []
for sample in tqdm(data):
instruction = get_instruction(sample)
target = sample["output"]
if not target.endswith("\n"):
target += "\n"
local_knowledge = sample["knowledge"]
input_ = template.format(instruction=instruction,
local_knowledge=local_knowledge,
global_knowledge=retrieve_global_knowledge(target, global_knowledge),
output="")
gen_param = {
"temperature":0,
"logprobs":0,
"stop":'\n',
"echo":True,
"n": None,
}
response = gpt3model. | generate(input_ + target, **gen_param) |
result = gpt3model.responses[-1]['choices'][0]
i = result['logprobs']['text_offset'].index(len(input_) - 1)
if i == 0:
i = 1
loss = -sum(result['logprobs']["token_logprobs"][i:-1])
avg_loss = loss / (len(result['logprobs']['text_offset']) - i - 1) # 1 is the last '.'
ppl = np.exp(avg_loss)
scores.append(1 / ppl)
meta_data.append(f"PPL:{ppl}")
return scores, meta_data
def chatgpt_score(model_name, data, global_knowledge=''):
chatgptmodel = OpenAILLM(model_name)
template = prompt_templates['chatgpt_evaluator']
stars_mapping = {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5}
scores = []
for sample in tqdm(data):
instruction = get_instruction(sample)
target = sample["output"]
local_knowledge = sample["knowledge"]
input_ = template.format(instruction=instruction,
local_knowledge=local_knowledge,
global_knowledge=retrieve_global_knowledge(target, global_knowledge),
output=target)
response = chatgptmodel.generate(input_)
result = chatgptmodel.responses[-1]['choices'][0]['message']['content']
rating = re.search(r'\b(\w+)\s+(?:star|stars)\b', result.lower())
try:
scores.append(stars_mapping[rating.group(1)] / 5)
except:
scores.append(0.5)
# scores.append(f"Couldn't match regex, ChatGPT output:{result}")
return scores
def localllm_score(method, data, global_knowledge=''):
task = "text-generation" if "gpt" in method else "text2text-generation"
model = LocalLLM(model_name = method, task = task)
template = prompt_templates['localllm_score']
stars_mapping = {'one': 1, 'two': 2, 'three': 3, '1': 1, '2': 2, '3': 3}
scores = []
for sample in tqdm(data):
instruction = get_instruction(sample)
target = sample["output"]
local_knowledge = sample["knowledge"]
input_ = template.format(instruction=instruction,
local_knowledge=local_knowledge,
global_knowledge=retrieve_global_knowledge(target, global_knowledge),
output=target)
result = model.generate(input_)
try:
rating = re.search(r'\d+', result).group()
scores.append(stars_mapping[rating] / 3)
except:
scores.append(0.5)
# scores.append(f"Couldn't match regex, LocalLLM output: {result}")
return scores
def unieval(data, global_knowledge, use_cuda, gpu_device):
from .unieval_utils.evaluator import FactEvaluator
device = "cpu"
if use_cuda:
device = f"cuda:{gpu_device}"
evaluator = FactEvaluator(device=device)
scores = evaluator.evaluate(data, global_knowledge)
return scores
def opt_score(method, data, global_knowledge):
task = "llm-scorer"
evaluator = LocalLLM(method, task=task)
template = prompt_templates['opt_score']
scores, meta_data = [], []
for sample in tqdm(data):
target = sample["output"]
local_knowledge = sample["knowledge"]
prompt = """Generate a text that is factually correct and consistent with the instruction.\n"""
instruction = template.format(instruction=get_instruction(sample),
local_knowledge=local_knowledge,
global_knowledge=retrieve_global_knowledge(target, global_knowledge))
score = evaluator.score(instruction, target, prompt)
ppl = np.exp(avg_loss)
scores.append(1 / ppl)
meta_data.append(f"PPL:{ppl}")
return scores, meta_data
def summac_metric(data, global_knowledge, use_cuda, gpu_device):
from .summac_utils.evaluator import SummacEvaluator
device = "cpu"
if use_cuda:
device = f"cuda:{gpu_device}"
evaluator = SummacEvaluator(device=device)
scores = evaluator.evaluate(data, global_knowledge)
return scores
def qafacteval_metric(data, global_knowledge, use_cuda, gpu_device):
from .qafacteval_utils.evaluator import QAFactEvalEvaluator
evaluator = QAFactEvalEvaluator(device=gpu_device if use_cuda else -1)
scores = evaluator.evaluate(data, global_knowledge)
return scores
| src/auditnlg/factualness/classifier.py | salesforce-AuditNLG-c473044 | [
{
"filename": "src/auditnlg/regeneration/self_refine/pipeline.py",
"retrieved_chunk": " gen_param = {\n \"max_tokens\":128\n }\n return model.generate(input_txt, **gen_param)",
"score": 0.8018251657485962
},
{
"filename": "src/auditnlg/llm_wrapper.py",
"retrieved_chunk": " output_ids = self.model.generate(\n **input_ids,\n do_sample=True,\n temperature=0.9,\n max_new_tokens=64,\n # min_new_tokens=5,\n # **gen_kwargs\n )\n output_text = self.tokenizer.batch_decode(output_ids, skip_special_tokens=True)[0]\n if self.task == 'text2text-generation':",
"score": 0.791551947593689
},
{
"filename": "src/auditnlg/regeneration/prompt_expansion/prompt_with_guidelines.py",
"retrieved_chunk": " model_input=model_input, model_output=model_output\n )\n gen_param = {\n \"max_tokens\": 128\n }\n guideline = model.generate(prompt, **gen_param)\n prompt = revised_factuality_prompt_template.format(\n model_input=model_input, guideline=guideline\n )\n revise = model.generate(prompt, **gen_param)",
"score": 0.7887622117996216
},
{
"filename": "src/auditnlg/safety/self_diagnosis/modeling.py",
"retrieved_chunk": " output_texts = ['<extra_id_0>'] * len(input_texts)\n inputs = self._tokenizer.batch_encode_plus(input_texts, padding=True, return_tensors='pt')\n inputs = {key: val.to(self._device) for key, val in inputs.items()}\n output_ids = self._tokenizer.batch_encode_plus(output_texts, return_tensors='pt')['input_ids'].to(self._device)\n return self._model(labels=output_ids, **inputs)['logits'][:, 1, :]\n def generate(self, input_text: str, **kwargs):\n assert '<extra_id_0>' in input_text\n input_ids = self._tokenizer.encode(input_text, return_tensors='pt').to(self._device)\n output_ids = self._model.generate(input_ids, **kwargs)[0]\n return self._tokenizer.decode(output_ids)",
"score": 0.7740051746368408
},
{
"filename": "src/auditnlg/regeneration/constitutional_ai/critique_revise.py",
"retrieved_chunk": ")\ngen_param = {\n \"max_tokens\": 128\n}\ndef run_pipeline(model_input: str, model_output: str, model) -> str:\n critique_prompt = critique_prompt_template.format(model_input=model_input, model_output=model_output)\n critique = model.generate(critique_prompt, **gen_param)\n # print(f\"Critique output: {critique}\")\n revise_prompt = revise_prompt_template.format(model_input=model_input, model_output=model_output, critique=critique)\n revise = model.generate(revise_prompt, **gen_param)",
"score": 0.773232102394104
}
] | python | generate(input_ + target, **gen_param) |
'''
* Copyright (c) 2023, Salesforce, Inc.
* All rights reserved.
* SPDX-License-Identifier: BSD-3-Clause
* For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
'''
from .prompts import constraint_identification_prompt, constraint_checking_prompt
from ..llm_wrapper import OpenAILLM, LocalLLM
from tqdm import tqdm
# Read all the possible inputs and decide in the evaluation function how to use them.
def format_model_inputs(sample):
return sample["prompt_all"], sample["prompt_task"], sample["prompt_context"], sample["output"]
"""
main function that evaluates and scores how well the constraints in the prompt are satisfied by the output
TODO:
1. What score for no constraints? (full?) - current scores it as 1.0 if no constraints identified
2. How to use the local and global knowledge here? -- Initial thoughts: Local or Global knowledge is only useful for factual verification not for constraint check
Scoring the constraints in 2 steps:
1. constraint identification using only prompt as the input
2. checking constraints as a set of rules against the LLM output
"""
def evaluate_2step_prompt(method, data, global_knowledge=''):
constraint_scores = []
score_reasoning = []
if "openai" in method:
model = OpenAILLM(model_name = method.split("/")[-1])
else:
model_task = "text-generation" if "gpt" in method else "text2text-generation"
model = LocalLLM(model_name = method, task = model_task)
for sample in tqdm(data):
prompt_all, task, input_doc, llm_output = format_model_inputs(sample)
# populate the prompt
if prompt_all: # if instruction and document provided together, no option but to use both for identification
prompt_identification = constraint_identification_prompt.format(instructions=prompt_all)
else:
prompt_identification = constraint_identification_prompt.format(instructions=task)
# run the prompt
constraints_found = model. | generate(prompt=prompt_identification, messages="") |
if 'No Constraints.' in constraints_found:
constraint_scores.append(1.0)
score_reasoning.append(constraints_found)
continue
# if specific constraints found
prompt_checking = constraint_checking_prompt.format(llm_output=llm_output, constraints=constraints_found)
constraints_checked = model.generate(prompt=prompt_checking, messages="")
satisfied = []
for constraint in constraints_checked.split("\n"):
if constraint and 'Constraint' in constraint:
# count the num of yes-es
if "Yes" in constraint:
satisfied.append(1)
else:
satisfied.append(0)
score = sum(satisfied)/len(satisfied)
# Use full response text as the reasoning
constraint_scores.append(score)
score_reasoning.append(constraints_found + "\n" + constraints_checked)
# TODO: Add exact constraint checked back into the reasoning for it to make sense
meta_data = {
"aspect_explanation": score_reasoning
}
# print ("\n==================\nconstraint_scores 2 step: ", constraint_scores)
return constraint_scores, meta_data
| src/auditnlg/constraint/constraint_checker.py | salesforce-AuditNLG-c473044 | [
{
"filename": "src/auditnlg/factualness/classifier.py",
"retrieved_chunk": " for sample in tqdm(data):\n instruction = get_instruction(sample)\n target = sample[\"output\"]\n local_knowledge = sample[\"knowledge\"]\n input_ = template.format(instruction=instruction,\n local_knowledge=local_knowledge,\n global_knowledge=retrieve_global_knowledge(target, global_knowledge),\n output=target)\n response = chatgptmodel.generate(input_)\n result = chatgptmodel.responses[-1]['choices'][0]['message']['content']",
"score": 0.865232527256012
},
{
"filename": "src/auditnlg/factualness/classifier.py",
"retrieved_chunk": " template = prompt_templates['opt_score']\n scores, meta_data = [], []\n for sample in tqdm(data):\n target = sample[\"output\"]\n local_knowledge = sample[\"knowledge\"]\n prompt = \"\"\"Generate a text that is factually correct and consistent with the instruction.\\n\"\"\"\n instruction = template.format(instruction=get_instruction(sample),\n local_knowledge=local_knowledge,\n global_knowledge=retrieve_global_knowledge(target, global_knowledge))\n score = evaluator.score(instruction, target, prompt)",
"score": 0.8618389368057251
},
{
"filename": "src/auditnlg/factualness/classifier.py",
"retrieved_chunk": " template = prompt_templates['localllm_score']\n stars_mapping = {'one': 1, 'two': 2, 'three': 3, '1': 1, '2': 2, '3': 3}\n scores = []\n for sample in tqdm(data):\n instruction = get_instruction(sample)\n target = sample[\"output\"]\n local_knowledge = sample[\"knowledge\"]\n input_ = template.format(instruction=instruction,\n local_knowledge=local_knowledge,\n global_knowledge=retrieve_global_knowledge(target, global_knowledge),",
"score": 0.8607468605041504
},
{
"filename": "src/auditnlg/safety/safety_generator.py",
"retrieved_chunk": " inputs = []\n for sample in data:\n if \"prompt_all\" in sample.keys() and sample[\"prompt_all\"] != \"\":\n input_sample = \"<Text> {} <Context> {}\".format(sample[\"output\"], sample[\"prompt_all\"])\n elif \"prompt_context\" in sample.keys() and sample[\"prompt_context\"] != \"\":\n input_sample = \"<Text> {} <Context> {}\".format(sample[\"output\"], sample[\"prompt_context\"])\n else:\n input_sample = \"<Text> {} <Context> {}\".format(sample[\"output\"], \"\")\n inputs.append(input_sample)\n inputs = [prefix + inp for inp in inputs]",
"score": 0.8435789942741394
},
{
"filename": "src/auditnlg/explain.py",
"retrieved_chunk": " data = example_format_checker(data)\n gen_kwargs = {\n \"max_tokens\": 128\n }\n explanations = []\n for i, sample in enumerate(tqdm(data)):\n input_ = explain_template.format(\n instruction = get_instruction(sample),\n local_knowledge = sample[\"knowledge\"],\n global_knowledge = retrieve_global_knowledge(sample[\"output\"], global_knowledge),",
"score": 0.8198809027671814
}
] | python | generate(prompt=prompt_identification, messages="") |
'''
* Copyright (c) 2023, Salesforce, Inc.
* All rights reserved.
* SPDX-License-Identifier: BSD-3-Clause
* For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
'''
from .prompts import constraint_identification_prompt, constraint_checking_prompt
from ..llm_wrapper import OpenAILLM, LocalLLM
from tqdm import tqdm
# Read all the possible inputs and decide in the evaluation function how to use them.
def format_model_inputs(sample):
return sample["prompt_all"], sample["prompt_task"], sample["prompt_context"], sample["output"]
"""
main function that evaluates and scores how well the constraints in the prompt are satisfied by the output
TODO:
1. What score for no constraints? (full?) - current scores it as 1.0 if no constraints identified
2. How to use the local and global knowledge here? -- Initial thoughts: Local or Global knowledge is only useful for factual verification not for constraint check
Scoring the constraints in 2 steps:
1. constraint identification using only prompt as the input
2. checking constraints as a set of rules against the LLM output
"""
def evaluate_2step_prompt(method, data, global_knowledge=''):
constraint_scores = []
score_reasoning = []
if "openai" in method:
model = OpenAILLM(model_name = method.split("/")[-1])
else:
model_task = "text-generation" if "gpt" in method else "text2text-generation"
model = LocalLLM(model_name = method, task = model_task)
for sample in tqdm(data):
prompt_all, task, input_doc, llm_output = format_model_inputs(sample)
# populate the prompt
if prompt_all: # if instruction and document provided together, no option but to use both for identification
prompt_identification = constraint_identification_prompt.format(instructions=prompt_all)
else:
prompt_identification = constraint_identification_prompt.format(instructions=task)
# run the prompt
constraints_found = model.generate(prompt=prompt_identification, messages="")
if 'No Constraints.' in constraints_found:
constraint_scores.append(1.0)
score_reasoning.append(constraints_found)
continue
# if specific constraints found
prompt_checking = constraint_checking_prompt. | format(llm_output=llm_output, constraints=constraints_found) |
constraints_checked = model.generate(prompt=prompt_checking, messages="")
satisfied = []
for constraint in constraints_checked.split("\n"):
if constraint and 'Constraint' in constraint:
# count the num of yes-es
if "Yes" in constraint:
satisfied.append(1)
else:
satisfied.append(0)
score = sum(satisfied)/len(satisfied)
# Use full response text as the reasoning
constraint_scores.append(score)
score_reasoning.append(constraints_found + "\n" + constraints_checked)
# TODO: Add exact constraint checked back into the reasoning for it to make sense
meta_data = {
"aspect_explanation": score_reasoning
}
# print ("\n==================\nconstraint_scores 2 step: ", constraint_scores)
return constraint_scores, meta_data
| src/auditnlg/constraint/constraint_checker.py | salesforce-AuditNLG-c473044 | [
{
"filename": "src/auditnlg/constraint/prompts.py",
"retrieved_chunk": "\"\"\"\nconstraint_identification_prompt = PromptTemplate(\n input_variables=[\"instructions\"],\n template=identification_only,\n)\nchecking_only = \"\"\"\nYour job is to assess the quality of a text document, given a set of rules or constraints. You will be provided with a text document and a list of rules or constraints to check one by one. For each constraint answer Yes/No if the given text satisfies it. Only check for constaints that you are completely sure about. See the examples below and follow their structure.\nList of constraints:\n* Constraint 1: Number of characters. Function template: constraint_num_characters(<output_text>, <min_num_characters>, <max_num_characters>)\n* Constraint 2: Number of words. Function template: constraint_num_words(<output_text>, <min_num_words>, <max_num_words>)",
"score": 0.8385084867477417
},
{
"filename": "src/auditnlg/constraint/prompts.py",
"retrieved_chunk": "1. Constraint 2: Yes.\n2. Constraint 11: Yes\nInput Text: {llm_output}\n{constraints}\nOutput: \n\"\"\"\nconstraint_checking_prompt = PromptTemplate(\n input_variables=[\"llm_output\", \"constraints\"],\n template=checking_only,\n)",
"score": 0.8345026969909668
},
{
"filename": "src/auditnlg/constraint/prompts.py",
"retrieved_chunk": "in case it is difficult for the LLM to understand the structure constraint as a whole\n\"\"\"\nidentification_only = \"\"\"\nGiven the instruction and the list of available constraints below, select which constraints should be checked for this particular instruction. Only select constraints/rules from the given list that are explicitly mentioned in the instruction. Ignore optional or implied constraints. If there are no constraints found from the above list, the output will be 'No Constraints'. For each constraint, specify what the filled function call should look like. See the examples below and follow their structure.\nList of constraints:\n* Constraint 1: Number of characters. Function template: constraint_num_characters(<output_text>, <min_num_characters>, <max_num_characters>)\n* Constraint 2: Number of words. Function template: constraint_num_words(<output_text>, <min_num_words>, <max_num_words>)\n* Constraint 3: Number of sentences. Function template: constraint_num_sentences(<output_text>, <min_num_sentences>, <max_num_sentences>)\n* Constraint 4: Number of paragraphs. Function template: constraint_num_paragraphs(<output_text>, <min_num_paragraphs>, <max_num_paragraphs>)\n* Constraint 5: Check lowercase. Function template: constraint_check_lowercase(<output_text>)",
"score": 0.8208749890327454
},
{
"filename": "src/auditnlg/factualness/classifier.py",
"retrieved_chunk": " template = prompt_templates['opt_score']\n scores, meta_data = [], []\n for sample in tqdm(data):\n target = sample[\"output\"]\n local_knowledge = sample[\"knowledge\"]\n prompt = \"\"\"Generate a text that is factually correct and consistent with the instruction.\\n\"\"\"\n instruction = template.format(instruction=get_instruction(sample),\n local_knowledge=local_knowledge,\n global_knowledge=retrieve_global_knowledge(target, global_knowledge))\n score = evaluator.score(instruction, target, prompt)",
"score": 0.8032969832420349
},
{
"filename": "src/auditnlg/factualness/classifier.py",
"retrieved_chunk": " template = prompt_templates['localllm_score']\n stars_mapping = {'one': 1, 'two': 2, 'three': 3, '1': 1, '2': 2, '3': 3}\n scores = []\n for sample in tqdm(data):\n instruction = get_instruction(sample)\n target = sample[\"output\"]\n local_knowledge = sample[\"knowledge\"]\n input_ = template.format(instruction=instruction,\n local_knowledge=local_knowledge,\n global_knowledge=retrieve_global_knowledge(target, global_knowledge),",
"score": 0.8028611540794373
}
] | python | format(llm_output=llm_output, constraints=constraints_found) |
'''
* Copyright (c) 2023, Salesforce, Inc.
* All rights reserved.
* SPDX-License-Identifier: BSD-3-Clause
* For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
'''
from .prompts import constraint_identification_prompt, constraint_checking_prompt
from ..llm_wrapper import OpenAILLM, LocalLLM
from tqdm import tqdm
# Read all the possible inputs and decide in the evaluation function how to use them.
def format_model_inputs(sample):
return sample["prompt_all"], sample["prompt_task"], sample["prompt_context"], sample["output"]
"""
main function that evaluates and scores how well the constraints in the prompt are satisfied by the output
TODO:
1. What score for no constraints? (full?) - current scores it as 1.0 if no constraints identified
2. How to use the local and global knowledge here? -- Initial thoughts: Local or Global knowledge is only useful for factual verification not for constraint check
Scoring the constraints in 2 steps:
1. constraint identification using only prompt as the input
2. checking constraints as a set of rules against the LLM output
"""
def evaluate_2step_prompt(method, data, global_knowledge=''):
constraint_scores = []
score_reasoning = []
if "openai" in method:
model = OpenAILLM(model_name = method.split("/")[-1])
else:
model_task = "text-generation" if "gpt" in method else "text2text-generation"
model = LocalLLM(model_name = method, task = model_task)
for sample in tqdm(data):
prompt_all, task, input_doc, llm_output = format_model_inputs(sample)
# populate the prompt
if prompt_all: # if instruction and document provided together, no option but to use both for identification
prompt_identification = constraint_identification_prompt. | format(instructions=prompt_all) |
else:
prompt_identification = constraint_identification_prompt.format(instructions=task)
# run the prompt
constraints_found = model.generate(prompt=prompt_identification, messages="")
if 'No Constraints.' in constraints_found:
constraint_scores.append(1.0)
score_reasoning.append(constraints_found)
continue
# if specific constraints found
prompt_checking = constraint_checking_prompt.format(llm_output=llm_output, constraints=constraints_found)
constraints_checked = model.generate(prompt=prompt_checking, messages="")
satisfied = []
for constraint in constraints_checked.split("\n"):
if constraint and 'Constraint' in constraint:
# count the num of yes-es
if "Yes" in constraint:
satisfied.append(1)
else:
satisfied.append(0)
score = sum(satisfied)/len(satisfied)
# Use full response text as the reasoning
constraint_scores.append(score)
score_reasoning.append(constraints_found + "\n" + constraints_checked)
# TODO: Add exact constraint checked back into the reasoning for it to make sense
meta_data = {
"aspect_explanation": score_reasoning
}
# print ("\n==================\nconstraint_scores 2 step: ", constraint_scores)
return constraint_scores, meta_data
| src/auditnlg/constraint/constraint_checker.py | salesforce-AuditNLG-c473044 | [
{
"filename": "src/auditnlg/regeneration/modeling.py",
"retrieved_chunk": " else:\n task = \"text-generation\" if \"gpt\" in method else \"text2text-generation\"\n return LocalLLM(model_name = method.split(\"/#\")[0], task = task)",
"score": 0.8527202606201172
},
{
"filename": "src/auditnlg/factualness/classifier.py",
"retrieved_chunk": " template = prompt_templates['localllm_score']\n stars_mapping = {'one': 1, 'two': 2, 'three': 3, '1': 1, '2': 2, '3': 3}\n scores = []\n for sample in tqdm(data):\n instruction = get_instruction(sample)\n target = sample[\"output\"]\n local_knowledge = sample[\"knowledge\"]\n input_ = template.format(instruction=instruction,\n local_knowledge=local_knowledge,\n global_knowledge=retrieve_global_knowledge(target, global_knowledge),",
"score": 0.8375648260116577
},
{
"filename": "src/auditnlg/factualness/classifier.py",
"retrieved_chunk": " for sample in tqdm(data):\n instruction = get_instruction(sample)\n target = sample[\"output\"]\n local_knowledge = sample[\"knowledge\"]\n input_ = template.format(instruction=instruction,\n local_knowledge=local_knowledge,\n global_knowledge=retrieve_global_knowledge(target, global_knowledge),\n output=target)\n response = chatgptmodel.generate(input_)\n result = chatgptmodel.responses[-1]['choices'][0]['message']['content']",
"score": 0.8314133882522583
},
{
"filename": "src/auditnlg/factualness/classifier.py",
"retrieved_chunk": "from .utils import get_instruction, retrieve_global_knowledge\nfrom tqdm import tqdm\nimport numpy as np\ndef gpt3_score(model_name, data, global_knowledge=''):\n template = prompt_templates['gpt3_score']\n gpt3model = OpenAILLM(model_name)\n scores, meta_data = [], []\n for sample in tqdm(data):\n instruction = get_instruction(sample)\n target = sample[\"output\"]",
"score": 0.8231512308120728
},
{
"filename": "src/auditnlg/factualness/classifier.py",
"retrieved_chunk": " template = prompt_templates['opt_score']\n scores, meta_data = [], []\n for sample in tqdm(data):\n target = sample[\"output\"]\n local_knowledge = sample[\"knowledge\"]\n prompt = \"\"\"Generate a text that is factually correct and consistent with the instruction.\\n\"\"\"\n instruction = template.format(instruction=get_instruction(sample),\n local_knowledge=local_knowledge,\n global_knowledge=retrieve_global_knowledge(target, global_knowledge))\n score = evaluator.score(instruction, target, prompt)",
"score": 0.8190562725067139
}
] | python | format(instructions=prompt_all) |
import os
import bpy
import platform
import datetime
import re
import tempfile
from .. import props
from . import common
def get_default_path():
if platform.system() == "Windows":
appdata_folder = os.path.join(os.environ["APPDATA"])
else:
appdata_folder = os.path.join(os.environ["HOME"], ".config")
return appdata_folder
def build_new_file_path():
current_time = datetime.datetime.now().strftime("%Y.%m.%d_%H-%M-%S")
timestep_regex = r"\d{4}\.\d{2}\.\d{2}_\d{2}-\d{2}-\d{2}"
new_path = re.sub(timestep_regex, current_time, bpy.context.window_manager.my_addon_props.file_path)
return new_path
def match_in_timestep():
if os.path.exists(bpy.context.window_manager.my_addon_props.file_path):
timestep_regex = r"\d{4}\.\d{2}\.\d{2}_\d{2}-\d{2}-\d{2}"
matched1 = re.search(timestep_regex, bpy.context.window_manager.my_addon_props.file_path)
return matched1
else:
return False
def create_new_file_path():
file_name = "my_blend_file_"
current_time = datetime.datetime.now().strftime("%Y.%m.%d_%H-%M-%S")
addonpref = props.preference.prefs()
created_filepath = os.path.join(addonpref.livesavede, file_name + current_time + ".blend")
return created_filepath
def create_new_file_path_version():
project_name = os.path.splitext(os.path.basename(bpy.context.window_manager.my_addon_props.file_path))[0]
# Create the version folder name with the project name and version count
version_folder_name = f"{project_name}_version_folder"
# Create the full path for the version folder
version_folder_path = os.path.join(os.path.dirname(bpy.context.window_manager.my_addon_props.file_path),
version_folder_name)
return version_folder_path
def build_new_p_file_path_version():
file_name = "my_blend_file_"
current_time = datetime.datetime.now().strftime("%Y.%m.%d_%H-%M-%S")
addonpref = props.preference.prefs()
created_filepath = os.path.join(addonpref.livesavede, file_name + current_time)
version_folder_name = f"{created_filepath}_permenant_version_folder"
version_folder_path = os.path.join(os.path.dirname(bpy.context.window_manager.my_addon_props.file_path),
version_folder_name)
return version_folder_path
def make_image_dir():
addonpref = props.preference.prefs()
image_dir = os.path.join(addonpref.image_file_path, "Images from Blender")
if not os.path.exists(image_dir):
os.mkdir(image_dir)
return image_dir
def make_image_file_path_udim(image_name):
image_dir = make_image_dir()
currrent_time = datetime.datetime.now().strftime("%Y.%m.%d_%H-%M-%S")
udim = '<UDIM>'
image_file_path = os.path.join(image_dir, image_name + currrent_time + udim + common. | file_extension_format()) |
return image_file_path
def make_image_file_path(image_name):
image_dir = make_image_dir()
currrent_time = datetime.datetime.now().strftime("%Y.%m.%d_%H-%M-%S")
image_file_path = os.path.join(image_dir, image_name + currrent_time + common.file_extension_format())
return image_file_path
# file_name = "live_backup"
# current_time = datetime.datetime.now().strftime("%Y.%m.%d_%H-%M-%S")
# file_path = os.path.join(appdata_folder, file_name + current_time + ".blend")
| Live_Addon/utils/file_path.py | pro470-Live-Save-for-Blender-3b5c1c2 | [
{
"filename": "Live_Addon/timer/save_version.py",
"retrieved_chunk": " version_folder_path = os.path.join(os.path.dirname(filepath), version_folder_name)\n # Create the version folder if it doesn't exist\n if not os.path.exists(version_folder_path):\n os.makedirs(version_folder_path, exist_ok=True)\n elif not os.path.isdir(file_path12) and matched_blend and os.path.exists(file_path12) and utils.comparison.compare_blend_data():\n version_folder_path = bpy.context.window_manager.my_addon_props.file_path_version\n # Extract name without the .blender extension but not with os.path.splitext\n #project_name = os.path.basename(version_folder_path)\n #create project name without the .blend extension\n #project_name = project_name[:-15]",
"score": 0.7995824813842773
},
{
"filename": "Live_Addon/utils/common.py",
"retrieved_chunk": " project_name = os.path.splitext(os.path.basename(file_path))[0]\n dirname = os.path.dirname(file_path)\n p_version_folder_name = f\"{project_name}_permenant_version\"\n p_version_folder_path = os.path.join(dirname, p_version_folder_name)\n print(p_version_folder_path)\n target_folder = p_version_folder_path\n if os.path.exists(target_folder):\n # get the directory and filename without extension\n directory, filename = os.path.split(file_path)\n filename, ext = os.path.splitext(filename)",
"score": 0.7897286415100098
},
{
"filename": "Live_Addon/utils/saving_function.py",
"retrieved_chunk": " new_file_path = fph.build_new_file_path()\n print(\"im about to delete\")\n print(bpy.context.window_manager.my_addon_props.file_path, new_file_path)\n os.rename(bpy.context.window_manager.my_addon_props.file_path, new_file_path)\n print(\"i deleted\")\n bpy.context.window_manager.my_addon_props.file_path = new_file_path\n if os.path.exists(bpy.context.window_manager.my_addon_props.file_path_version):\n new_version_folder = fph.create_new_file_path_version()\n os.rename(bpy.context.window_manager.my_addon_props.file_path_version, new_version_folder)\n bpy.context.window_manager.my_addon_props.file_path_version = new_version_folder",
"score": 0.776116132736206
},
{
"filename": "Live_Addon/utils/saving_function.py",
"retrieved_chunk": " except Exception as e:\n print(str(e))\n if not os.path.exists(img.filepath):\n img.filepath = file_path.make_image_file_path_udim(img.name)\n img.save()\ndef save_blend_file():\n if bpy.data.is_saved:\n bpy.ops.wm.save_mainfile()\n elif comparison.compare_blend_data():\n if fph.match_in_timestep():",
"score": 0.7758666276931763
},
{
"filename": "Live_Addon/utils/common.py",
"retrieved_chunk": " original_file_path = os.path.join(dirname, new_filename + ext)\n return original_file_path\n else:\n print(\"This is the original file!\")\n return original_file_path\ndef go_to_original_test():\n new_filepath = go_to_original()\n # check if the new filepath exists\n if os.path.exists(new_filepath):\n print(f\"{new_filepath} already exists!\")",
"score": 0.7744607329368591
}
] | python | file_extension_format()) |
'''
* Copyright (c) 2023, Salesforce, Inc.
* All rights reserved.
* SPDX-License-Identifier: BSD-3-Clause
* For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
'''
from .summac.summac.model_summac import SummaCConv
from ..utils import retrieve_global_knowledge, get_instruction
class SummacEvaluator:
def __init__(self, device='cuda:0'):
""" Set up evaluator for factual consistency detection """
import nltk
nltk.download('punkt')
self.model_conv = SummaCConv(models=["vitc"], bins='percentile', granularity="sentence", \
nli_labels="e", device=device, start_file="default", agg="mean")
def evaluate(self, data, global_knowledge):
sources = []
generateds = []
for sample in data:
source = '\n'.join([get_instruction(sample),
sample['knowledge'],
retrieve_global_knowledge(sample['output'], global_knowledge)])
sources.append(source)
generateds.append(sample['output'])
scores = self.model_conv. | score(sources, generateds)["scores"] |
return scores
| src/auditnlg/factualness/summac_utils/evaluator.py | salesforce-AuditNLG-c473044 | [
{
"filename": "src/auditnlg/factualness/unieval_utils/evaluator.py",
"retrieved_chunk": " n_sents = [] # the number of sentences in the claim\n for sample in data:\n source = '\\n'.join([get_instruction(sample),\n sample['knowledge'],\n retrieve_global_knowledge(sample['output'], global_knowledge)])\n system_outputs = sent_tokenize(sample['output'])\n n_sents.append(len(system_outputs))\n for system_output in system_outputs:\n input_list.append('question: Is this claim consistent with the document? </s> claim: ' + system_output + ' </s> document: ' + source)\n sent_score = self.scorer.score(input_list)",
"score": 0.8858364820480347
},
{
"filename": "src/auditnlg/factualness/classifier.py",
"retrieved_chunk": " template = prompt_templates['opt_score']\n scores, meta_data = [], []\n for sample in tqdm(data):\n target = sample[\"output\"]\n local_knowledge = sample[\"knowledge\"]\n prompt = \"\"\"Generate a text that is factually correct and consistent with the instruction.\\n\"\"\"\n instruction = template.format(instruction=get_instruction(sample),\n local_knowledge=local_knowledge,\n global_knowledge=retrieve_global_knowledge(target, global_knowledge))\n score = evaluator.score(instruction, target, prompt)",
"score": 0.872535228729248
},
{
"filename": "src/auditnlg/factualness/classifier.py",
"retrieved_chunk": "from .utils import get_instruction, retrieve_global_knowledge\nfrom tqdm import tqdm\nimport numpy as np\ndef gpt3_score(model_name, data, global_knowledge=''):\n template = prompt_templates['gpt3_score']\n gpt3model = OpenAILLM(model_name)\n scores, meta_data = [], []\n for sample in tqdm(data):\n instruction = get_instruction(sample)\n target = sample[\"output\"]",
"score": 0.8720500469207764
},
{
"filename": "src/auditnlg/factualness/qafacteval_utils/evaluator.py",
"retrieved_chunk": " os.remove(output_path)\n self.qafacteval = QAFactEval(cuda_device=device, use_lerc_quip=True, \\\n verbose=False, generation_batch_size=32, \\\n answering_batch_size=32, lerc_batch_size=8, \\\n lerc_quip_path=f\"models/quip-512-mocha\", \\\n answering_model_dir=f\"models/answering\")\n def evaluate(self, data, global_knowledge):\n sources = []\n generateds = []\n for sample in data:",
"score": 0.8650251626968384
},
{
"filename": "src/auditnlg/factualness/classifier.py",
"retrieved_chunk": " for sample in tqdm(data):\n instruction = get_instruction(sample)\n target = sample[\"output\"]\n local_knowledge = sample[\"knowledge\"]\n input_ = template.format(instruction=instruction,\n local_knowledge=local_knowledge,\n global_knowledge=retrieve_global_knowledge(target, global_knowledge),\n output=target)\n response = chatgptmodel.generate(input_)\n result = chatgptmodel.responses[-1]['choices'][0]['message']['content']",
"score": 0.8624650835990906
}
] | python | score(sources, generateds)["scores"] |
from unittest.mock import MagicMock
import pytest
from fastapi.testclient import TestClient
from sqlalchemy import create_engine, select
from sqlalchemy.orm import sessionmaker
from main import app
from src.database.models import Base, Role, User
from src.database.db import get_db
SQLALCHEMY_DATABASE_URL = 'sqlite:///./test.db'
engine = create_engine(
SQLALCHEMY_DATABASE_URL,
connect_args={'check_same_thread': False}
)
TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
@pytest.fixture(scope='module')
def session():
# Create the database
Base.metadata.drop_all(bind=engine)
Base.metadata.create_all(bind=engine)
db = TestingSessionLocal()
try:
yield db
finally:
db.close()
@pytest.fixture(scope='module')
def client(session):
def override_get_db():
try:
yield session
finally:
session.close()
app.dependency_overrides[get_db] = override_get_db
yield TestClient(app)
@pytest.fixture(scope='module')
def admin():
return {
'id': 1,
'username': 'admin',
'email': 'example@example.com',
'password': 'Qwerty@1',
'roles': 'admin',
'status_active': 'true',
}
@pytest.fixture(scope='module')
def user():
return {
'id': 2,
'username': 'user',
'email': 'example2@example.com',
'password': 'Qwerty@1',
'roles': 'user',
'status_active': 'true',
}
@pytest.fixture(scope='module')
def comment():
return {'comment': 'Test comment', 'image_id': '1'}
@pytest.fixture(scope='module')
def image():
return {'description': 'Test image', 'tags': 'test tag'}
@pytest.fixture
def admin_token(client, admin, session, monkeypatch):
mock_send_email = MagicMock()
monkeypatch.setattr('src.routes.auth.send_email', mock_send_email)
client.post('/api/auth/signup', json=admin)
current_user: User = session.query(User).filter_by(email=admin.get('email')).first()
current_user.id = 1
current_user.confirmed = True
current_user.roles = Role.admin
session.commit()
response = client.post(
'/api/auth/login',
data={'username': admin.get('email'), 'password': admin.get('password')},
)
data = response.json()
# return data['access_token']
return {'access_token': data['access_token'], 'refresh_token': data['refresh_token'], 'token_type': 'bearer'}
@pytest.fixture
def user_token(client, user, session, monkeypatch):
mock_send_email = MagicMock()
monkeypatch.setattr('src.routes.auth.send_email', mock_send_email)
client.post('/api/auth/signup', json=user)
current_user: User = session.query(User).filter_by(email=user.get('email')).first()
current_user.id = 2
current_user.confirmed = True
current_user.roles = Role.user
session.commit()
response = client.post(
'/api/auth/login',
data={'username': user.get('email'), 'password': user.get('password')},
)
data = response.json()
# return data['access_token']
return {'access_token': data['access_token'], 'refresh_token': data['refresh_token'], 'token_type': 'bearer'}
@pytest.fixture(scope='function')
def access_token(client, admin, session, mocker) -> str:
mocker.patch('src.routes.auth.send_email') # mocker
client.post('/api/auth/signup', json=admin)
current_user: User = session.scalar(select(User).filter(User. | email == admin['email'])) |
current_user.confirmed = True
session.commit()
response = client.post(
'/api/auth/login',
data={'username': admin.get('email'), 'password': admin.get('password')},
)
return response.json()['access_token']
@pytest.fixture(scope='function')
def access_token_user(client, user, session, mocker) -> str:
mocker.patch('src.routes.auth.send_email') # mocker
client.post('/api/auth/signup', json=user)
current_user: User = session.scalar(select(User).filter(User.email == user['email']))
current_user.confirmed = True
session.commit()
response = client.post(
'/api/auth/login',
data={'username': user.get('email'), 'password': user.get('password')},
)
return response.json()['access_token'] | tests/conftest.py | theneonwhale-frt-photo-share-6659afb | [
{
"filename": "tests/test_route_users.py",
"retrieved_chunk": " assert 'detail' in response.json()\n assert response.json()['detail'] == messages.MSC404_USER_NOT_FOUND \n response = client.put('api/users/me/1/', headers=headers, json=admin)\n assert response.status_code == status.HTTP_200_OK\n data = response.json()\n expected_response: dict = UserDb.__fields__\n for field in expected_response:\n assert field in data\ndef test_update_avatar_user(client, admin, access_token, mocker):\n mock_avatar = 'https://pypi.org/static/images/logo-small.2a411bc6.svg'",
"score": 0.8632030487060547
},
{
"filename": "tests/test_route_users.py",
"retrieved_chunk": " assert response.status_code == status.HTTP_200_OK\n data = response.json()\n expected_response: dict = UserDb.__fields__\n for field in expected_response:\n assert field in data\ndef test_update_your_profile(client, admin, access_token, user, access_token_user): # ! need\n response = client.put('api/users/me/1/', json=admin)\n assert response.status_code == status.HTTP_401_UNAUTHORIZED\n headers = {'Authorization': f'Bearer {access_token}'}\n response = client.put('api/users/me/1/', headers=headers)",
"score": 0.8578780889511108
},
{
"filename": "tests/test_route_users.py",
"retrieved_chunk": " assert field in data\n assert response.json()['email'] == admin['email']\n assert response.json()['avatar'] == mock_avatar\ndef test_ban_user(client, access_token, admin, access_token_user):\n response = client.patch('api/users/ban_user/1/true')\n assert response.status_code == status.HTTP_401_UNAUTHORIZED\n headers = {'Authorization': f'Bearer {access_token}'}\n response = client.patch('api/users/ban_user/999/true', headers=headers)\n assert 'detail' in response.json()\n assert response.json()['detail'] == messages.MSC404_USER_NOT_FOUND ",
"score": 0.8552142381668091
},
{
"filename": "tests/test_route_auth.py",
"retrieved_chunk": " assert data['token_type'] == m.TOKEN_TYPE\ndef test_logout(client, access_token):\n headers = {'Authorization': f'Bearer {access_token}'}\n response = client.get('api/auth/logout', headers=headers)\n assert response.status_code == status.HTTP_205_RESET_CONTENT\ndef test_login_fail(client, session, user): # split into several?\n current_user: User = session.query(User).filter(User.email == user.get('email')).first()\n current_user.confirmed = False\n session.commit()\n response1 = client.post('api/auth/login', data={'username': 'NonExistUser', 'password': user.get('password')})",
"score": 0.8551286458969116
},
{
"filename": "tests/test_routes_images.py",
"retrieved_chunk": " headers={'Authorization': f'''Bearer {admin_token['access_token']}'''}\n )\n data = response.json()\n assert response.status_code == 200, response.text\n assert type(data) == list\n assert data[0]['user_id'] == user.id\ndef test_get_image_by_user_no_user(client, session, admin_token, user, image, monkeypatch):\n with patch.object(AuthUser, 'redis_client') as redis_mock:\n redis_mock.get.return_value = None\n monkeypatch.setattr('fastapi_limiter.FastAPILimiter.redis', AsyncMock())",
"score": 0.8530929684638977
}
] | python | email == admin['email'])) |
from unittest.mock import MagicMock
import pytest
from fastapi.testclient import TestClient
from sqlalchemy import create_engine, select
from sqlalchemy.orm import sessionmaker
from main import app
from src.database.models import Base, Role, User
from src.database.db import get_db
SQLALCHEMY_DATABASE_URL = 'sqlite:///./test.db'
engine = create_engine(
SQLALCHEMY_DATABASE_URL,
connect_args={'check_same_thread': False}
)
TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
@pytest.fixture(scope='module')
def session():
# Create the database
Base. | metadata.drop_all(bind=engine) |
Base.metadata.create_all(bind=engine)
db = TestingSessionLocal()
try:
yield db
finally:
db.close()
@pytest.fixture(scope='module')
def client(session):
def override_get_db():
try:
yield session
finally:
session.close()
app.dependency_overrides[get_db] = override_get_db
yield TestClient(app)
@pytest.fixture(scope='module')
def admin():
return {
'id': 1,
'username': 'admin',
'email': 'example@example.com',
'password': 'Qwerty@1',
'roles': 'admin',
'status_active': 'true',
}
@pytest.fixture(scope='module')
def user():
return {
'id': 2,
'username': 'user',
'email': 'example2@example.com',
'password': 'Qwerty@1',
'roles': 'user',
'status_active': 'true',
}
@pytest.fixture(scope='module')
def comment():
return {'comment': 'Test comment', 'image_id': '1'}
@pytest.fixture(scope='module')
def image():
return {'description': 'Test image', 'tags': 'test tag'}
@pytest.fixture
def admin_token(client, admin, session, monkeypatch):
mock_send_email = MagicMock()
monkeypatch.setattr('src.routes.auth.send_email', mock_send_email)
client.post('/api/auth/signup', json=admin)
current_user: User = session.query(User).filter_by(email=admin.get('email')).first()
current_user.id = 1
current_user.confirmed = True
current_user.roles = Role.admin
session.commit()
response = client.post(
'/api/auth/login',
data={'username': admin.get('email'), 'password': admin.get('password')},
)
data = response.json()
# return data['access_token']
return {'access_token': data['access_token'], 'refresh_token': data['refresh_token'], 'token_type': 'bearer'}
@pytest.fixture
def user_token(client, user, session, monkeypatch):
mock_send_email = MagicMock()
monkeypatch.setattr('src.routes.auth.send_email', mock_send_email)
client.post('/api/auth/signup', json=user)
current_user: User = session.query(User).filter_by(email=user.get('email')).first()
current_user.id = 2
current_user.confirmed = True
current_user.roles = Role.user
session.commit()
response = client.post(
'/api/auth/login',
data={'username': user.get('email'), 'password': user.get('password')},
)
data = response.json()
# return data['access_token']
return {'access_token': data['access_token'], 'refresh_token': data['refresh_token'], 'token_type': 'bearer'}
@pytest.fixture(scope='function')
def access_token(client, admin, session, mocker) -> str:
mocker.patch('src.routes.auth.send_email') # mocker
client.post('/api/auth/signup', json=admin)
current_user: User = session.scalar(select(User).filter(User.email == admin['email']))
current_user.confirmed = True
session.commit()
response = client.post(
'/api/auth/login',
data={'username': admin.get('email'), 'password': admin.get('password')},
)
return response.json()['access_token']
@pytest.fixture(scope='function')
def access_token_user(client, user, session, mocker) -> str:
mocker.patch('src.routes.auth.send_email') # mocker
client.post('/api/auth/signup', json=user)
current_user: User = session.scalar(select(User).filter(User.email == user['email']))
current_user.confirmed = True
session.commit()
response = client.post(
'/api/auth/login',
data={'username': user.get('email'), 'password': user.get('password')},
)
return response.json()['access_token'] | tests/conftest.py | theneonwhale-frt-photo-share-6659afb | [
{
"filename": "src/database/db.py",
"retrieved_chunk": "from src.conf.messages import MSC500_DATABASE_CONFIG, MSC500_DATABASE_CONNECT\nfrom src.services.asyncdevlogging import async_logging_to_file\nURI = settings.sqlalchemy_database_url\nengine = create_engine(URI, echo=True)\nDBSession = sessionmaker(bind=engine, autoflush=False, autocommit=False)\nBase = declarative_base()\ndef get_db():\n db = DBSession()\n try:\n yield db",
"score": 0.8697056770324707
},
{
"filename": "tests/test_repository_images.py",
"retrieved_chunk": " def setUp(self):\n self.session = MagicMock(spec=Session)\n self.user = {'id': 1, 'roles': 'user'}\n async def test_create_image(self):\n image = ImageModel(name='Test image', description='Test description', tags=['test', 'image'])\n result = await create_image(body=image, user=self.user, db=self.session)\n self.assertTrue(hasattr(result, 'id'))\n self.assertEqual(result.description, image.description)\n self.assertEqual(result.user_id, self.user['id'])\n self.assertEqual(result.tags, image.tags)",
"score": 0.8043818473815918
},
{
"filename": "tests/test_repository_users.py",
"retrieved_chunk": " # \"\"\"Start after all test.\"\"\"\n # ...\n def setUp(self):\n \"\"\"Start before each test.\"\"\"\n self.session = MagicMock(spec=Session)\n # def tearDown(self):\n # \"\"\"Start after each test.\"\"\"\n # ...\n async def test_get_user_by_email_found(self):\n self.session.query().filter().first.return_value = TestUsers.user",
"score": 0.7969229817390442
},
{
"filename": "tests/test_unit_repository_comments.py",
"retrieved_chunk": "import unittest\nfrom unittest.mock import MagicMock\nfrom sqlalchemy.orm import Session\nfrom src.conf import messages\nfrom src.database.models import Comment, Image\nfrom src.schemas.images import CommentModel\nfrom src.repository.comments import (\n add_comment,\n update_comment,\n remove_comment,",
"score": 0.7938390970230103
},
{
"filename": "tests/test_routes_images.py",
"retrieved_chunk": " monkeypatch.setattr('fastapi_limiter.FastAPILimiter.identifier', AsyncMock())\n monkeypatch.setattr('fastapi_limiter.FastAPILimiter.http_callback', AsyncMock())\n mock_public_id = MagicMock()\n monkeypatch.setattr('src.services.images.CloudImage.generate_name_image', mock_public_id)\n mock_r = MagicMock()\n monkeypatch.setattr('src.services.images.CloudImage.image_upload', mock_r)\n mock_src_url = MagicMock()\n mock_src_url.return_value = 'some url'\n monkeypatch.setattr('src.services.images.CloudImage.get_url_for_image', mock_src_url)\n user = session.query(User).filter_by(email=user.get('email')).first()",
"score": 0.7937695384025574
}
] | python | metadata.drop_all(bind=engine) |
from databasez import Database
database = Database("postgresql+asyncpg://localhost/example")
# Establish the connection pool
await database.connect()
# Execute
query = "INSERT INTO users(name, address) VALUES (:name, :address)"
values = {"text": "databasez", "address": "London, United Kingdom"}
await database.execute(query=query, values=values)
# Execute many
query = "INSERT INTO users(name, address) VALUES (:name, :address)"
values = [
{"name": "databasez", "address": "London, United Kingdom"},
{"name": "another name", "address": "The Hague, Netherlands"},
]
await database.execute_many(query=query, values=values)
# Fetch multiple rows
query = "SELECT * FROM users WHERE address = :address"
rows = await database. | fetch_all(query=query, values={"address": "London, United Kingdom"}) |
# Fetch single row
query = "SELECT * FROM users WHERE id = :id"
result = await database.fetch_one(query=query, values={"id": 1})
| docs_src/queries/raw_queries.py | tarsil-databasez-01b23b0 | [
{
"filename": "docs_src/queries/queries.py",
"retrieved_chunk": "values = [\n {\"name\": \"databasez\", \"address\": \"London, United Kingdom\"},\n {\"name\": \"another name\", \"address\": \"The Hague, Netherlands\"},\n]\nawait database.execute_many(query=query, values=values)\n# Fetch multiple rows\nquery = users.select()\nrows = await database.fetch_all(query=query)\n# Fetch single row\nquery = users.select()",
"score": 0.9478416442871094
},
{
"filename": "docs_src/queries/queries.py",
"retrieved_chunk": "from databasez import Database\ndatabase = Database(\"postgresql+asyncpg://localhost/example\")\n# Establish the connection pool\nawait database.connect()\n# Execute\nquery = users.insert()\nvalues = {\"name\": \"databasez\", \"address\": \"London, United Kingdom\"}\nawait database.execute(query=query, values=values)\n# Execute many\nquery = users.insert()",
"score": 0.9201148748397827
},
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " await database.execute(query, values)\n # execute_many()\n query = \"INSERT INTO notes(text, completed) VALUES (:text, :completed)\"\n values = [\n {\"text\": \"example2\", \"completed\": False},\n {\"text\": \"example3\", \"completed\": True},\n ]\n await database.execute_many(query, values)\n # fetch_all()\n query = \"SELECT * FROM notes WHERE completed = :completed\"",
"score": 0.8869153261184692
},
{
"filename": "docs_src/quickstart/quickstart.py",
"retrieved_chunk": " {\"name\": \"Daisy\", \"score\": 92},\n {\"name\": \"Neil\", \"score\": 87},\n {\"name\": \"Carol\", \"score\": 43},\n]\nawait database.execute_many(query=query, values=values)\n# Run a database query.\nquery = \"SELECT * FROM HighScores\"\nrows = await database.fetch_all(query=query)\nprint(\"High Scores:\", rows)",
"score": 0.8865028023719788
},
{
"filename": "docs_src/queries/queries.py",
"retrieved_chunk": "row = await database.fetch_one(query=query)\n# Fetch single value, defaults to `column=0`.\nquery = users.select()\nvalue = await database.fetch_val(query=query)\n# Fetch multiple rows without loading them all into memory at once\nquery = users.select()\nasync for row in database.iterate(query=query):\n ...\n# Close all connections in the connection pool\nawait database.disconnect()",
"score": 0.8822186589241028
}
] | python | fetch_all(query=query, values={"address": "London, United Kingdom"}) |
"""CLI command to initialize somesy configuration file."""
import logging
from pathlib import Path
import tomlkit
from somesy.core.core import get_input_content
from somesy.core.models import SomesyInput
logger = logging.getLogger("somesy")
def init_config(input_path: Path, options: dict) -> None:
"""Initialize somesy configuration file.
Args:
input_path (Path): Path to somesy file (will be created/overwritten).
options (dict): CLI options.
"""
logger.info(f"Updating input file ({input_path}) with CLI configurations...")
content = get_input_content(input_path, no_unwrap=True)
is_somesy = SomesyInput. | is_somesy_file_path(input_path) |
input_file_type = "somesy" if is_somesy else "pyproject"
msg = f"Found input file with {input_file_type} format."
logger.verbose(msg)
logger.debug(f"Input file content: {options}")
if "input_file" in options:
del options["input_file"]
if is_somesy:
content["config"] = options
else:
if "tool" not in content:
content["tool"] = {}
if "somesy" not in content["tool"]:
content["tool"]["somesy"] = {}
content["tool"]["somesy"]["config"] = options
with open(input_path, "w") as f:
tomlkit.dump(content, f)
logger.info(f"Input file ({input_path}) updated.")
logger.debug(f"Input file content: {content}")
| src/somesy/commands/init_config.py | Materials-Data-Science-and-Informatics-somesy-a47ca93 | [
{
"filename": "tests/commands/test_init_config.py",
"retrieved_chunk": " cli_options,\n):\n # load somesy file\n somesy_file = tmp_path / \".somesy.toml\"\n create_somesy_metadata(somesy_file)\n options = dict(cli_options)\n options[\"debug\"] = True\n init_config(somesy_file, options)\n assert \"debug = true\" in somesy_file.read_text()\n # load somesy file with config",
"score": 0.8394782543182373
},
{
"filename": "src/somesy/cli/init.py",
"retrieved_chunk": "@app.command()\n@wrap_exceptions\ndef config():\n \"\"\"Set CLI configs for somesy.\"\"\"\n # check if input file exists, if not, try to find it from default list\n input_file_default = discover_input()\n # prompt for inputs\n input_file = typer.prompt(\"Input file path\", default=input_file_default)\n input_file = Path(input_file)\n options = {",
"score": 0.8263726830482483
},
{
"filename": "tests/commands/test_init_config.py",
"retrieved_chunk": " somesy_file = tmp_path / \".somesy.with_config.toml\"\n create_somesy(somesy_file)\n options = dict(cli_options)\n options[\"show_info\"] = True\n init_config(somesy_file, options)\n assert \"show_info = true\" in somesy_file.read_text()\n # load pyproject file\n pyproject_file = tmp_path / \"pyproject.toml\"\n create_poetry_file(pyproject_file)\n options = dict(cli_options)",
"score": 0.8224481344223022
},
{
"filename": "src/somesy/cli/init.py",
"retrieved_chunk": " options[\"debug\"] = typer.confirm(\"Do you want to show debug logs?\")\n set_log_level(\n SomesyLogLevel.from_flags(\n debug=options[\"debug\"],\n verbose=options[\"verbose\"],\n info=options[\"show_info\"],\n )\n )\n logger.debug(f\"CLI options entered: {options}\")\n init_config(input_file, options)",
"score": 0.814910888671875
},
{
"filename": "src/somesy/cli/util.py",
"retrieved_chunk": " cli_log_level: Optional[SomesyLogLevel] = get_log_level()\n if cli_log_level is not None:\n # update log level flags if cli log level was set\n somesy_conf.update_log_level(cli_log_level)\n somesy_input: SomesyInput = somesy_conf.get_input()\n if cli_log_level is None:\n # no cli log level -> set it according to the loaded configuration\n set_log_level(somesy_input.config.log_level())\n logger.debug(\n f\"Combined config (Defaults + File + CLI):\\n{pretty_repr(somesy_input.config)}\"",
"score": 0.8075594902038574
}
] | python | is_somesy_file_path(input_path) |
"""package.json parser and saver."""
import json
import logging
from collections import OrderedDict
from pathlib import Path
from typing import List, Optional
from rich.pretty import pretty_repr
from somesy.core.models import Person, ProjectMetadata
from somesy.core.writer import ProjectMetadataWriter
from somesy.package_json.models import PackageJsonConfig
logger = logging.getLogger("somesy")
class PackageJSON(ProjectMetadataWriter):
"""package.json parser and saver."""
def __init__(
self,
path: Path,
):
"""package.json parser.
See [somesy.core.writer.ProjectMetadataWriter.__init__][].
"""
mappings = {
"authors": ["author"],
}
super().__init__(path, create_if_not_exists=False, direct_mappings=mappings)
@property
def authors(self):
"""Return the only author of the package.json file as list."""
return [self. | _get_property(self._get_key("authors"))] |
@authors.setter
def authors(self, authors: List[Person]) -> None:
"""Set the authors of the project."""
authors = self._from_person(authors[0])
self._set_property(self._get_key("authors"), authors)
@property
def contributors(self):
"""Return the contributors of the package.json file."""
return self._get_property(self._get_key("contributors"))
@contributors.setter
def contributors(self, contributors: List[Person]) -> None:
"""Set the contributors of the project."""
contributors = [self._from_person(c) for c in contributors]
self._set_property(self._get_key("contributors"), contributors)
def _load(self) -> None:
"""Load package.json file."""
with self.path.open() as f:
self._data = json.load(f, object_pairs_hook=OrderedDict)
def _validate(self) -> None:
"""Validate package.json content using pydantic class."""
config = dict(self._get_property([]))
logger.debug(
f"Validating config using {PackageJsonConfig.__name__}: {pretty_repr(config)}"
)
PackageJsonConfig(**config)
def save(self, path: Optional[Path] = None) -> None:
"""Save the package.json file."""
path = path or self.path
logger.debug(f"Saving package.json to {path}")
with path.open("w") as f:
# package.json indentation is 2 spaces
json.dump(self._data, f, indent=2)
@staticmethod
def _from_person(person: Person):
"""Convert project metadata person object to package.json dict for person format."""
person_dict = {"name": person.full_name}
if person.email:
person_dict["email"] = person.email
if person.orcid:
person_dict["url"] = person.orcid
return person_dict
@staticmethod
def _to_person(person) -> Person:
"""Convert package.json dict or str for person format to project metadata person object."""
if isinstance(person, str):
# parse from package.json format
person = PackageJsonConfig.convert_author(person).dict(exclude_none=True)
names = list(map(lambda s: s.strip(), person["name"].split()))
person_obj = {
"given-names": " ".join(names[:-1]),
"family-names": names[-1],
}
if "email" in person:
person_obj["email"] = person["email"].strip()
if "url" in person:
person_obj["orcid"] = person["url"].strip()
return Person(**person_obj)
def sync(self, metadata: ProjectMetadata) -> None:
"""Sync package.json with project metadata.
Use existing sync function from ProjectMetadataWriter but update repository and contributors.
"""
super().sync(metadata)
self.contributors = self._sync_person_list(self.contributors, metadata.people)
if metadata.repository:
self.repository = {"type": "git", "url": metadata.repository}
| src/somesy/package_json/writer.py | Materials-Data-Science-and-Informatics-somesy-a47ca93 | [
{
"filename": "src/somesy/cff/writer.py",
"retrieved_chunk": " mappings = {\n \"name\": [\"title\"],\n \"description\": [\"abstract\"],\n \"homepage\": [\"url\"],\n \"repository\": [\"repository-code\"],\n \"maintainers\": [\"contact\"],\n }\n super().__init__(\n path, create_if_not_exists=create_if_not_exists, direct_mappings=mappings\n )",
"score": 0.7894161939620972
},
{
"filename": "src/somesy/core/writer.py",
"retrieved_chunk": " self._set_property(self._get_key(\"description\"), description)\n @property\n def authors(self):\n \"\"\"Return the authors of the project.\"\"\"\n return self._get_property(self._get_key(\"authors\"))\n @authors.setter\n def authors(self, authors: List[Person]) -> None:\n \"\"\"Set the authors of the project.\"\"\"\n authors = [self._from_person(c) for c in authors]\n self._set_property(self._get_key(\"authors\"), authors)",
"score": 0.7888090014457703
},
{
"filename": "tests/pyproject/test_setuptools.py",
"retrieved_chunk": " Person(\n **{\n \"email\": \"m.soylu@fz-juelich.de\",\n \"given-names\": \"Mustafa\",\n \"family-names\": \"Soylu\",\n }\n )\n ]\n setuptools.authors = authors\n assert setuptools.authors == [",
"score": 0.7780740261077881
},
{
"filename": "src/somesy/core/writer.py",
"retrieved_chunk": " @property\n def maintainers(self):\n \"\"\"Return the maintainers of the project.\"\"\"\n return self._get_property(self._get_key(\"maintainers\"))\n @maintainers.setter\n def maintainers(self, maintainers: List[Person]) -> None:\n \"\"\"Set the maintainers of the project.\"\"\"\n maintainers = [self._from_person(c) for c in maintainers]\n self._set_property(self._get_key(\"maintainers\"), maintainers)\n @property",
"score": 0.7709158658981323
},
{
"filename": "src/somesy/core/models.py",
"retrieved_chunk": " \"\"\"Return people explicitly marked as authors.\"\"\"\n return [p for p in self.people if p.author]\n def publication_authors(self):\n \"\"\"Return people marked as publication authors.\n This always includes people marked as authors.\n \"\"\"\n return [p for p in self.people if p.publication_author]\n def maintainers(self):\n \"\"\"Return people marked as maintainers.\"\"\"\n return [p for p in self.people if p.maintainer]",
"score": 0.769439697265625
}
] | python | _get_property(self._get_key("authors"))] |
from pathlib import Path
import pytest
from somesy.core.models import Person, SomesyInput
from somesy.pyproject.writer import Poetry, Pyproject, SetupTools
@pytest.fixture
def poetry_path():
return Path("tests/pyproject/data/pyproject.full.toml")
@pytest.fixture
def pyproject_poetry(poetry_path):
return Pyproject(poetry_path)
@pytest.fixture
def setuptools_path():
return Path("tests/pyproject/data/pyproject.setuptools.toml")
@pytest.fixture
def pyproject_setuptools(setuptools_path):
return Pyproject(setuptools_path)
@pytest.fixture
def project_metadata(poetry_path):
return SomesyInput.from_input_file(poetry_path).project
def test_pyproject_init_path(pyproject_poetry, poetry_path):
# test if pyproject object is wrapped with Poetry object
assert pyproject_poetry.path == poetry_path
def test_pyproject_init(tmp_path):
path = tmp_path / "pyproject.toml"
# test if it gives error when pyproject.toml file is not found
with pytest.raises(FileNotFoundError):
Pyproject(path)
def test_init_poetry(pyproject_poetry):
# test if pyproject object is wrapped with Poetry object
assert isinstance(pyproject_poetry.__wrapped__, Poetry)
def test_init_setuptools(pyproject_setuptools):
# test if pyproject object is wrapped with Poetry object
assert isinstance(pyproject_setuptools.__wrapped__, SetupTools)
def test_init_no_tool(tmp_path):
file_path = tmp_path / "pyproject.toml"
file_path.touch()
# check if it raises error when no tool is found in pyproject.toml file
with pytest.raises(ValueError):
Pyproject(file_path)
file_path.unlink()
file_path.touch()
def test_sync(pyproject_poetry, project_metadata):
pyproject_poetry.sync(project_metadata)
assert pyproject_poetry.version == "0.1.0"
@pytest.fixture
def person():
p = {
"given-names": "John",
"family-names": "Doe",
"email": "test@test.test",
}
return Person(**p)
def test_person_to_poetry_string(person):
poetry_string = Poetry._from_person(person)
assert poetry_string == "John Doe <test@test.test>"
def test_person_to_setuptools_dict(person):
setuptools_dict = SetupTools._from_person(person)
assert setuptools_dict == {
"name": "John Doe",
"email": "test@test.test",
}
def test_poetry_from_to_person(person):
p = Poetry._to_person(Poetry._from_person(person))
assert p.full_name == person.full_name
assert p.email == person.email
def test_setuptools_from_to_person(person):
p = SetupTools. | _to_person(SetupTools._from_person(person)) |
assert p.full_name == person.full_name
assert p.email == person.email
| tests/pyproject/test_pyproject_misc.py | Materials-Data-Science-and-Informatics-somesy-a47ca93 | [
{
"filename": "src/somesy/pyproject/writer.py",
"retrieved_chunk": " def _from_person(person: Person):\n \"\"\"Convert project metadata person object to poetry string for person format \"full name <email>.\"\"\"\n return f\"{person.full_name} <{person.email}>\"\n @staticmethod\n def _to_person(person_obj: str) -> Person:\n \"\"\"Parse poetry person string to a Person.\"\"\"\n m = re.match(r\"\\s*([^<]+)<([^>]+)>\", person_obj)\n names, mail = (\n list(map(lambda s: s.strip(), m.group(1).split())),\n m.group(2).strip(),",
"score": 0.8596891164779663
},
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " \"family-names\": \"Doe\",\n \"orcid\": \"https://orcid.org/0123-4567-8910\",\n }\n ret = Person(**p)\n ret.set_key_order(list(p.keys())) # custom order!\n return ret\ndef test_from_to_person(person):\n assert CFF._from_person(person) == person.dict(by_alias=True)\n p = CFF._to_person(CFF._from_person(person))\n assert p.full_name == person.full_name",
"score": 0.8493194580078125
},
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " assert p.email == person.email\n assert p.orcid == person.orcid\ndef test_person_merge(tmp_path, person):\n def to_cff_keys(lst):\n return list(map(lambda s: s.replace(\"_\", \"-\"), lst))\n cff_path = tmp_path / \"CITATION.cff\"\n cff = CFF(cff_path, create_if_not_exists=True)\n pm = ProjectMetadata(\n name=\"My awesome project\",\n description=\"Project description\",",
"score": 0.8369314670562744
},
{
"filename": "src/somesy/pyproject/writer.py",
"retrieved_chunk": " \"\"\"Parse setuptools person string to a Person.\"\"\"\n # NOTE: for our purposes, does not matter what are given or family names,\n # we only compare on full_name anyway.\n names = list(map(lambda s: s.strip(), person_obj[\"name\"].split()))\n return Person(\n **{\n \"given-names\": \" \".join(names[:-1]),\n \"family-names\": names[-1],\n \"email\": person_obj[\"email\"].strip(),\n }",
"score": 0.831494927406311
},
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " person3 = Person(\n **{\n \"given_names\": \"Janice\",\n \"family_names\": \"Doethan\",\n \"email\": \"jane93@gmail.com\",\n \"author\": True,\n \"publication_author\": True,\n }\n )\n # john has a new email address",
"score": 0.8290969729423523
}
] | python | _to_person(SetupTools._from_person(person)) |
from pathlib import Path
import pytest
from somesy.core.core import discover_input
from somesy.core.models import ProjectMetadata, SomesyConfig, SomesyInput
@pytest.fixture
def somesy_metadata_only():
return Path("tests/core/data/.somesy.toml")
@pytest.fixture
def somesy_with_config():
return Path("tests/core/data/.somesy.with_config.toml")
def test_discover_input(tmp_path, monkeypatch: pytest.MonkeyPatch):
# Test 1: input is is given and exists
input_file = Path("tests/core/data/.somesy.toml")
result = discover_input(input_file)
assert result == input_file
# Test 2: input is is given but does not exist
input_file = Path("tests/core/data/.somesy2.toml")
result = discover_input(input_file)
assert result == Path(".somesy.toml")
monkeypatch.chdir(tmp_path)
input_file = Path("tests/core/data/.somesy2.toml")
with pytest.raises(FileNotFoundError):
discover_input(input_file)
def test_with_project_metadata(somesy_metadata_only):
# valid somesy file
metadata = SomesyInput. | from_input_file(somesy_metadata_only).project |
assert isinstance(metadata, ProjectMetadata)
assert metadata.name == "somesy"
assert metadata.version == "0.1.0"
def test_with_extract_cli_config(somesy_with_config, somesy_metadata_only):
# test with config exists
config = SomesyInput.from_input_file(somesy_with_config).config
assert isinstance(config, SomesyConfig)
assert config.debug == True
# test with config does not exist
config = SomesyInput.from_input_file(somesy_metadata_only).config
assert config is None
def test_somesy_input(somesy_metadata_only):
metadata = SomesyInput.from_input_file(somesy_metadata_only).project
assert isinstance(metadata, ProjectMetadata)
assert metadata.name == "somesy"
assert metadata.version == "0.1.0"
def test_somesy_input2(somesy_with_config, somesy_metadata_only):
# test with config exists
config = SomesyInput.from_input_file(somesy_with_config).config
assert isinstance(config, SomesyConfig)
assert config.debug == True
# test with config does not exist
config = SomesyInput.from_input_file(somesy_metadata_only).config
assert config is None
| tests/core/test_core_core.py | Materials-Data-Science-and-Informatics-somesy-a47ca93 | [
{
"filename": "tests/conftest.py",
"retrieved_chunk": " # create pyproject file beforehand\n with open(\"tests/pyproject/data/pyproject.setuptools.toml\", \"r\") as f:\n pyproject_content = f.read()\n with open(pyproject_file, \"w+\") as f2:\n f2.write(pyproject_content)\n yield _create_setuptools_file\n@pytest.fixture\ndef create_somesy_metadata():\n def _create_somesy_metadata(somesy_file: Path):\n # create somesy file beforehand",
"score": 0.8433544635772705
},
{
"filename": "tests/commands/test_sync.py",
"retrieved_chunk": " # Call the sync function\n sync(\n somesy_input,\n )\n # Check that the pyproject.toml file was synced\n pyproject = Pyproject(pyproject_file)\n assert pyproject.name == \"test-project\"\n assert pyproject.version == \"0.1.0\"\n assert pyproject.description == \"A test project\"\n assert pyproject.authors == [\"Alice Joe <a@a.aa>\"]",
"score": 0.8411208987236023
},
{
"filename": "tests/commands/test_sync.py",
"retrieved_chunk": " license=\"MIT\",\n )\n conf = SomesyConfig(\n pyproject_file=pyproject_file,\n cff_file=cff_file,\n no_sync_package_json=False,\n package_json_file=package_json_file,\n no_sync_codemeta=True,\n )\n somesy_input = SomesyInput(config=conf, project=metadata)",
"score": 0.8407384157180786
},
{
"filename": "src/somesy/cli/sync.py",
"retrieved_chunk": " dir_okay=False,\n writable=True,\n readable=True,\n resolve_path=True,\n help=\"Custom codemeta.json file path\",\n ),\n):\n \"\"\"Sync project metadata input with metadata files.\"\"\"\n somesy_input = resolved_somesy_input(\n input_file=input_file,",
"score": 0.8389480113983154
},
{
"filename": "tests/conftest.py",
"retrieved_chunk": " with open(\"tests/core/data/.somesy.toml\", \"r\") as f:\n content = f.read()\n with open(somesy_file, \"w+\") as f2:\n f2.write(content)\n yield _create_somesy_metadata\n@pytest.fixture\ndef create_somesy():\n def _create_somesy(somesy_file: Path):\n # create somesy file beforehand\n with open(\"tests/data/somesy.toml\", \"r\") as f:",
"score": 0.8381879925727844
}
] | python | from_input_file(somesy_metadata_only).project |
from urllib.parse import quote
import pytest
from databasez import DatabaseURL
def test_database_url_repr():
u = DatabaseURL("postgresql://localhost/name")
assert repr(u) == "DatabaseURL('postgresql://localhost/name')"
u = DatabaseURL("postgresql://username@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username@localhost/name')"
u = DatabaseURL("postgresql://username:password@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username:********@localhost/name')"
u = DatabaseURL(f"postgresql://username:{quote('[password')}@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username:********@localhost/name')"
def test_database_url_properties():
u = DatabaseURL("postgresql+asyncpg://username:password@localhost:123/mydatabase")
assert u.dialect == "postgresql"
assert u. | driver == "asyncpg" |
assert u.username == "username"
assert u.password == "password"
assert u.hostname == "localhost"
assert u.port == 123
assert u.database == "mydatabase"
u = DatabaseURL(
"postgresql://username:password@/mydatabase?host=/var/run/postgresql/.s.PGSQL.5432"
)
assert u.dialect == "postgresql"
assert u.username == "username"
assert u.password == "password"
assert u.hostname == "/var/run/postgresql/.s.PGSQL.5432"
assert u.database == "mydatabase"
u = DatabaseURL(
"postgresql://username:password@/mydatabase?unix_sock=/var/run/postgresql/.s.PGSQL.5432"
)
assert u.hostname == "/var/run/postgresql/.s.PGSQL.5432"
def test_database_url_escape():
u = DatabaseURL(f"postgresql://username:{quote('[password')}@localhost/mydatabase")
assert u.username == "username"
assert u.password == "[password"
assert u.userinfo == f"username:{quote('[password')}".encode("utf-8")
u2 = DatabaseURL(u)
assert u2.password == "[password"
u3 = DatabaseURL(str(u))
assert u3.password == "[password"
def test_database_url_constructor():
with pytest.raises(TypeError):
DatabaseURL(("postgresql", "username", "password", "localhost", "mydatabase"))
u = DatabaseURL("postgresql+asyncpg://username:password@localhost:123/mydatabase")
assert DatabaseURL(u) == u
def test_database_url_options():
u = DatabaseURL("postgresql://localhost/mydatabase?pool_size=20&ssl=true")
assert u.options == {"pool_size": "20", "ssl": "true"}
u = DatabaseURL("mysql+asyncmy://username/testsuite?unix_socket=/tmp/mysqld/mysqld.sock")
assert u.options == {"unix_socket": "/tmp/mysqld/mysqld.sock"}
def test_replace_database_url_components():
u = DatabaseURL("postgresql://localhost/mydatabase")
assert u.database == "mydatabase"
new = u.replace(database="test_" + u.database)
assert new.database == "test_mydatabase"
assert str(new) == "postgresql://localhost/test_mydatabase"
assert u.driver == ""
new = u.replace(driver="asyncpg")
assert new.driver == "asyncpg"
assert str(new) == "postgresql+asyncpg://localhost/mydatabase"
assert u.port is None
new = u.replace(port=123)
assert new.port == 123
assert str(new) == "postgresql://localhost:123/mydatabase"
assert u.username is None
assert u.userinfo is None
u = DatabaseURL("sqlite:///mydatabase")
assert u.database == "mydatabase"
new = u.replace(database="test_" + u.database)
assert new.database == "test_mydatabase"
assert str(new) == "sqlite:///test_mydatabase"
u = DatabaseURL("sqlite:////absolute/path")
assert u.database == "/absolute/path"
new = u.replace(database=u.database + "_test")
assert new.database == "/absolute/path_test"
assert str(new) == "sqlite:////absolute/path_test"
| tests/test_database_url.py | tarsil-databasez-01b23b0 | [
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " data = {\"config\": database_url}\n async with Database(**data) as database:\n assert isinstance(database.url, DatabaseURL)\n if isinstance(database_url, str):\n assert database.url == database_url\n@pytest.mark.parametrize(\"database_url\", DATABASE_URLS)\n@async_adapter\nasync def test_concurrent_access_on_single_connection(database_url):\n database_url = DatabaseURL(database_url)\n if database_url.dialect != \"postgresql\":",
"score": 0.8424937725067139
},
{
"filename": "databasez/core.py",
"retrieved_chunk": " await self._connection.__aexit__()\n self._transaction = None\nclass _EmptyNetloc(str):\n def __bool__(self) -> bool:\n return True\nclass DatabaseURL:\n def __init__(self, url: typing.Union[str, \"DatabaseURL\"]):\n if isinstance(url, DatabaseURL):\n self._url: str = url._url\n elif isinstance(url, str):",
"score": 0.8359137773513794
},
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " data = {\"config\": database_url}\n database = Database(**data)\n assert not database.is_connected\n await database.connect()\n assert database.is_connected\n await database.disconnect()\n assert not database.is_connected\n # connect and disconnect idempotence\n await database.connect()\n await database.connect()",
"score": 0.8332949876785278
},
{
"filename": "tests/test_integration.py",
"retrieved_chunk": " \"postgresql+asyncpg\",\n ]:\n url = str(database_url.replace(driver=None))\n elif database_url.scheme in [\n \"mssql\",\n \"mssql+pyodbc\",\n \"mssql+aioodbc\",\n \"mssql+pymssql\",\n ]:\n url = str(database_url.replace(driver=\"pyodbc\"))",
"score": 0.8299258947372437
},
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " database_url = database_url[0]\n if isinstance(database_url, str):\n data = {\"url\": database_url}\n else:\n data = {\"config\": database_url}\n async with Database(**data) as database:\n async with database.connection() as connection_1:\n async with database.connection() as connection_2:\n assert connection_1 is connection_2\n async with Database(**data) as database:",
"score": 0.8296514749526978
}
] | python | driver == "asyncpg" |
from pathlib import Path
import pytest
from somesy.core.log import SomesyLogLevel, set_log_level
from somesy.core.models import SomesyInput
from somesy.package_json.writer import PackageJSON
@pytest.fixture(scope="session", autouse=True)
def init_somesy_logger():
set_log_level(SomesyLogLevel.DEBUG)
@pytest.fixture
def create_poetry_file():
def _create_poetry_file(pyproject_file: Path):
# create pyproject file beforehand
with open("tests/pyproject/data/pyproject.full.toml", "r") as f:
pyproject_content = f.read()
with open(pyproject_file, "w+") as f2:
f2.write(pyproject_content)
yield _create_poetry_file
@pytest.fixture
def create_setuptools_file():
def _create_setuptools_file(pyproject_file: Path):
# create pyproject file beforehand
with open("tests/pyproject/data/pyproject.setuptools.toml", "r") as f:
pyproject_content = f.read()
with open(pyproject_file, "w+") as f2:
f2.write(pyproject_content)
yield _create_setuptools_file
@pytest.fixture
def create_somesy_metadata():
def _create_somesy_metadata(somesy_file: Path):
# create somesy file beforehand
with open("tests/core/data/.somesy.toml", "r") as f:
content = f.read()
with open(somesy_file, "w+") as f2:
f2.write(content)
yield _create_somesy_metadata
@pytest.fixture
def create_somesy():
def _create_somesy(somesy_file: Path):
# create somesy file beforehand
with open("tests/data/somesy.toml", "r") as f:
content = f.read()
with open(somesy_file, "w+") as f2:
f2.write(content)
yield _create_somesy
@pytest.fixture
def create_package_json():
def _create_package_json(package_json_file: Path):
# create somesy file beforehand
with open("tests/data/package.json", "r") as f:
content = f.read()
with open(package_json_file, "w+") as f2:
f2.write(content)
yield _create_package_json
@pytest.fixture
def create_cff_file():
def _create_cff_file(cff_file: Path):
# create somesy file beforehand
with open("tests/cff/data/CITATION.cff", "r") as f:
content = f.read()
with open(cff_file, "w+") as f2:
f2.write(content)
yield _create_cff_file
@pytest.fixture
def somesy() -> dict:
return SomesyInput. | from_input_file(Path("tests/data/somesy.toml")) |
@pytest.fixture
def package_json() -> PackageJSON:
return PackageJSON(Path("tests/data/package.json"))
| tests/conftest.py | Materials-Data-Science-and-Informatics-somesy-a47ca93 | [
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": "from pathlib import Path\nimport pytest\nfrom somesy.cff.writer import CFF\nfrom somesy.core.models import LicenseEnum, Person, ProjectMetadata, SomesyInput\ndef test_load(tmp_path):\n not_exist_path = Path(\"reject/CITATION.cff\")\n with pytest.raises(FileNotFoundError):\n CFF(not_exist_path, create_if_not_exists=False)\n file_path = tmp_path / \"CITATION.cff\"\n CFF(file_path, create_if_not_exists=True)",
"score": 0.8513234853744507
},
{
"filename": "tests/test_codemeta.py",
"retrieved_chunk": " cff = CFF(cff_path)\n cff.save()\n assert cff_path.is_file()\n # first time, no file -> codemeta.json is created\n conf = SomesyConfig(codemeta_file=file_path, cff_file=cff_path)\n assert update_codemeta(conf)\n # second time, no changes -> codemeta.json is not overwritten\n assert not update_codemeta(conf)\n cff.description = \"Changed description\"\n cff.save()",
"score": 0.8448008894920349
},
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " cff.save()\n assert file_path.is_file()\n # test save with custom path\n custom_path = tmp_path / \"custom.cff\"\n cff.save(custom_path)\n@pytest.fixture\ndef person():\n p = {\n \"given-names\": \"Jane\",\n \"email\": \"j.doe@example.com\",",
"score": 0.841144859790802
},
{
"filename": "tests/commands/test_sync.py",
"retrieved_chunk": " license=\"MIT\",\n )\n conf = SomesyConfig(\n pyproject_file=pyproject_file,\n cff_file=cff_file,\n no_sync_package_json=False,\n package_json_file=package_json_file,\n no_sync_codemeta=True,\n )\n somesy_input = SomesyInput(config=conf, project=metadata)",
"score": 0.8397043347358704
},
{
"filename": "tests/core/test_core_core.py",
"retrieved_chunk": "from pathlib import Path\nimport pytest\nfrom somesy.core.core import discover_input\nfrom somesy.core.models import ProjectMetadata, SomesyConfig, SomesyInput\n@pytest.fixture\ndef somesy_metadata_only():\n return Path(\"tests/core/data/.somesy.toml\")\n@pytest.fixture\ndef somesy_with_config():\n return Path(\"tests/core/data/.somesy.with_config.toml\")",
"score": 0.8330113887786865
}
] | python | from_input_file(Path("tests/data/somesy.toml")) |
"""package.json parser and saver."""
import json
import logging
from collections import OrderedDict
from pathlib import Path
from typing import List, Optional
from rich.pretty import pretty_repr
from somesy.core.models import Person, ProjectMetadata
from somesy.core.writer import ProjectMetadataWriter
from somesy.package_json.models import PackageJsonConfig
logger = logging.getLogger("somesy")
class PackageJSON(ProjectMetadataWriter):
"""package.json parser and saver."""
def __init__(
self,
path: Path,
):
"""package.json parser.
See [somesy.core.writer.ProjectMetadataWriter.__init__][].
"""
mappings = {
"authors": ["author"],
}
super().__init__(path, create_if_not_exists=False, direct_mappings=mappings)
@property
def authors(self):
"""Return the only author of the package.json file as list."""
return [self._get_property(self. | _get_key("authors"))] |
@authors.setter
def authors(self, authors: List[Person]) -> None:
"""Set the authors of the project."""
authors = self._from_person(authors[0])
self._set_property(self._get_key("authors"), authors)
@property
def contributors(self):
"""Return the contributors of the package.json file."""
return self._get_property(self._get_key("contributors"))
@contributors.setter
def contributors(self, contributors: List[Person]) -> None:
"""Set the contributors of the project."""
contributors = [self._from_person(c) for c in contributors]
self._set_property(self._get_key("contributors"), contributors)
def _load(self) -> None:
"""Load package.json file."""
with self.path.open() as f:
self._data = json.load(f, object_pairs_hook=OrderedDict)
def _validate(self) -> None:
"""Validate package.json content using pydantic class."""
config = dict(self._get_property([]))
logger.debug(
f"Validating config using {PackageJsonConfig.__name__}: {pretty_repr(config)}"
)
PackageJsonConfig(**config)
def save(self, path: Optional[Path] = None) -> None:
"""Save the package.json file."""
path = path or self.path
logger.debug(f"Saving package.json to {path}")
with path.open("w") as f:
# package.json indentation is 2 spaces
json.dump(self._data, f, indent=2)
@staticmethod
def _from_person(person: Person):
"""Convert project metadata person object to package.json dict for person format."""
person_dict = {"name": person.full_name}
if person.email:
person_dict["email"] = person.email
if person.orcid:
person_dict["url"] = person.orcid
return person_dict
@staticmethod
def _to_person(person) -> Person:
"""Convert package.json dict or str for person format to project metadata person object."""
if isinstance(person, str):
# parse from package.json format
person = PackageJsonConfig.convert_author(person).dict(exclude_none=True)
names = list(map(lambda s: s.strip(), person["name"].split()))
person_obj = {
"given-names": " ".join(names[:-1]),
"family-names": names[-1],
}
if "email" in person:
person_obj["email"] = person["email"].strip()
if "url" in person:
person_obj["orcid"] = person["url"].strip()
return Person(**person_obj)
def sync(self, metadata: ProjectMetadata) -> None:
"""Sync package.json with project metadata.
Use existing sync function from ProjectMetadataWriter but update repository and contributors.
"""
super().sync(metadata)
self.contributors = self._sync_person_list(self.contributors, metadata.people)
if metadata.repository:
self.repository = {"type": "git", "url": metadata.repository}
| src/somesy/package_json/writer.py | Materials-Data-Science-and-Informatics-somesy-a47ca93 | [
{
"filename": "src/somesy/cff/writer.py",
"retrieved_chunk": " mappings = {\n \"name\": [\"title\"],\n \"description\": [\"abstract\"],\n \"homepage\": [\"url\"],\n \"repository\": [\"repository-code\"],\n \"maintainers\": [\"contact\"],\n }\n super().__init__(\n path, create_if_not_exists=create_if_not_exists, direct_mappings=mappings\n )",
"score": 0.7896274924278259
},
{
"filename": "src/somesy/core/writer.py",
"retrieved_chunk": " self._set_property(self._get_key(\"description\"), description)\n @property\n def authors(self):\n \"\"\"Return the authors of the project.\"\"\"\n return self._get_property(self._get_key(\"authors\"))\n @authors.setter\n def authors(self, authors: List[Person]) -> None:\n \"\"\"Set the authors of the project.\"\"\"\n authors = [self._from_person(c) for c in authors]\n self._set_property(self._get_key(\"authors\"), authors)",
"score": 0.7879958152770996
},
{
"filename": "tests/pyproject/test_setuptools.py",
"retrieved_chunk": " Person(\n **{\n \"email\": \"m.soylu@fz-juelich.de\",\n \"given-names\": \"Mustafa\",\n \"family-names\": \"Soylu\",\n }\n )\n ]\n setuptools.authors = authors\n assert setuptools.authors == [",
"score": 0.7773231267929077
},
{
"filename": "src/somesy/core/writer.py",
"retrieved_chunk": " @property\n def maintainers(self):\n \"\"\"Return the maintainers of the project.\"\"\"\n return self._get_property(self._get_key(\"maintainers\"))\n @maintainers.setter\n def maintainers(self, maintainers: List[Person]) -> None:\n \"\"\"Set the maintainers of the project.\"\"\"\n maintainers = [self._from_person(c) for c in maintainers]\n self._set_property(self._get_key(\"maintainers\"), maintainers)\n @property",
"score": 0.7708451151847839
},
{
"filename": "src/somesy/core/models.py",
"retrieved_chunk": " \"\"\"Return people explicitly marked as authors.\"\"\"\n return [p for p in self.people if p.author]\n def publication_authors(self):\n \"\"\"Return people marked as publication authors.\n This always includes people marked as authors.\n \"\"\"\n return [p for p in self.people if p.publication_author]\n def maintainers(self):\n \"\"\"Return people marked as maintainers.\"\"\"\n return [p for p in self.people if p.maintainer]",
"score": 0.7667655944824219
}
] | python | _get_key("authors"))] |
"""package.json parser and saver."""
import json
import logging
from collections import OrderedDict
from pathlib import Path
from typing import List, Optional
from rich.pretty import pretty_repr
from somesy.core.models import Person, ProjectMetadata
from somesy.core.writer import ProjectMetadataWriter
from somesy.package_json.models import PackageJsonConfig
logger = logging.getLogger("somesy")
class PackageJSON(ProjectMetadataWriter):
"""package.json parser and saver."""
def __init__(
self,
path: Path,
):
"""package.json parser.
See [somesy.core.writer.ProjectMetadataWriter.__init__][].
"""
mappings = {
"authors": ["author"],
}
super().__init__(path, create_if_not_exists=False, direct_mappings=mappings)
@property
def authors(self):
"""Return the only author of the package.json file as list."""
return [self._get_property(self._get_key("authors"))]
@authors.setter
def authors(self, authors: List[Person]) -> None:
"""Set the authors of the project."""
authors = self._from_person(authors[0])
self._set_property(self._get_key("authors"), authors)
@property
def contributors(self):
"""Return the contributors of the package.json file."""
return self._get_property(self._get_key("contributors"))
@contributors.setter
def contributors(self, contributors: List[Person]) -> None:
"""Set the contributors of the project."""
contributors = [self._from_person(c) for c in contributors]
self._set_property(self._get_key("contributors"), contributors)
def _load(self) -> None:
"""Load package.json file."""
with self.path.open() as f:
self._data = json.load(f, object_pairs_hook=OrderedDict)
def _validate(self) -> None:
"""Validate package.json content using pydantic class."""
config = dict(self._get_property([]))
logger.debug(
f"Validating config using {PackageJsonConfig.__name__}: {pretty_repr(config)}"
)
PackageJsonConfig(**config)
def save(self, path: Optional[Path] = None) -> None:
"""Save the package.json file."""
path = path or self.path
logger.debug(f"Saving package.json to {path}")
with path.open("w") as f:
# package.json indentation is 2 spaces
json.dump(self._data, f, indent=2)
@staticmethod
def _from_person(person: Person):
"""Convert project metadata person object to package.json dict for person format."""
person_dict = {"name": person.full_name}
if person.email:
person_dict["email"] = person.email
if person.orcid:
person_dict["url"] = person.orcid
return person_dict
@staticmethod
def _to_person(person) -> Person:
"""Convert package.json dict or str for person format to project metadata person object."""
if isinstance(person, str):
# parse from package.json format
person = PackageJsonConfig.convert_author(person).dict(exclude_none=True)
names = list(map(lambda s: s.strip(), person["name"].split()))
person_obj = {
"given-names": " ".join(names[:-1]),
"family-names": names[-1],
}
if "email" in person:
person_obj["email"] = person["email"].strip()
if "url" in person:
person_obj["orcid"] = person["url"].strip()
return Person(**person_obj)
def sync(self, metadata: ProjectMetadata) -> None:
"""Sync package.json with project metadata.
Use existing sync function from ProjectMetadataWriter but update repository and contributors.
"""
super().sync(metadata)
self.contributors = self. | _sync_person_list(self.contributors, metadata.people) |
if metadata.repository:
self.repository = {"type": "git", "url": metadata.repository}
| src/somesy/package_json/writer.py | Materials-Data-Science-and-Informatics-somesy-a47ca93 | [
{
"filename": "src/somesy/commands/sync.py",
"retrieved_chunk": "):\n \"\"\"Sync package.json file using project metadata.\n Args:\n metadata (ProjectMetadata): project metadata to sync pyproject.toml file.\n package_json_file (Path, optional): package.json file path if wanted to be synced. Defaults to None.\n \"\"\"\n logger.verbose(\"Loading package.json file.\")\n package_json = PackageJSON(package_json_file)\n logger.verbose(\"Syncing package.json file.\")\n package_json.sync(metadata)",
"score": 0.8367048501968384
},
{
"filename": "src/somesy/core/writer.py",
"retrieved_chunk": " This method is existing for the publication_author special case\n when synchronizing to CITATION.cff.\n \"\"\"\n self.authors = self._sync_person_list(self.authors, metadata.authors())\n def sync(self, metadata: ProjectMetadata) -> None:\n \"\"\"Sync output file with other metadata files.\"\"\"\n self.name = metadata.name\n self.description = metadata.description\n if metadata.version:\n self.version = metadata.version",
"score": 0.8297330737113953
},
{
"filename": "src/somesy/core/writer.py",
"retrieved_chunk": " if metadata.keywords:\n self.keywords = metadata.keywords\n self._sync_authors(metadata)\n self.maintainers = self._sync_person_list(\n self.maintainers, metadata.maintainers()\n )\n self.license = metadata.license.value\n if metadata.homepage:\n self.homepage = str(metadata.homepage)\n if metadata.repository:",
"score": 0.8282499313354492
},
{
"filename": "tests/commands/test_sync.py",
"retrieved_chunk": " metadata = ProjectMetadata(\n name=\"test-project\",\n version=\"0.1.0\",\n description=\"A test project\",\n people=[\n Person(\n given_names=\"Alice\", family_names=\"Joe\", email=\"a@a.aa\", author=True\n ),\n Person(given_names=\"Bob\", family_names=\"Joe\", email=\"b@b.bb\"),\n ],",
"score": 0.8138200044631958
},
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " person1c = person1b.copy(update={\"email\": \"john.of.us@qualityland.com\"})\n # jane 2 is removed from authors, but added to maintainers\n person2.author = False\n person2.publication_author = False\n person2.maintainer = True\n # reflect in project metadata\n pm.people = [person3, person2, person1c]\n # sync to CFF file\n cff.sync(pm)\n cff.save()",
"score": 0.813530445098877
}
] | python | _sync_person_list(self.contributors, metadata.people) |
"""package.json parser and saver."""
import json
import logging
from collections import OrderedDict
from pathlib import Path
from typing import List, Optional
from rich.pretty import pretty_repr
from somesy.core.models import Person, ProjectMetadata
from somesy.core.writer import ProjectMetadataWriter
from somesy.package_json.models import PackageJsonConfig
logger = logging.getLogger("somesy")
class PackageJSON(ProjectMetadataWriter):
"""package.json parser and saver."""
def __init__(
self,
path: Path,
):
"""package.json parser.
See [somesy.core.writer.ProjectMetadataWriter.__init__][].
"""
mappings = {
"authors": ["author"],
}
super().__init__(path, create_if_not_exists=False, direct_mappings=mappings)
@property
def authors(self):
"""Return the only author of the package.json file as list."""
return [self._get_property(self._get_key("authors"))]
@authors.setter
def authors(self, authors: List[Person]) -> None:
"""Set the authors of the project."""
authors = self._from_person(authors[0])
self._set_property(self._get_key("authors"), authors)
@property
def contributors(self):
"""Return the contributors of the package.json file."""
return self._get_property(self._get_key("contributors"))
@contributors.setter
def contributors(self, contributors: List[Person]) -> None:
"""Set the contributors of the project."""
contributors = [self._from_person(c) for c in contributors]
self._set_property(self._get_key("contributors"), contributors)
def _load(self) -> None:
"""Load package.json file."""
with self. | path.open() as f: |
self._data = json.load(f, object_pairs_hook=OrderedDict)
def _validate(self) -> None:
"""Validate package.json content using pydantic class."""
config = dict(self._get_property([]))
logger.debug(
f"Validating config using {PackageJsonConfig.__name__}: {pretty_repr(config)}"
)
PackageJsonConfig(**config)
def save(self, path: Optional[Path] = None) -> None:
"""Save the package.json file."""
path = path or self.path
logger.debug(f"Saving package.json to {path}")
with path.open("w") as f:
# package.json indentation is 2 spaces
json.dump(self._data, f, indent=2)
@staticmethod
def _from_person(person: Person):
"""Convert project metadata person object to package.json dict for person format."""
person_dict = {"name": person.full_name}
if person.email:
person_dict["email"] = person.email
if person.orcid:
person_dict["url"] = person.orcid
return person_dict
@staticmethod
def _to_person(person) -> Person:
"""Convert package.json dict or str for person format to project metadata person object."""
if isinstance(person, str):
# parse from package.json format
person = PackageJsonConfig.convert_author(person).dict(exclude_none=True)
names = list(map(lambda s: s.strip(), person["name"].split()))
person_obj = {
"given-names": " ".join(names[:-1]),
"family-names": names[-1],
}
if "email" in person:
person_obj["email"] = person["email"].strip()
if "url" in person:
person_obj["orcid"] = person["url"].strip()
return Person(**person_obj)
def sync(self, metadata: ProjectMetadata) -> None:
"""Sync package.json with project metadata.
Use existing sync function from ProjectMetadataWriter but update repository and contributors.
"""
super().sync(metadata)
self.contributors = self._sync_person_list(self.contributors, metadata.people)
if metadata.repository:
self.repository = {"type": "git", "url": metadata.repository}
| src/somesy/package_json/writer.py | Materials-Data-Science-and-Informatics-somesy-a47ca93 | [
{
"filename": "src/somesy/core/writer.py",
"retrieved_chunk": " @property\n def maintainers(self):\n \"\"\"Return the maintainers of the project.\"\"\"\n return self._get_property(self._get_key(\"maintainers\"))\n @maintainers.setter\n def maintainers(self, maintainers: List[Person]) -> None:\n \"\"\"Set the maintainers of the project.\"\"\"\n maintainers = [self._from_person(c) for c in maintainers]\n self._set_property(self._get_key(\"maintainers\"), maintainers)\n @property",
"score": 0.8130700588226318
},
{
"filename": "src/somesy/core/writer.py",
"retrieved_chunk": " self._set_property(self._get_key(\"description\"), description)\n @property\n def authors(self):\n \"\"\"Return the authors of the project.\"\"\"\n return self._get_property(self._get_key(\"authors\"))\n @authors.setter\n def authors(self, authors: List[Person]) -> None:\n \"\"\"Set the authors of the project.\"\"\"\n authors = [self._from_person(c) for c in authors]\n self._set_property(self._get_key(\"authors\"), authors)",
"score": 0.7961304187774658
},
{
"filename": "tests/pyproject/test_setuptools.py",
"retrieved_chunk": " maintainers = [\n Person(\n **{\n \"email\": \"m.soylu@fz-juelich.de\",\n \"given-names\": \"Mustafa\",\n \"family-names\": \"Soylu\",\n }\n )\n ]\n setuptools.maintainers = maintainers",
"score": 0.7747633457183838
},
{
"filename": "src/somesy/pyproject/writer.py",
"retrieved_chunk": " \"\"\"\n self._model_cls = model_cls\n self._section = section\n super().__init__(\n path, create_if_not_exists=False, direct_mappings=direct_mappings or {}\n )\n def _load(self) -> None:\n \"\"\"Load pyproject.toml file.\"\"\"\n with open(self.path) as f:\n self._data = tomlkit.load(f)",
"score": 0.7664036750793457
},
{
"filename": "tests/commands/test_sync.py",
"retrieved_chunk": " # Check that the package.json file was synced\n package_json = PackageJSON(package_json_file)\n assert package_json.name == \"test-project\"\n assert package_json.version == \"0.1.0\"\n assert package_json.description == \"A test project\"\n assert package_json.authors == [\n OrderedDict([(\"name\", \"Alice Joe\"), (\"email\", \"a@a.aa\")])\n ]\n assert package_json.license == \"MIT\"",
"score": 0.7625523805618286
}
] | python | path.open() as f: |
from urllib.parse import quote
import pytest
from databasez import DatabaseURL
def test_database_url_repr():
u = DatabaseURL("postgresql://localhost/name")
assert repr(u) == "DatabaseURL('postgresql://localhost/name')"
u = DatabaseURL("postgresql://username@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username@localhost/name')"
u = DatabaseURL("postgresql://username:password@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username:********@localhost/name')"
u = DatabaseURL(f"postgresql://username:{quote('[password')}@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username:********@localhost/name')"
def test_database_url_properties():
u = DatabaseURL("postgresql+asyncpg://username:password@localhost:123/mydatabase")
assert u.dialect == "postgresql"
assert u.driver == "asyncpg"
assert u. | username == "username" |
assert u.password == "password"
assert u.hostname == "localhost"
assert u.port == 123
assert u.database == "mydatabase"
u = DatabaseURL(
"postgresql://username:password@/mydatabase?host=/var/run/postgresql/.s.PGSQL.5432"
)
assert u.dialect == "postgresql"
assert u.username == "username"
assert u.password == "password"
assert u.hostname == "/var/run/postgresql/.s.PGSQL.5432"
assert u.database == "mydatabase"
u = DatabaseURL(
"postgresql://username:password@/mydatabase?unix_sock=/var/run/postgresql/.s.PGSQL.5432"
)
assert u.hostname == "/var/run/postgresql/.s.PGSQL.5432"
def test_database_url_escape():
u = DatabaseURL(f"postgresql://username:{quote('[password')}@localhost/mydatabase")
assert u.username == "username"
assert u.password == "[password"
assert u.userinfo == f"username:{quote('[password')}".encode("utf-8")
u2 = DatabaseURL(u)
assert u2.password == "[password"
u3 = DatabaseURL(str(u))
assert u3.password == "[password"
def test_database_url_constructor():
with pytest.raises(TypeError):
DatabaseURL(("postgresql", "username", "password", "localhost", "mydatabase"))
u = DatabaseURL("postgresql+asyncpg://username:password@localhost:123/mydatabase")
assert DatabaseURL(u) == u
def test_database_url_options():
u = DatabaseURL("postgresql://localhost/mydatabase?pool_size=20&ssl=true")
assert u.options == {"pool_size": "20", "ssl": "true"}
u = DatabaseURL("mysql+asyncmy://username/testsuite?unix_socket=/tmp/mysqld/mysqld.sock")
assert u.options == {"unix_socket": "/tmp/mysqld/mysqld.sock"}
def test_replace_database_url_components():
u = DatabaseURL("postgresql://localhost/mydatabase")
assert u.database == "mydatabase"
new = u.replace(database="test_" + u.database)
assert new.database == "test_mydatabase"
assert str(new) == "postgresql://localhost/test_mydatabase"
assert u.driver == ""
new = u.replace(driver="asyncpg")
assert new.driver == "asyncpg"
assert str(new) == "postgresql+asyncpg://localhost/mydatabase"
assert u.port is None
new = u.replace(port=123)
assert new.port == 123
assert str(new) == "postgresql://localhost:123/mydatabase"
assert u.username is None
assert u.userinfo is None
u = DatabaseURL("sqlite:///mydatabase")
assert u.database == "mydatabase"
new = u.replace(database="test_" + u.database)
assert new.database == "test_mydatabase"
assert str(new) == "sqlite:///test_mydatabase"
u = DatabaseURL("sqlite:////absolute/path")
assert u.database == "/absolute/path"
new = u.replace(database=u.database + "_test")
assert new.database == "/absolute/path_test"
assert str(new) == "sqlite:////absolute/path_test"
| tests/test_database_url.py | tarsil-databasez-01b23b0 | [
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " data = {\"config\": database_url}\n async with Database(**data) as database:\n assert isinstance(database.url, DatabaseURL)\n if isinstance(database_url, str):\n assert database.url == database_url\n@pytest.mark.parametrize(\"database_url\", DATABASE_URLS)\n@async_adapter\nasync def test_concurrent_access_on_single_connection(database_url):\n database_url = DatabaseURL(database_url)\n if database_url.dialect != \"postgresql\":",
"score": 0.8588108420372009
},
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " data = {\"config\": database_url}\n database = Database(**data)\n assert not database.is_connected\n await database.connect()\n assert database.is_connected\n await database.disconnect()\n assert not database.is_connected\n # connect and disconnect idempotence\n await database.connect()\n await database.connect()",
"score": 0.8500221967697144
},
{
"filename": "databasez/core.py",
"retrieved_chunk": " await self._connection.__aexit__()\n self._transaction = None\nclass _EmptyNetloc(str):\n def __bool__(self) -> bool:\n return True\nclass DatabaseURL:\n def __init__(self, url: typing.Union[str, \"DatabaseURL\"]):\n if isinstance(url, DatabaseURL):\n self._url: str = url._url\n elif isinstance(url, str):",
"score": 0.8489311337471008
},
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " database_url = database_url[0]\n if isinstance(database_url, str):\n data = {\"url\": database_url}\n else:\n data = {\"config\": database_url}\n async with Database(**data) as database:\n async with database.connection() as connection_1:\n async with database.connection() as connection_2:\n assert connection_1 is connection_2\n async with Database(**data) as database:",
"score": 0.846720278263092
},
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " database_url = database_url[0]\n if isinstance(database_url, str):\n data = {\"url\": database_url}\n else:\n data = {\"config\": database_url}\n async with Database(**data) as database:\n async with database.transaction(force_rollback=True):\n query = \"SELECT 1 AS id, 2 AS id\"\n row = await database.fetch_one(query=query)\n assert list(row._mapping.keys()) == [\"id\", \"id\"]",
"score": 0.8454519510269165
}
] | python | username == "username" |
"""package.json parser and saver."""
import json
import logging
from collections import OrderedDict
from pathlib import Path
from typing import List, Optional
from rich.pretty import pretty_repr
from somesy.core.models import Person, ProjectMetadata
from somesy.core.writer import ProjectMetadataWriter
from somesy.package_json.models import PackageJsonConfig
logger = logging.getLogger("somesy")
class PackageJSON(ProjectMetadataWriter):
"""package.json parser and saver."""
def __init__(
self,
path: Path,
):
"""package.json parser.
See [somesy.core.writer.ProjectMetadataWriter.__init__][].
"""
mappings = {
"authors": ["author"],
}
super().__init__(path, create_if_not_exists=False, direct_mappings=mappings)
@property
def authors(self):
"""Return the only author of the package.json file as list."""
return [self._get_property(self._get_key("authors"))]
@authors.setter
def authors(self, authors: List[Person]) -> None:
"""Set the authors of the project."""
authors = self._from_person(authors[0])
self._set_property(self._get_key("authors"), authors)
@property
def contributors(self):
"""Return the contributors of the package.json file."""
return self._get_property(self._get_key("contributors"))
@contributors.setter
def contributors(self, contributors: List[Person]) -> None:
"""Set the contributors of the project."""
contributors = [self._from_person(c) for c in contributors]
self._set_property(self._get_key("contributors"), contributors)
def _load(self) -> None:
"""Load package.json file."""
with self.path.open() as f:
self._data = json.load(f, object_pairs_hook=OrderedDict)
def _validate(self) -> None:
"""Validate package.json content using pydantic class."""
config = dict(self._get_property([]))
logger.debug(
f"Validating config using {PackageJsonConfig.__name__}: {pretty_repr(config)}"
)
PackageJsonConfig(**config)
def save(self, path: Optional[Path] = None) -> None:
"""Save the package.json file."""
path = path or self.path
logger.debug(f"Saving package.json to {path}")
with path.open("w") as f:
# package.json indentation is 2 spaces
json.dump(self._data, f, indent=2)
@staticmethod
def _from_person(person: Person):
"""Convert project metadata person object to package.json dict for person format."""
person_dict = {"name": person.full_name}
if person.email:
person_dict["email"] = person.email
if person.orcid:
person_dict["url"] = person.orcid
return person_dict
@staticmethod
def _to_person(person) -> Person:
"""Convert package.json dict or str for person format to project metadata person object."""
if isinstance(person, str):
# parse from package.json format
person = PackageJsonConfig. | convert_author(person).dict(exclude_none=True) |
names = list(map(lambda s: s.strip(), person["name"].split()))
person_obj = {
"given-names": " ".join(names[:-1]),
"family-names": names[-1],
}
if "email" in person:
person_obj["email"] = person["email"].strip()
if "url" in person:
person_obj["orcid"] = person["url"].strip()
return Person(**person_obj)
def sync(self, metadata: ProjectMetadata) -> None:
"""Sync package.json with project metadata.
Use existing sync function from ProjectMetadataWriter but update repository and contributors.
"""
super().sync(metadata)
self.contributors = self._sync_person_list(self.contributors, metadata.people)
if metadata.repository:
self.repository = {"type": "git", "url": metadata.repository}
| src/somesy/package_json/writer.py | Materials-Data-Science-and-Informatics-somesy-a47ca93 | [
{
"filename": "src/somesy/cff/writer.py",
"retrieved_chunk": " def _from_person(person: Person):\n \"\"\"Convert project metadata person object to cff dict for person format.\"\"\"\n json_str = person.json(\n exclude={\n \"contribution\",\n \"contribution_types\",\n \"contribution_begin\",\n \"contribution_end\",\n \"author\",\n \"publication_author\",",
"score": 0.8615375757217407
},
{
"filename": "src/somesy/pyproject/writer.py",
"retrieved_chunk": " }\n super().__init__(\n path, section=section, direct_mappings=mappings, model_cls=SetuptoolsConfig\n )\n @staticmethod\n def _from_person(person: Person):\n \"\"\"Convert project metadata person object to setuptools dict for person format.\"\"\"\n return {\"name\": person.full_name, \"email\": person.email}\n @staticmethod\n def _to_person(person_obj) -> Person:",
"score": 0.8494138121604919
},
{
"filename": "src/somesy/core/writer.py",
"retrieved_chunk": " self.repository = str(metadata.repository)\n @staticmethod\n @abstractmethod\n def _from_person(person: Person) -> Any:\n \"\"\"Convert a `Person` object into suitable target format.\"\"\"\n @staticmethod\n @abstractmethod\n def _to_person(person_obj: Any) -> Person:\n \"\"\"Convert an object representing a person into a `Person` object.\"\"\"\n @classmethod",
"score": 0.8342102766036987
},
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " person1b = person.copy(\n update={\"given_names\": \"John\", \"author\": True, \"publication_author\": True}\n )\n # different Jane Doe with different orcid -> new person\n person2 = person.copy(\n update={\n \"orcid\": \"https://orcid.org/4321-0987-3231\",\n \"email\": \"i.am.jane@doe.com\",\n \"author\": True,\n \"publication_author\": True,",
"score": 0.8332634568214417
},
{
"filename": "tests/pyproject/test_pyproject_misc.py",
"retrieved_chunk": " }\n return Person(**p)\ndef test_person_to_poetry_string(person):\n poetry_string = Poetry._from_person(person)\n assert poetry_string == \"John Doe <test@test.test>\"\ndef test_person_to_setuptools_dict(person):\n setuptools_dict = SetupTools._from_person(person)\n assert setuptools_dict == {\n \"name\": \"John Doe\",\n \"email\": \"test@test.test\",",
"score": 0.8241759538650513
}
] | python | convert_author(person).dict(exclude_none=True) |
import json
from pathlib import Path
import pytest
from somesy.core.models import Person, ProjectMetadata, SomesyInput
p1 = {
"given-names": "Jane",
"family-names": "Doe",
"email": "j.doe@example.com",
"orcid": "https://orcid.org/0123-4567-8910",
}
p2 = {"given-names": "Foo", "family-names": "Bar", "email": "f.bar@example.com"}
p3 = {
"given-names": p1["given-names"],
"family-names": p1["family-names"],
"email": p2["email"],
}
p4 = {**p2, "email": p1["email"]}
p5 = {**p2, "orcid": "https://orcid.org/1234-5678-9101"}
p6 = {**p5, "orcid": p1["orcid"]}
def test_same_person():
# same is same (reflexivity)
assert Person(**p1).same_person(Person(**p1))
# missing orcid, different mail, different name -> not same
assert not Person(**p1).same_person(Person(**p2))
# missing orcid, different mail, same name -> same
assert Person(**p1).same_person(Person(**p3))
# missing orcid, same mail -> same
assert Person(**p1).same_person(Person(**p4))
# different orcid -> different
assert not Person(**p1).same_person(Person(**p5))
# same orcid -> same
assert Person(**p1).same_person(Person(**p6))
def test_detect_duplicate_person():
metadata = SomesyInput.from_input_file(Path("tests/core/data/.somesy.toml")).project
meta = metadata.copy()
meta.people.append(p1)
ProjectMetadata(**meta.dict())
# P1 ~= P3
meta.people.append(p3)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
# P1 ~= P4
meta.people.pop()
meta.people.append(p4)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
# P1 ~= P6
meta.people.pop()
meta.people.append(p6)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
# P1 /= P2
meta.people.pop()
meta.people.append(p2)
ProjectMetadata(**meta.dict())
# P1 /= P5
meta.people.pop()
meta.people.append(p5)
ProjectMetadata(**meta.dict())
# P2 ~= P5
meta.people.append(p2)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
def test_custom_key_order():
key_order = ["given-names", "orcid", "family-names", "email"]
p = Person(
**{
"given-names": "Jane",
"email": "mail@example.com",
"family-names": "Doe",
}
)
p.set_key_order(key_order)
# correct subsequence of order
expected_order = ["given_names", "family_names", "email"]
assert list(p.dict(exclude_none=True).keys()) == expected_order
assert list(json.loads(p.json(exclude_none=True)).keys()) == expected_order
# added field appears in right spot
p.orcid = "https://orcid.org/1234-5678-9101"
assert list(p.dict(exclude_none=True).keys()) == p._key_order
assert list(json.loads(p.json(exclude_none=True)).keys()) == p._key_order
# fields not in key order come after all the listed ones
p.affiliation = "Some institution"
expected_order = p._key_order + ["affiliation"]
assert list(p.dict(exclude_none=True).keys()) == expected_order
assert list(json.loads(p.json(exclude_none=True)).keys()) == expected_order
# key order also preserved by copy
assert p. | copy()._key_order == p._key_order | tests/core/test_core_models.py | Materials-Data-Science-and-Informatics-somesy-a47ca93 | [
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " \"family-names\": \"Doe\",\n \"orcid\": \"https://orcid.org/0123-4567-8910\",\n }\n ret = Person(**p)\n ret.set_key_order(list(p.keys())) # custom order!\n return ret\ndef test_from_to_person(person):\n assert CFF._from_person(person) == person.dict(by_alias=True)\n p = CFF._to_person(CFF._from_person(person))\n assert p.full_name == person.full_name",
"score": 0.8131417036056519
},
{
"filename": "src/somesy/core/models.py",
"retrieved_chunk": " def json(self, *args, **kwargs):\n \"\"\"Patched json method (to preserve custom key order).\"\"\"\n self._patch_kwargs_defaults(kwargs)\n by_alias = kwargs.pop(\"by_alias\", False)\n # loop back json through dict to apply custom key order\n dct = json.loads(super().json(*args, **kwargs, by_alias=False))\n ret = self._reorder_dict(dct)\n if by_alias:\n ret = {self.__fields__[k].alias: v for k, v in ret.items()}\n return json.dumps(ret)",
"score": 0.7864891290664673
},
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " assert len(cff.authors) == 2\n assert len(cff.maintainers) == 1\n assert cff.authors[0] == person1c.dict(\n by_alias=True, exclude={\"author\", \"publication_author\"}\n )\n assert cff.authors[1] == person3.dict(\n by_alias=True, exclude={\"author\", \"publication_author\"}\n )\n dct = cff._yaml.load(open(cff_path, \"r\"))\n assert list(dct[\"authors\"][0].keys()) == to_cff_keys(person1c._key_order)",
"score": 0.7827085852622986
},
{
"filename": "tests/pyproject/test_pyproject_misc.py",
"retrieved_chunk": " }\n return Person(**p)\ndef test_person_to_poetry_string(person):\n poetry_string = Poetry._from_person(person)\n assert poetry_string == \"John Doe <test@test.test>\"\ndef test_person_to_setuptools_dict(person):\n setuptools_dict = SetupTools._from_person(person)\n assert setuptools_dict == {\n \"name\": \"John Doe\",\n \"email\": \"test@test.test\",",
"score": 0.782605767250061
},
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " }\n )\n # use different order, just for some difference\n person2.set_key_order([\"given_names\", \"orcid\", \"family_names\", \"email\"])\n # listed in \"arbitrary\" order in somesy metadata (new person comes first)\n pm.people = [person2, person1b] # need to assign like that to keep _key_order\n cff.sync(pm)\n cff.save()\n # existing author order preserved\n assert cff.authors[0] == person1b.dict(",
"score": 0.7817397117614746
}
] | python | copy()._key_order == p._key_order |
|
from pathlib import Path
import pytest
from somesy.core.models import Person, SomesyInput
from somesy.pyproject.writer import Poetry, Pyproject, SetupTools
@pytest.fixture
def poetry_path():
return Path("tests/pyproject/data/pyproject.full.toml")
@pytest.fixture
def pyproject_poetry(poetry_path):
return Pyproject(poetry_path)
@pytest.fixture
def setuptools_path():
return Path("tests/pyproject/data/pyproject.setuptools.toml")
@pytest.fixture
def pyproject_setuptools(setuptools_path):
return Pyproject(setuptools_path)
@pytest.fixture
def project_metadata(poetry_path):
return SomesyInput.from_input_file(poetry_path).project
def test_pyproject_init_path(pyproject_poetry, poetry_path):
# test if pyproject object is wrapped with Poetry object
assert pyproject_poetry.path == poetry_path
def test_pyproject_init(tmp_path):
path = tmp_path / "pyproject.toml"
# test if it gives error when pyproject.toml file is not found
with pytest.raises(FileNotFoundError):
Pyproject(path)
def test_init_poetry(pyproject_poetry):
# test if pyproject object is wrapped with Poetry object
assert isinstance(pyproject_poetry.__wrapped__, Poetry)
def test_init_setuptools(pyproject_setuptools):
# test if pyproject object is wrapped with Poetry object
assert isinstance(pyproject_setuptools.__wrapped__, SetupTools)
def test_init_no_tool(tmp_path):
file_path = tmp_path / "pyproject.toml"
file_path.touch()
# check if it raises error when no tool is found in pyproject.toml file
with pytest.raises(ValueError):
Pyproject(file_path)
file_path.unlink()
file_path.touch()
def test_sync(pyproject_poetry, project_metadata):
pyproject_poetry.sync(project_metadata)
assert pyproject_poetry.version == "0.1.0"
@pytest.fixture
def person():
p = {
"given-names": "John",
"family-names": "Doe",
"email": "test@test.test",
}
return Person(**p)
def test_person_to_poetry_string(person):
poetry_string = Poetry._from_person(person)
assert poetry_string == "John Doe <test@test.test>"
def test_person_to_setuptools_dict(person):
setuptools_dict = SetupTools._from_person(person)
assert setuptools_dict == {
"name": "John Doe",
"email": "test@test.test",
}
def test_poetry_from_to_person(person):
p = Poetry. | _to_person(Poetry._from_person(person)) |
assert p.full_name == person.full_name
assert p.email == person.email
def test_setuptools_from_to_person(person):
p = SetupTools._to_person(SetupTools._from_person(person))
assert p.full_name == person.full_name
assert p.email == person.email
| tests/pyproject/test_pyproject_misc.py | Materials-Data-Science-and-Informatics-somesy-a47ca93 | [
{
"filename": "src/somesy/pyproject/writer.py",
"retrieved_chunk": " \"\"\"Parse setuptools person string to a Person.\"\"\"\n # NOTE: for our purposes, does not matter what are given or family names,\n # we only compare on full_name anyway.\n names = list(map(lambda s: s.strip(), person_obj[\"name\"].split()))\n return Person(\n **{\n \"given-names\": \" \".join(names[:-1]),\n \"family-names\": names[-1],\n \"email\": person_obj[\"email\"].strip(),\n }",
"score": 0.8344043493270874
},
{
"filename": "src/somesy/pyproject/writer.py",
"retrieved_chunk": " def _from_person(person: Person):\n \"\"\"Convert project metadata person object to poetry string for person format \"full name <email>.\"\"\"\n return f\"{person.full_name} <{person.email}>\"\n @staticmethod\n def _to_person(person_obj: str) -> Person:\n \"\"\"Parse poetry person string to a Person.\"\"\"\n m = re.match(r\"\\s*([^<]+)<([^>]+)>\", person_obj)\n names, mail = (\n list(map(lambda s: s.strip(), m.group(1).split())),\n m.group(2).strip(),",
"score": 0.8340359330177307
},
{
"filename": "tests/pyproject/test_poetry.py",
"retrieved_chunk": " assert poetry.description == \"new description\"\ndef test_authors(poetry):\n # check existing authors\n authors = [\n Person(\n **{\n \"email\": \"m.soylu@fz-juelich.de\",\n \"given-names\": \"Mustafa\",\n \"family-names\": \"Soylu\",\n }",
"score": 0.8226310014724731
},
{
"filename": "tests/pyproject/test_poetry.py",
"retrieved_chunk": " ]\n poetry.maintainers = maintainers\n assert set(poetry.maintainers) == set([\"Mustafa Soylu <m.soylu@fz-juelich.de>\"])\n # set maintainers\n new_maintainers = [\n Person(**{\"email\": \"aaa@aaa.aaa\", \"given-names\": \"AA\", \"family-names\": \"BB\"}),\n ]\n poetry.maintainers = new_maintainers\n assert set(poetry.maintainers) == set([\"AA BB <aaa@aaa.aaa>\"])\ndef test_license(poetry):",
"score": 0.8178747892379761
},
{
"filename": "src/somesy/pyproject/writer.py",
"retrieved_chunk": " }\n super().__init__(\n path, section=section, direct_mappings=mappings, model_cls=SetuptoolsConfig\n )\n @staticmethod\n def _from_person(person: Person):\n \"\"\"Convert project metadata person object to setuptools dict for person format.\"\"\"\n return {\"name\": person.full_name, \"email\": person.email}\n @staticmethod\n def _to_person(person_obj) -> Person:",
"score": 0.8176730871200562
}
] | python | _to_person(Poetry._from_person(person)) |
from pathlib import Path
import pytest
from somesy.core.models import Person, SomesyInput
from somesy.pyproject.writer import Poetry, Pyproject, SetupTools
@pytest.fixture
def poetry_path():
return Path("tests/pyproject/data/pyproject.full.toml")
@pytest.fixture
def pyproject_poetry(poetry_path):
return Pyproject(poetry_path)
@pytest.fixture
def setuptools_path():
return Path("tests/pyproject/data/pyproject.setuptools.toml")
@pytest.fixture
def pyproject_setuptools(setuptools_path):
return Pyproject(setuptools_path)
@pytest.fixture
def project_metadata(poetry_path):
return SomesyInput. | from_input_file(poetry_path).project |
def test_pyproject_init_path(pyproject_poetry, poetry_path):
# test if pyproject object is wrapped with Poetry object
assert pyproject_poetry.path == poetry_path
def test_pyproject_init(tmp_path):
path = tmp_path / "pyproject.toml"
# test if it gives error when pyproject.toml file is not found
with pytest.raises(FileNotFoundError):
Pyproject(path)
def test_init_poetry(pyproject_poetry):
# test if pyproject object is wrapped with Poetry object
assert isinstance(pyproject_poetry.__wrapped__, Poetry)
def test_init_setuptools(pyproject_setuptools):
# test if pyproject object is wrapped with Poetry object
assert isinstance(pyproject_setuptools.__wrapped__, SetupTools)
def test_init_no_tool(tmp_path):
file_path = tmp_path / "pyproject.toml"
file_path.touch()
# check if it raises error when no tool is found in pyproject.toml file
with pytest.raises(ValueError):
Pyproject(file_path)
file_path.unlink()
file_path.touch()
def test_sync(pyproject_poetry, project_metadata):
pyproject_poetry.sync(project_metadata)
assert pyproject_poetry.version == "0.1.0"
@pytest.fixture
def person():
p = {
"given-names": "John",
"family-names": "Doe",
"email": "test@test.test",
}
return Person(**p)
def test_person_to_poetry_string(person):
poetry_string = Poetry._from_person(person)
assert poetry_string == "John Doe <test@test.test>"
def test_person_to_setuptools_dict(person):
setuptools_dict = SetupTools._from_person(person)
assert setuptools_dict == {
"name": "John Doe",
"email": "test@test.test",
}
def test_poetry_from_to_person(person):
p = Poetry._to_person(Poetry._from_person(person))
assert p.full_name == person.full_name
assert p.email == person.email
def test_setuptools_from_to_person(person):
p = SetupTools._to_person(SetupTools._from_person(person))
assert p.full_name == person.full_name
assert p.email == person.email
| tests/pyproject/test_pyproject_misc.py | Materials-Data-Science-and-Informatics-somesy-a47ca93 | [
{
"filename": "tests/core/test_core_core.py",
"retrieved_chunk": "from pathlib import Path\nimport pytest\nfrom somesy.core.core import discover_input\nfrom somesy.core.models import ProjectMetadata, SomesyConfig, SomesyInput\n@pytest.fixture\ndef somesy_metadata_only():\n return Path(\"tests/core/data/.somesy.toml\")\n@pytest.fixture\ndef somesy_with_config():\n return Path(\"tests/core/data/.somesy.with_config.toml\")",
"score": 0.887067437171936
},
{
"filename": "tests/conftest.py",
"retrieved_chunk": " def _create_poetry_file(pyproject_file: Path):\n # create pyproject file beforehand\n with open(\"tests/pyproject/data/pyproject.full.toml\", \"r\") as f:\n pyproject_content = f.read()\n with open(pyproject_file, \"w+\") as f2:\n f2.write(pyproject_content)\n yield _create_poetry_file\n@pytest.fixture\ndef create_setuptools_file():\n def _create_setuptools_file(pyproject_file: Path):",
"score": 0.8809258937835693
},
{
"filename": "tests/conftest.py",
"retrieved_chunk": "from pathlib import Path\nimport pytest\nfrom somesy.core.log import SomesyLogLevel, set_log_level\nfrom somesy.core.models import SomesyInput\nfrom somesy.package_json.writer import PackageJSON\n@pytest.fixture(scope=\"session\", autouse=True)\ndef init_somesy_logger():\n set_log_level(SomesyLogLevel.DEBUG)\n@pytest.fixture\ndef create_poetry_file():",
"score": 0.8806293606758118
},
{
"filename": "tests/pyproject/test_setuptools.py",
"retrieved_chunk": "from pathlib import Path\nimport pytest\nfrom pydantic import AnyUrl\nfrom pydantic.tools import parse_obj_as\nfrom somesy.core.models import Person\nfrom somesy.pyproject.writer import SetupTools\n@pytest.fixture\ndef setuptools():\n return SetupTools(Path(\"tests/pyproject/data/pyproject.setuptools.toml\"))\ndef test_init(tmp_path):",
"score": 0.8625584840774536
},
{
"filename": "tests/conftest.py",
"retrieved_chunk": " # create pyproject file beforehand\n with open(\"tests/pyproject/data/pyproject.setuptools.toml\", \"r\") as f:\n pyproject_content = f.read()\n with open(pyproject_file, \"w+\") as f2:\n f2.write(pyproject_content)\n yield _create_setuptools_file\n@pytest.fixture\ndef create_somesy_metadata():\n def _create_somesy_metadata(somesy_file: Path):\n # create somesy file beforehand",
"score": 0.8518964052200317
}
] | python | from_input_file(poetry_path).project |
import json
from pathlib import Path
import pytest
from somesy.core.models import Person, ProjectMetadata, SomesyInput
p1 = {
"given-names": "Jane",
"family-names": "Doe",
"email": "j.doe@example.com",
"orcid": "https://orcid.org/0123-4567-8910",
}
p2 = {"given-names": "Foo", "family-names": "Bar", "email": "f.bar@example.com"}
p3 = {
"given-names": p1["given-names"],
"family-names": p1["family-names"],
"email": p2["email"],
}
p4 = {**p2, "email": p1["email"]}
p5 = {**p2, "orcid": "https://orcid.org/1234-5678-9101"}
p6 = {**p5, "orcid": p1["orcid"]}
def test_same_person():
# same is same (reflexivity)
assert Person(**p1).same_person(Person(**p1))
# missing orcid, different mail, different name -> not same
assert not Person(**p1).same_person(Person(**p2))
# missing orcid, different mail, same name -> same
assert Person(**p1).same_person(Person(**p3))
# missing orcid, same mail -> same
assert Person(**p1).same_person(Person(**p4))
# different orcid -> different
assert not Person(**p1).same_person(Person(**p5))
# same orcid -> same
assert Person(**p1).same_person(Person(**p6))
def test_detect_duplicate_person():
metadata = SomesyInput.from_input_file(Path("tests/core/data/.somesy.toml")).project
meta = metadata.copy()
meta.people.append(p1)
ProjectMetadata(**meta.dict())
# P1 ~= P3
meta.people.append(p3)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
# P1 ~= P4
meta.people.pop()
meta.people.append(p4)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
# P1 ~= P6
meta.people.pop()
meta.people.append(p6)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
# P1 /= P2
meta.people.pop()
meta.people.append(p2)
ProjectMetadata(**meta.dict())
# P1 /= P5
meta.people.pop()
meta.people.append(p5)
ProjectMetadata(**meta.dict())
# P2 ~= P5
meta.people.append(p2)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
def test_custom_key_order():
key_order = ["given-names", "orcid", "family-names", "email"]
p = Person(
**{
"given-names": "Jane",
"email": "mail@example.com",
"family-names": "Doe",
}
)
p.set_key_order(key_order)
# correct subsequence of order
expected_order = ["given_names", "family_names", "email"]
assert list(p. | dict(exclude_none=True).keys()) == expected_order |
assert list(json.loads(p.json(exclude_none=True)).keys()) == expected_order
# added field appears in right spot
p.orcid = "https://orcid.org/1234-5678-9101"
assert list(p.dict(exclude_none=True).keys()) == p._key_order
assert list(json.loads(p.json(exclude_none=True)).keys()) == p._key_order
# fields not in key order come after all the listed ones
p.affiliation = "Some institution"
expected_order = p._key_order + ["affiliation"]
assert list(p.dict(exclude_none=True).keys()) == expected_order
assert list(json.loads(p.json(exclude_none=True)).keys()) == expected_order
# key order also preserved by copy
assert p.copy()._key_order == p._key_order
| tests/core/test_core_models.py | Materials-Data-Science-and-Informatics-somesy-a47ca93 | [
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " \"family-names\": \"Doe\",\n \"orcid\": \"https://orcid.org/0123-4567-8910\",\n }\n ret = Person(**p)\n ret.set_key_order(list(p.keys())) # custom order!\n return ret\ndef test_from_to_person(person):\n assert CFF._from_person(person) == person.dict(by_alias=True)\n p = CFF._to_person(CFF._from_person(person))\n assert p.full_name == person.full_name",
"score": 0.813217043876648
},
{
"filename": "src/somesy/core/models.py",
"retrieved_chunk": " return {k: dct[k] for k in key_order}\n def dict(self, *args, **kwargs):\n \"\"\"Patched dict method (to preserve custom key order).\"\"\"\n self._patch_kwargs_defaults(kwargs)\n by_alias = kwargs.pop(\"by_alias\", False)\n dct = super().dict(*args, **kwargs, by_alias=False)\n ret = self._reorder_dict(dct)\n if by_alias:\n ret = {self.__fields__[k].alias: v for k, v in ret.items()}\n return ret",
"score": 0.7913608551025391
},
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " }\n )\n # use different order, just for some difference\n person2.set_key_order([\"given_names\", \"orcid\", \"family_names\", \"email\"])\n # listed in \"arbitrary\" order in somesy metadata (new person comes first)\n pm.people = [person2, person1b] # need to assign like that to keep _key_order\n cff.sync(pm)\n cff.save()\n # existing author order preserved\n assert cff.authors[0] == person1b.dict(",
"score": 0.7889805436134338
},
{
"filename": "src/somesy/cff/writer.py",
"retrieved_chunk": " ret = Person.make_partial(person_obj)\n ret.set_key_order(list(person_obj.keys()))\n return ret",
"score": 0.7775707244873047
},
{
"filename": "tests/pyproject/test_pyproject_misc.py",
"retrieved_chunk": " }\n return Person(**p)\ndef test_person_to_poetry_string(person):\n poetry_string = Poetry._from_person(person)\n assert poetry_string == \"John Doe <test@test.test>\"\ndef test_person_to_setuptools_dict(person):\n setuptools_dict = SetupTools._from_person(person)\n assert setuptools_dict == {\n \"name\": \"John Doe\",\n \"email\": \"test@test.test\",",
"score": 0.7674640417098999
}
] | python | dict(exclude_none=True).keys()) == expected_order |
import json
from pathlib import Path
import pytest
from somesy.core.models import Person, ProjectMetadata, SomesyInput
p1 = {
"given-names": "Jane",
"family-names": "Doe",
"email": "j.doe@example.com",
"orcid": "https://orcid.org/0123-4567-8910",
}
p2 = {"given-names": "Foo", "family-names": "Bar", "email": "f.bar@example.com"}
p3 = {
"given-names": p1["given-names"],
"family-names": p1["family-names"],
"email": p2["email"],
}
p4 = {**p2, "email": p1["email"]}
p5 = {**p2, "orcid": "https://orcid.org/1234-5678-9101"}
p6 = {**p5, "orcid": p1["orcid"]}
def test_same_person():
# same is same (reflexivity)
assert Person(**p1).same_person(Person(**p1))
# missing orcid, different mail, different name -> not same
assert not Person(**p1).same_person(Person(**p2))
# missing orcid, different mail, same name -> same
assert Person(**p1).same_person(Person(**p3))
# missing orcid, same mail -> same
assert Person(**p1).same_person(Person(**p4))
# different orcid -> different
assert not Person(**p1).same_person(Person(**p5))
# same orcid -> same
assert Person(**p1).same_person(Person(**p6))
def test_detect_duplicate_person():
metadata = SomesyInput. | from_input_file(Path("tests/core/data/.somesy.toml")).project |
meta = metadata.copy()
meta.people.append(p1)
ProjectMetadata(**meta.dict())
# P1 ~= P3
meta.people.append(p3)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
# P1 ~= P4
meta.people.pop()
meta.people.append(p4)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
# P1 ~= P6
meta.people.pop()
meta.people.append(p6)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
# P1 /= P2
meta.people.pop()
meta.people.append(p2)
ProjectMetadata(**meta.dict())
# P1 /= P5
meta.people.pop()
meta.people.append(p5)
ProjectMetadata(**meta.dict())
# P2 ~= P5
meta.people.append(p2)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
def test_custom_key_order():
key_order = ["given-names", "orcid", "family-names", "email"]
p = Person(
**{
"given-names": "Jane",
"email": "mail@example.com",
"family-names": "Doe",
}
)
p.set_key_order(key_order)
# correct subsequence of order
expected_order = ["given_names", "family_names", "email"]
assert list(p.dict(exclude_none=True).keys()) == expected_order
assert list(json.loads(p.json(exclude_none=True)).keys()) == expected_order
# added field appears in right spot
p.orcid = "https://orcid.org/1234-5678-9101"
assert list(p.dict(exclude_none=True).keys()) == p._key_order
assert list(json.loads(p.json(exclude_none=True)).keys()) == p._key_order
# fields not in key order come after all the listed ones
p.affiliation = "Some institution"
expected_order = p._key_order + ["affiliation"]
assert list(p.dict(exclude_none=True).keys()) == expected_order
assert list(json.loads(p.json(exclude_none=True)).keys()) == expected_order
# key order also preserved by copy
assert p.copy()._key_order == p._key_order
| tests/core/test_core_models.py | Materials-Data-Science-and-Informatics-somesy-a47ca93 | [
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " assert p.email == person.email\n assert p.orcid == person.orcid\ndef test_person_merge(tmp_path, person):\n def to_cff_keys(lst):\n return list(map(lambda s: s.replace(\"_\", \"-\"), lst))\n cff_path = tmp_path / \"CITATION.cff\"\n cff = CFF(cff_path, create_if_not_exists=True)\n pm = ProjectMetadata(\n name=\"My awesome project\",\n description=\"Project description\",",
"score": 0.8416157364845276
},
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " \"given-names\": \"AA\",\n \"email\": \"test@test.teset\",\n \"orcid\": \"https://orcid.org/0000-0001-2345-6789\",\n }\n return Person(**people)\n@pytest.fixture\ndef project_metadata():\n return SomesyInput.from_input_file(\n Path(\"tests/cff/data/pyproject.base.toml\")\n ).project",
"score": 0.8325879573822021
},
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " \"family-names\": \"Doe\",\n \"orcid\": \"https://orcid.org/0123-4567-8910\",\n }\n ret = Person(**p)\n ret.set_key_order(list(p.keys())) # custom order!\n return ret\ndef test_from_to_person(person):\n assert CFF._from_person(person) == person.dict(by_alias=True)\n p = CFF._to_person(CFF._from_person(person))\n assert p.full_name == person.full_name",
"score": 0.8156572580337524
},
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " person1c = person1b.copy(update={\"email\": \"john.of.us@qualityland.com\"})\n # jane 2 is removed from authors, but added to maintainers\n person2.author = False\n person2.publication_author = False\n person2.maintainer = True\n # reflect in project metadata\n pm.people = [person3, person2, person1c]\n # sync to CFF file\n cff.sync(pm)\n cff.save()",
"score": 0.8092823624610901
},
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " }\n )\n # use different order, just for some difference\n person2.set_key_order([\"given_names\", \"orcid\", \"family_names\", \"email\"])\n # listed in \"arbitrary\" order in somesy metadata (new person comes first)\n pm.people = [person2, person1b] # need to assign like that to keep _key_order\n cff.sync(pm)\n cff.save()\n # existing author order preserved\n assert cff.authors[0] == person1b.dict(",
"score": 0.8017905354499817
}
] | python | from_input_file(Path("tests/core/data/.somesy.toml")).project |
"""Utility functions for CLI commands."""
import logging
import traceback
from typing import Optional
import typer
import wrapt
from rich.pretty import pretty_repr
from somesy.core.core import discover_input
from somesy.core.log import SomesyLogLevel, get_log_level, set_log_level
from somesy.core.models import SomesyConfig, SomesyInput
logger = logging.getLogger("somesy")
@wrapt.decorator
def wrap_exceptions(wrapped, instance, args, kwargs):
"""Format and log exceptions for cli commands."""
try:
return wrapped(*args, **kwargs)
except Exception as e:
logger.error(f"[bold red]Error: {e}[/bold red]")
logger.debug(f"[red]{traceback.format_exc()}[/red]")
raise typer.Exit(code=1) from e
def resolved_somesy_input(**cli_args) -> SomesyInput:
"""Return a combined `SomesyInput` based on config file and passed CLI args.
Will also adjust log levels accordingly.
"""
# figure out what input file to use
input_file = discover_input(cli_args.pop("input_file", None))
# create config based on passed arguments
passed_args = {k: v for k, v in cli_args.items() if v is not None}
somesy_conf = SomesyConfig(input_file=input_file, **passed_args)
# cli_log_level is None if the user did not pass a log level (-> "default")
cli_log_level: Optional[SomesyLogLevel] = get_log_level()
if cli_log_level is not None:
# update log level flags if cli log level was set
somesy_conf. | update_log_level(cli_log_level) |
somesy_input: SomesyInput = somesy_conf.get_input()
if cli_log_level is None:
# no cli log level -> set it according to the loaded configuration
set_log_level(somesy_input.config.log_level())
logger.debug(
f"Combined config (Defaults + File + CLI):\n{pretty_repr(somesy_input.config)}"
)
return somesy_input
| src/somesy/cli/util.py | Materials-Data-Science-and-Informatics-somesy-a47ca93 | [
{
"filename": "src/somesy/cli/init.py",
"retrieved_chunk": " options[\"debug\"] = typer.confirm(\"Do you want to show debug logs?\")\n set_log_level(\n SomesyLogLevel.from_flags(\n debug=options[\"debug\"],\n verbose=options[\"verbose\"],\n info=options[\"show_info\"],\n )\n )\n logger.debug(f\"CLI options entered: {options}\")\n init_config(input_file, options)",
"score": 0.8807998299598694
},
{
"filename": "tests/commands/test_init_config.py",
"retrieved_chunk": " cli_options,\n):\n # load somesy file\n somesy_file = tmp_path / \".somesy.toml\"\n create_somesy_metadata(somesy_file)\n options = dict(cli_options)\n options[\"debug\"] = True\n init_config(somesy_file, options)\n assert \"debug = true\" in somesy_file.read_text()\n # load somesy file with config",
"score": 0.869765043258667
},
{
"filename": "src/somesy/commands/init_config.py",
"retrieved_chunk": " input_path (Path): Path to somesy file (will be created/overwritten).\n options (dict): CLI options.\n \"\"\"\n logger.info(f\"Updating input file ({input_path}) with CLI configurations...\")\n content = get_input_content(input_path, no_unwrap=True)\n is_somesy = SomesyInput.is_somesy_file_path(input_path)\n input_file_type = \"somesy\" if is_somesy else \"pyproject\"\n msg = f\"Found input file with {input_file_type} format.\"\n logger.verbose(msg)\n logger.debug(f\"Input file content: {options}\")",
"score": 0.8596205711364746
},
{
"filename": "src/somesy/core/models.py",
"retrieved_chunk": " self.debug = log_level == SomesyLogLevel.DEBUG\n def get_input(self) -> SomesyInput:\n \"\"\"Based on the somesy config, load the complete somesy input.\"\"\"\n # get metadata+config from specified input file\n somesy_input = SomesyInput.from_input_file(self.input_file)\n # update input with merged config settings (cli overrides config file)\n dct: Dict[str, Any] = {}\n dct.update(somesy_input.config or {})\n dct.update(self.dict())\n somesy_input.config = SomesyConfig(**dct)",
"score": 0.8545124530792236
},
{
"filename": "src/somesy/cli/init.py",
"retrieved_chunk": "@app.command()\n@wrap_exceptions\ndef config():\n \"\"\"Set CLI configs for somesy.\"\"\"\n # check if input file exists, if not, try to find it from default list\n input_file_default = discover_input()\n # prompt for inputs\n input_file = typer.prompt(\"Input file path\", default=input_file_default)\n input_file = Path(input_file)\n options = {",
"score": 0.8531541228294373
}
] | python | update_log_level(cli_log_level) |
import json
from pathlib import Path
import pytest
from somesy.core.models import Person, ProjectMetadata, SomesyInput
p1 = {
"given-names": "Jane",
"family-names": "Doe",
"email": "j.doe@example.com",
"orcid": "https://orcid.org/0123-4567-8910",
}
p2 = {"given-names": "Foo", "family-names": "Bar", "email": "f.bar@example.com"}
p3 = {
"given-names": p1["given-names"],
"family-names": p1["family-names"],
"email": p2["email"],
}
p4 = {**p2, "email": p1["email"]}
p5 = {**p2, "orcid": "https://orcid.org/1234-5678-9101"}
p6 = {**p5, "orcid": p1["orcid"]}
def test_same_person():
# same is same (reflexivity)
assert Person(**p1).same_person(Person(**p1))
# missing orcid, different mail, different name -> not same
assert not Person(**p1).same_person(Person(**p2))
# missing orcid, different mail, same name -> same
assert Person(**p1).same_person(Person(**p3))
# missing orcid, same mail -> same
assert Person(**p1).same_person(Person(**p4))
# different orcid -> different
assert not Person(**p1).same_person(Person(**p5))
# same orcid -> same
assert Person(**p1).same_person(Person(**p6))
def test_detect_duplicate_person():
metadata = SomesyInput.from_input_file(Path("tests/core/data/.somesy.toml")).project
meta = metadata.copy()
meta.people.append(p1)
ProjectMetadata(**meta.dict())
# P1 ~= P3
meta.people.append(p3)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
# P1 ~= P4
meta.people.pop()
meta.people.append(p4)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
# P1 ~= P6
meta.people.pop()
meta.people.append(p6)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
# P1 /= P2
meta.people.pop()
meta.people.append(p2)
ProjectMetadata(**meta.dict())
# P1 /= P5
meta.people.pop()
meta.people.append(p5)
ProjectMetadata(**meta.dict())
# P2 ~= P5
meta.people.append(p2)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
def test_custom_key_order():
key_order = ["given-names", "orcid", "family-names", "email"]
p = Person(
**{
"given-names": "Jane",
"email": "mail@example.com",
"family-names": "Doe",
}
)
p. | set_key_order(key_order) |
# correct subsequence of order
expected_order = ["given_names", "family_names", "email"]
assert list(p.dict(exclude_none=True).keys()) == expected_order
assert list(json.loads(p.json(exclude_none=True)).keys()) == expected_order
# added field appears in right spot
p.orcid = "https://orcid.org/1234-5678-9101"
assert list(p.dict(exclude_none=True).keys()) == p._key_order
assert list(json.loads(p.json(exclude_none=True)).keys()) == p._key_order
# fields not in key order come after all the listed ones
p.affiliation = "Some institution"
expected_order = p._key_order + ["affiliation"]
assert list(p.dict(exclude_none=True).keys()) == expected_order
assert list(json.loads(p.json(exclude_none=True)).keys()) == expected_order
# key order also preserved by copy
assert p.copy()._key_order == p._key_order
| tests/core/test_core_models.py | Materials-Data-Science-and-Informatics-somesy-a47ca93 | [
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " \"family-names\": \"Doe\",\n \"orcid\": \"https://orcid.org/0123-4567-8910\",\n }\n ret = Person(**p)\n ret.set_key_order(list(p.keys())) # custom order!\n return ret\ndef test_from_to_person(person):\n assert CFF._from_person(person) == person.dict(by_alias=True)\n p = CFF._to_person(CFF._from_person(person))\n assert p.full_name == person.full_name",
"score": 0.8421328067779541
},
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " }\n )\n # use different order, just for some difference\n person2.set_key_order([\"given_names\", \"orcid\", \"family_names\", \"email\"])\n # listed in \"arbitrary\" order in somesy metadata (new person comes first)\n pm.people = [person2, person1b] # need to assign like that to keep _key_order\n cff.sync(pm)\n cff.save()\n # existing author order preserved\n assert cff.authors[0] == person1b.dict(",
"score": 0.8336977958679199
},
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " person3 = Person(\n **{\n \"given_names\": \"Janice\",\n \"family_names\": \"Doethan\",\n \"email\": \"jane93@gmail.com\",\n \"author\": True,\n \"publication_author\": True,\n }\n )\n # john has a new email address",
"score": 0.8186081647872925
},
{
"filename": "src/somesy/cff/writer.py",
"retrieved_chunk": " ret = Person.make_partial(person_obj)\n ret.set_key_order(list(person_obj.keys()))\n return ret",
"score": 0.8111869692802429
},
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " person1b = person.copy(\n update={\"given_names\": \"John\", \"author\": True, \"publication_author\": True}\n )\n # different Jane Doe with different orcid -> new person\n person2 = person.copy(\n update={\n \"orcid\": \"https://orcid.org/4321-0987-3231\",\n \"email\": \"i.am.jane@doe.com\",\n \"author\": True,\n \"publication_author\": True,",
"score": 0.8093976378440857
}
] | python | set_key_order(key_order) |
import json
from pathlib import Path
import pytest
from somesy.core.models import Person, ProjectMetadata, SomesyInput
p1 = {
"given-names": "Jane",
"family-names": "Doe",
"email": "j.doe@example.com",
"orcid": "https://orcid.org/0123-4567-8910",
}
p2 = {"given-names": "Foo", "family-names": "Bar", "email": "f.bar@example.com"}
p3 = {
"given-names": p1["given-names"],
"family-names": p1["family-names"],
"email": p2["email"],
}
p4 = {**p2, "email": p1["email"]}
p5 = {**p2, "orcid": "https://orcid.org/1234-5678-9101"}
p6 = {**p5, "orcid": p1["orcid"]}
def test_same_person():
# same is same (reflexivity)
assert Person(**p1). | same_person(Person(**p1)) |
# missing orcid, different mail, different name -> not same
assert not Person(**p1).same_person(Person(**p2))
# missing orcid, different mail, same name -> same
assert Person(**p1).same_person(Person(**p3))
# missing orcid, same mail -> same
assert Person(**p1).same_person(Person(**p4))
# different orcid -> different
assert not Person(**p1).same_person(Person(**p5))
# same orcid -> same
assert Person(**p1).same_person(Person(**p6))
def test_detect_duplicate_person():
metadata = SomesyInput.from_input_file(Path("tests/core/data/.somesy.toml")).project
meta = metadata.copy()
meta.people.append(p1)
ProjectMetadata(**meta.dict())
# P1 ~= P3
meta.people.append(p3)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
# P1 ~= P4
meta.people.pop()
meta.people.append(p4)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
# P1 ~= P6
meta.people.pop()
meta.people.append(p6)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
# P1 /= P2
meta.people.pop()
meta.people.append(p2)
ProjectMetadata(**meta.dict())
# P1 /= P5
meta.people.pop()
meta.people.append(p5)
ProjectMetadata(**meta.dict())
# P2 ~= P5
meta.people.append(p2)
with pytest.raises(ValueError):
ProjectMetadata(**meta.dict())
def test_custom_key_order():
key_order = ["given-names", "orcid", "family-names", "email"]
p = Person(
**{
"given-names": "Jane",
"email": "mail@example.com",
"family-names": "Doe",
}
)
p.set_key_order(key_order)
# correct subsequence of order
expected_order = ["given_names", "family_names", "email"]
assert list(p.dict(exclude_none=True).keys()) == expected_order
assert list(json.loads(p.json(exclude_none=True)).keys()) == expected_order
# added field appears in right spot
p.orcid = "https://orcid.org/1234-5678-9101"
assert list(p.dict(exclude_none=True).keys()) == p._key_order
assert list(json.loads(p.json(exclude_none=True)).keys()) == p._key_order
# fields not in key order come after all the listed ones
p.affiliation = "Some institution"
expected_order = p._key_order + ["affiliation"]
assert list(p.dict(exclude_none=True).keys()) == expected_order
assert list(json.loads(p.json(exclude_none=True)).keys()) == expected_order
# key order also preserved by copy
assert p.copy()._key_order == p._key_order
| tests/core/test_core_models.py | Materials-Data-Science-and-Informatics-somesy-a47ca93 | [
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " \"family-names\": \"Doe\",\n \"orcid\": \"https://orcid.org/0123-4567-8910\",\n }\n ret = Person(**p)\n ret.set_key_order(list(p.keys())) # custom order!\n return ret\ndef test_from_to_person(person):\n assert CFF._from_person(person) == person.dict(by_alias=True)\n p = CFF._to_person(CFF._from_person(person))\n assert p.full_name == person.full_name",
"score": 0.8650326728820801
},
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " person1b = person.copy(\n update={\"given_names\": \"John\", \"author\": True, \"publication_author\": True}\n )\n # different Jane Doe with different orcid -> new person\n person2 = person.copy(\n update={\n \"orcid\": \"https://orcid.org/4321-0987-3231\",\n \"email\": \"i.am.jane@doe.com\",\n \"author\": True,\n \"publication_author\": True,",
"score": 0.8270793557167053
},
{
"filename": "tests/pyproject/test_pyproject_misc.py",
"retrieved_chunk": " }\n return Person(**p)\ndef test_person_to_poetry_string(person):\n poetry_string = Poetry._from_person(person)\n assert poetry_string == \"John Doe <test@test.test>\"\ndef test_person_to_setuptools_dict(person):\n setuptools_dict = SetupTools._from_person(person)\n assert setuptools_dict == {\n \"name\": \"John Doe\",\n \"email\": \"test@test.test\",",
"score": 0.8259456157684326
},
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " assert p.email == person.email\n assert p.orcid == person.orcid\ndef test_person_merge(tmp_path, person):\n def to_cff_keys(lst):\n return list(map(lambda s: s.replace(\"_\", \"-\"), lst))\n cff_path = tmp_path / \"CITATION.cff\"\n cff = CFF(cff_path, create_if_not_exists=True)\n pm = ProjectMetadata(\n name=\"My awesome project\",\n description=\"Project description\",",
"score": 0.8241246938705444
},
{
"filename": "tests/cff/test_cff_writer.py",
"retrieved_chunk": " }\n )\n # use different order, just for some difference\n person2.set_key_order([\"given_names\", \"orcid\", \"family_names\", \"email\"])\n # listed in \"arbitrary\" order in somesy metadata (new person comes first)\n pm.people = [person2, person1b] # need to assign like that to keep _key_order\n cff.sync(pm)\n cff.save()\n # existing author order preserved\n assert cff.authors[0] == person1b.dict(",
"score": 0.822884202003479
}
] | python | same_person(Person(**p1)) |
# coding=utf-8
# Copyright 2023 Junbong Jang.
#
# 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.
'''
Implement contour flow model takes features along the contour
Estimates the optical flow along the contour
'''
import collections
import tensorflow as tf
from tensorflow.keras import Model
from tensorflow.keras.layers import Concatenate
from tensorflow.keras.layers import Conv2D
from tensorflow.keras.layers import Conv2DTranspose
from tensorflow.keras.layers import LeakyReLU
from tensorflow.keras.models import Sequential
from src import uflow_utils
def normalize_features(feature_list, normalize, center, moments_across_channels,
moments_across_images):
"""Normalizes feature tensors (e.g., before computing the cost volume).
Args:
feature_list: list of tf.tensors, each with dimensions [b, h, w, c]
normalize: bool flag, divide features by their standard deviation
center: bool flag, subtract feature mean
moments_across_channels: bool flag, compute mean and std across channels
moments_across_images: bool flag, compute mean and std across images
Returns:
list, normalized feature_list
"""
# Compute feature statistics.
statistics = collections.defaultdict(list)
axes = [-3, -2, -1] if moments_across_channels else [-3, -2]
for feature_image in feature_list:
mean, variance = tf.nn.moments(x=feature_image, axes=axes, keepdims=True)
statistics['mean'].append(mean)
statistics['var'].append(variance)
if moments_across_images:
statistics['mean'] = ([tf.reduce_mean(input_tensor=statistics['mean'])] *
len(feature_list))
statistics['var'] = [tf.reduce_mean(input_tensor=statistics['var'])
] * len(feature_list)
statistics['std'] = [tf.sqrt(v + 1e-16) for v in statistics['var']]
# Center and normalize features.
if center:
feature_list = [
f - mean for f, mean in zip(feature_list, statistics['mean'])
]
if normalize:
feature_list = [f / std for f, std in zip(feature_list, statistics['std'])]
return feature_list
def compute_cost_volume(features1, features2, max_displacement):
"""Compute the cost volume between features1 and features2.
Displace features2 up to max_displacement in any direction and compute the
per pixel cost of features1 and the displaced features2.
Args:
features1: tf.tensor of shape [b, h, w, c] which means batch, height, width, channels
features2: tf.tensor of shape [b, h, w, c]
max_displacement: int, maximum displacement for cost volume computation.
Returns:
tf.tensor of shape [b, h, w, (2 * max_displacement + 1) ** 2] of costs for
all displacements.
"""
# Set maximum displacement and compute the number of image shifts.
_, height, width, _ = features1.shape.as_list()
if max_displacement <= 0 or max_displacement >= height: # why not check width also?
raise ValueError(f'Max displacement of {max_displacement} is too large.')
max_disp = max_displacement
num_shifts = 2 * max_disp + 1
# Pad features2 such that shifts do not go out of bounds.
features2_padded = tf.pad(
tensor=features2,
paddings=[[0, 0], [max_disp, max_disp], [max_disp, max_disp], [0, 0]],
mode='CONSTANT')
# Shift features2 while keeping features1 fixed to compute the cost volume (correlation).
cost_list = []
for i in range(num_shifts):
for j in range(num_shifts):
corr = tf.reduce_mean(
input_tensor=features1 *
features2_padded[:, i:(height + i), j:(width + j), :],
axis=-1,
keepdims=True)
cost_list.append(corr)
cost_volume = tf.concat(cost_list, axis=-1)
return cost_volume
class ContourFlowModel(Model):
"""Model for estimating flow based on the feature pyramids of two images."""
def __init__(self,
leaky_relu_alpha=0.1,
dropout_rate=0.25,
num_channels_upsampled_context=32,
num_levels=5,
normalize_before_cost_volume=True,
channel_multiplier=1.,
use_cost_volume=True,
use_feature_warp=True,
accumulate_flow=True,
use_bfloat16=False,
shared_flow_decoder=False):
super(ContourFlowModel, self).__init__()
self._use_bfloat16 = use_bfloat16
if use_bfloat16:
self._dtype_policy = tf.keras.mixed_precision.experimental.Policy(
'mixed_bfloat16')
else:
self._dtype_policy = tf.keras.mixed_precision.experimental.Policy(
'float32')
self._leaky_relu_alpha = leaky_relu_alpha
self._drop_out_rate = dropout_rate
self._num_context_up_channels = num_channels_upsampled_context
self._num_levels = num_levels
self._normalize_before_cost_volume = normalize_before_cost_volume
self._channel_multiplier = channel_multiplier
self._use_cost_volume = use_cost_volume
self._use_feature_warp = use_feature_warp
self._accumulate_flow = accumulate_flow
self._shared_flow_decoder = shared_flow_decoder
self._refine_model = self._build_refinement_model()
# print('self._refine_model', self._refine_model.summary())
self._flow_layers = self._build_flow_layers()
# print('self._flow_layers', self._flow_layers.summary())
if not self._use_cost_volume:
self._cost_volume_surrogate_convs = self._build_cost_volume_surrogate_convs(
)
if num_channels_upsampled_context:
self._context_up_layers = self._build_upsample_layers(
num_channels=int(num_channels_upsampled_context * channel_multiplier))
if self._shared_flow_decoder:
# pylint:disable=invalid-name
self._1x1_shared_decoder = self._build_1x1_shared_decoder()
def call(self, feature_pyramid1, feature_pyramid2, segmentation1, segmentation2, training=False):
"""Run the model."""
context = None
flow = None
flow_up = None
context_up = None
flows = []
# Go top down through the levels to the second to last one to estimate flow.
for level, (features1, features2) in reversed(
list(enumerate(zip(feature_pyramid1, feature_pyramid2)))[1:]):
batch_size, height, width, _ = features1.shape.as_list()
# ----------------------------------------------------------
# Feature attention to contour region only
# import pdb; pdb.set_trace()
# if training:
# # resize
# segmentation1 = tf.image.resize(-1*segmentation1+1, [height, width])
# segmentation2 = tf.image.resize(-1*segmentation2+1, [height, width])
#
# # sample features at segmentation portion only
# features1 = tf.math.multiply(features1, segmentation1)
# features2 = tf.math.multiply(features2, segmentation2)
# -------------------------------------------------------
# init flows with zeros for coarsest level if needed
if self._shared_flow_decoder and flow_up is None:
flow_up = tf.zeros(
[batch_size, height, width, 2],
dtype=tf.bfloat16 if self._use_bfloat16 else tf.float32)
if self._num_context_up_channels:
num_channels = int(self._num_context_up_channels *
self._channel_multiplier)
context_up = tf.zeros(
[batch_size, height, width, num_channels],
dtype=tf.bfloat16 if self._use_bfloat16 else tf.float32)
# --------------- Warp features2 with upsampled flow from higher level.
if flow_up is None or not self._use_feature_warp:
warped2 = features2
else:
warp_up = uflow_utils. | flow_to_warp(flow_up) |
warped2 = uflow_utils.resample(features2, warp_up)
# --------------- Compute cost volume by comparing features1 and warped features2.
features1_normalized, warped2_normalized = normalize_features(
[features1, warped2],
normalize=self._normalize_before_cost_volume,
center=self._normalize_before_cost_volume,
moments_across_channels=True,
moments_across_images=True)
if self._use_cost_volume:
cost_volume = compute_cost_volume(
features1_normalized, warped2_normalized, max_displacement=4)
else:
concat_features = Concatenate(axis=-1)(
[features1_normalized, warped2_normalized])
cost_volume = self._cost_volume_surrogate_convs[level](concat_features)
cost_volume = LeakyReLU(
alpha=self._leaky_relu_alpha, dtype=self._dtype_policy)(
cost_volume)
# ----------------------------------------------
if self._shared_flow_decoder:
# This will ensure to work for arbitrary feature sizes per level.
conv_1x1 = self._1x1_shared_decoder[level]
features1 = conv_1x1(features1)
# ------------------- Compute context and flow from previous flow, cost volume, and features1
if flow_up is None:
x_in = Concatenate(axis=-1)([cost_volume, features1])
else:
if context_up is None:
x_in = Concatenate(axis=-1)([flow_up, cost_volume, features1])
else:
x_in = Concatenate(axis=-1)(
[context_up, flow_up, cost_volume, features1])
# Use dense-net connections to get context
x_out = None
if self._shared_flow_decoder:
# reuse the same flow decoder on all levels
flow_layers = self._flow_layers
else:
flow_layers = self._flow_layers[level]
for layer in flow_layers[:-1]:
x_out = layer(x_in)
x_in = Concatenate(axis=-1)([x_in, x_out])
context = x_out
# ----------------- Compute Flow -----------------------------
flow = flow_layers[-1](context)
if (training and self._drop_out_rate):
maybe_dropout = tf.cast(
tf.math.greater(tf.random.uniform([]), self._drop_out_rate),
tf.bfloat16 if self._use_bfloat16 else tf.float32)
context *= maybe_dropout
flow *= maybe_dropout
if flow_up is not None and self._accumulate_flow:
flow += flow_up
# Upsample flow for the next lower level.
flow_up = uflow_utils.upsample(flow, is_flow=True)
if self._num_context_up_channels:
context_up = self._context_up_layers[level](context)
# Append results to list.
flows.insert(0, flow)
# Refine flow at level 1.
refinement = self._refine_model([context, flow])
if (training and self._drop_out_rate):
refinement *= tf.cast(
tf.math.greater(tf.random.uniform([]), self._drop_out_rate),
tf.bfloat16 if self._use_bfloat16 else tf.float32)
refined_flow = flow + refinement
flows[0] = refined_flow
return [tf.cast(flow, tf.float32) for flow in flows]
def _build_cost_volume_surrogate_convs(self):
layers = []
for _ in range(self._num_levels):
layers.append(
Conv2D(
int(64 * self._channel_multiplier),
kernel_size=(4, 4),
padding='same',
dtype=self._dtype_policy))
return layers
def _build_upsample_layers(self, num_channels):
"""Build layers for upsampling via deconvolution."""
layers = []
for unused_level in range(self._num_levels):
layers.append(
Conv2DTranspose(
num_channels,
kernel_size=(4, 4),
strides=2,
padding='same',
dtype=self._dtype_policy))
return layers
def _build_flow_layers(self):
"""Build layers for flow estimation."""
# Empty list of layers level 0 because flow is only estimated at levels > 0.
result = [[]]
for _ in range(1, self._num_levels):
layers = []
for c in [128, 128, 96, 64, 32]:
layers.append(
Sequential([
Conv2D(
int(c * self._channel_multiplier),
kernel_size=(3, 3),
strides=1,
padding='same',
dtype=self._dtype_policy),
LeakyReLU(
alpha=self._leaky_relu_alpha, dtype=self._dtype_policy)
]))
layers.append(
Conv2D(
2,
kernel_size=(3, 3),
strides=1,
padding='same',
dtype=self._dtype_policy))
if self._shared_flow_decoder:
return layers
result.append(layers)
return result
def _build_refinement_model(self):
"""Build model for flow refinement using dilated convolutions."""
layers = []
layers.append(Concatenate(axis=-1))
for c, d in [(128, 1), (128, 2), (128, 4), (96, 8), (64, 16), (32, 1)]:
layers.append(
Conv2D(
int(c * self._channel_multiplier),
kernel_size=(3, 3),
strides=1,
padding='same',
dilation_rate=d,
dtype=self._dtype_policy))
layers.append(
LeakyReLU(alpha=self._leaky_relu_alpha, dtype=self._dtype_policy))
layers.append(
Conv2D(
2,
kernel_size=(3, 3),
strides=1,
padding='same',
dtype=self._dtype_policy))
return Sequential(layers)
def _build_1x1_shared_decoder(self):
"""Build layers for flow estimation."""
# Empty list of layers level 0 because flow is only estimated at levels > 0.
result = [[]]
for _ in range(1, self._num_levels):
result.append(
Conv2D(
32,
kernel_size=(1, 1),
strides=1,
padding='same',
dtype=self._dtype_policy))
return result
class PWCFeaturePyramid(Model):
"""Model for computing a feature pyramid from an image."""
def __init__(self,
leaky_relu_alpha=0.1,
filters=None,
level1_num_layers=3,
level1_num_filters=16,
level1_num_1x1=0,
original_layer_sizes=False,
num_levels=5,
channel_multiplier=1.,
pyramid_resolution='half',
use_bfloat16=False):
"""Constructor.
Args:
leaky_relu_alpha: Float. Alpha for leaky ReLU.
filters: Tuple of tuples. Used to construct feature pyramid. Each tuple is
of form (num_convs_per_group, num_filters_per_conv).
level1_num_layers: How many layers and filters to use on the first
pyramid. Only relevant if filters is None and original_layer_sizes
is False.
level1_num_filters: int, how many filters to include on pyramid layer 1.
Only relevant if filters is None and original_layer_sizes if False.
level1_num_1x1: How many 1x1 convolutions to use on the first pyramid
level.
original_layer_sizes: bool, if True, use the original PWC net number
of layers and filters.
num_levels: int, How many feature pyramid levels to construct.
channel_multiplier: float, used to scale up or down the amount of
computation by increasing or decreasing the number of channels
by this factor.
pyramid_resolution: str, specifies the resolution of the lowest (closest
to input pyramid resolution)
use_bfloat16: bool, whether or not to run in bfloat16 mode.
"""
super(PWCFeaturePyramid, self).__init__()
self._use_bfloat16 = use_bfloat16
if use_bfloat16:
self._dtype_policy = tf.keras.mixed_precision.experimental.Policy(
'mixed_bfloat16')
else:
self._dtype_policy = tf.keras.mixed_precision.experimental.Policy(
'float32')
self._channel_multiplier = channel_multiplier
if num_levels > 6:
raise NotImplementedError('Max number of pyramid levels is 6')
if filters is None:
if original_layer_sizes:
# Orig - last layer
filters = ((3, 16), (3, 32), (3, 64), (3, 96), (3, 128),
(3, 196))[:num_levels]
else:
filters = ((level1_num_layers, level1_num_filters), (3, 32), (3, 32),
(3, 32), (3, 32), (3, 32))[:num_levels]
assert filters
assert all(len(t) == 2 for t in filters)
assert all(t[0] > 0 for t in filters)
self._leaky_relu_alpha = leaky_relu_alpha
self._convs = []
self._level1_num_1x1 = level1_num_1x1
for level, (num_layers, num_filters) in enumerate(filters):
group = []
for i in range(num_layers):
stride = 1
if i == 0 or (i == 1 and level == 0 and
pyramid_resolution == 'quarter'):
stride = 2
conv = Conv2D(
int(num_filters * self._channel_multiplier),
kernel_size=(3,
3) if level > 0 or i < num_layers - level1_num_1x1 else
(1, 1),
strides=stride,
padding='valid',
dtype=self._dtype_policy)
group.append(conv)
self._convs.append(group)
def call(self, x, split_features_by_sample=False):
if self._use_bfloat16:
x = tf.cast(x, tf.bfloat16)
x = x * 2. - 1. # Rescale input from [0,1] to [-1, 1]
features = []
for level, conv_tuple in enumerate(self._convs):
for i, conv in enumerate(conv_tuple):
if level > 0 or i < len(conv_tuple) - self._level1_num_1x1:
x = tf.pad(
tensor=x,
paddings=[[0, 0], [1, 1], [1, 1], [0, 0]],
mode='CONSTANT')
x = conv(x)
x = LeakyReLU(alpha=self._leaky_relu_alpha, dtype=self._dtype_policy)(x)
features.append(x)
if split_features_by_sample:
# Split the list of features per level (for all samples) into a nested
# list that can be indexed by [sample][level].
n = len(features[0])
features = [[f[i:i + 1] for f in features] for i in range(n)] # pylint: disable=g-complex-comprehension
return features
| src/contour_flow_model.py | JunbongJang-contour-tracking-1219b66 | [
{
"filename": "src/uflow_utils.py",
"retrieved_chunk": " image_1 = batch[:, 1]\n features_0 = feature_model(\n image_0, split_features_by_sample=False, training=training)\n features_1 = feature_model(\n image_1, split_features_by_sample=False, training=training)\n # -------------------------------------------\n # ------------------------------------------\n flow = flow_model(features_0, features_1, training=training)\n flow_level2 = flow[0]\n flow_level1 = upsample(flow_level2, is_flow=True)",
"score": 0.8451908826828003
},
{
"filename": "src/contour_flow_net.py",
"retrieved_chunk": " images,\n [batch_size * seq_len, input_height, input_width, image_channels])\n # noinspection PyCallingNonCallable\n features_flattened = self._feature_model(\n images_flattened, split_features_by_sample=False)\n features = [\n tf.reshape(f, [batch_size, seq_len] + f.shape.as_list()[1:])\n for f in features_flattened\n ]\n features1, features2 = [[f[:, i] for f in features] for i in range(2)]",
"score": 0.8169017434120178
},
{
"filename": "src/data/data_utils.py",
"retrieved_chunk": " output.append(flow_uv)\n # create valid mask\n flow_valid = tf.ones_like(flow_uv[Ellipsis, :1], dtype=tf.float32)\n output.append(flow_valid)\n if include_occlusion:\n occlusion_mask = deserialize(context_parsed['occlusion_mask'], tf.uint8, 1)\n if height is not None and width is not None:\n occlusion_mask = uflow_utils.resize_uint8(\n occlusion_mask, height, width)\n output.append(occlusion_mask)",
"score": 0.8144482970237732
},
{
"filename": "src/uflow_utils.py",
"retrieved_chunk": " coords_floor = tf.floor(coords)\n coords_offset = coords - coords_floor\n coords_floor = tf.cast(coords_floor, 'int32')\n # Define a batch offset for flattened indexes into all pixels.\n batch_range = tf.reshape(tf.range(batch_size), [batch_size, 1, 1])\n idx_batch_offset = tf.tile(\n batch_range, [1, flow_height, flow_width]) * output_height * output_width\n # Flatten everything.\n coords_floor_flattened = tf.reshape(coords_floor, [-1, 2])\n coords_offset_flattened = tf.reshape(coords_offset, [-1, 2])",
"score": 0.8138532638549805
},
{
"filename": "src/uflow_augmentation.py",
"retrieved_chunk": " new_height = tf.cast(\n tf.math.ceil(tf.cast(orig_height, tf.float32) * scale), tf.int32)\n new_width = tf.cast(\n tf.math.ceil(tf.cast(orig_width, tf.float32) * scale), tf.int32)\n # rescale the images (and flow)\n images = uflow_utils.resize(images, new_height, new_width, is_flow=False)\n if flow is not None:\n flow, mask = uflow_utils.resize(\n flow, new_height, new_width, is_flow=True, mask=mask)\n return images, flow, mask",
"score": 0.8136484026908875
}
] | python | flow_to_warp(flow_up) |
# coding=utf-8
# Copyright 2023 Junbong Jang.
#
# 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.
'''
Implement contour flow model takes features along the contour
Estimates the optical flow along the contour
'''
import collections
import tensorflow as tf
from tensorflow.keras import Model
from tensorflow.keras.layers import Concatenate
from tensorflow.keras.layers import Conv2D
from tensorflow.keras.layers import Conv2DTranspose
from tensorflow.keras.layers import LeakyReLU
from tensorflow.keras.models import Sequential
from src import uflow_utils
def normalize_features(feature_list, normalize, center, moments_across_channels,
moments_across_images):
"""Normalizes feature tensors (e.g., before computing the cost volume).
Args:
feature_list: list of tf.tensors, each with dimensions [b, h, w, c]
normalize: bool flag, divide features by their standard deviation
center: bool flag, subtract feature mean
moments_across_channels: bool flag, compute mean and std across channels
moments_across_images: bool flag, compute mean and std across images
Returns:
list, normalized feature_list
"""
# Compute feature statistics.
statistics = collections.defaultdict(list)
axes = [-3, -2, -1] if moments_across_channels else [-3, -2]
for feature_image in feature_list:
mean, variance = tf.nn.moments(x=feature_image, axes=axes, keepdims=True)
statistics['mean'].append(mean)
statistics['var'].append(variance)
if moments_across_images:
statistics['mean'] = ([tf.reduce_mean(input_tensor=statistics['mean'])] *
len(feature_list))
statistics['var'] = [tf.reduce_mean(input_tensor=statistics['var'])
] * len(feature_list)
statistics['std'] = [tf.sqrt(v + 1e-16) for v in statistics['var']]
# Center and normalize features.
if center:
feature_list = [
f - mean for f, mean in zip(feature_list, statistics['mean'])
]
if normalize:
feature_list = [f / std for f, std in zip(feature_list, statistics['std'])]
return feature_list
def compute_cost_volume(features1, features2, max_displacement):
"""Compute the cost volume between features1 and features2.
Displace features2 up to max_displacement in any direction and compute the
per pixel cost of features1 and the displaced features2.
Args:
features1: tf.tensor of shape [b, h, w, c] which means batch, height, width, channels
features2: tf.tensor of shape [b, h, w, c]
max_displacement: int, maximum displacement for cost volume computation.
Returns:
tf.tensor of shape [b, h, w, (2 * max_displacement + 1) ** 2] of costs for
all displacements.
"""
# Set maximum displacement and compute the number of image shifts.
_, height, width, _ = features1.shape.as_list()
if max_displacement <= 0 or max_displacement >= height: # why not check width also?
raise ValueError(f'Max displacement of {max_displacement} is too large.')
max_disp = max_displacement
num_shifts = 2 * max_disp + 1
# Pad features2 such that shifts do not go out of bounds.
features2_padded = tf.pad(
tensor=features2,
paddings=[[0, 0], [max_disp, max_disp], [max_disp, max_disp], [0, 0]],
mode='CONSTANT')
# Shift features2 while keeping features1 fixed to compute the cost volume (correlation).
cost_list = []
for i in range(num_shifts):
for j in range(num_shifts):
corr = tf.reduce_mean(
input_tensor=features1 *
features2_padded[:, i:(height + i), j:(width + j), :],
axis=-1,
keepdims=True)
cost_list.append(corr)
cost_volume = tf.concat(cost_list, axis=-1)
return cost_volume
class ContourFlowModel(Model):
"""Model for estimating flow based on the feature pyramids of two images."""
def __init__(self,
leaky_relu_alpha=0.1,
dropout_rate=0.25,
num_channels_upsampled_context=32,
num_levels=5,
normalize_before_cost_volume=True,
channel_multiplier=1.,
use_cost_volume=True,
use_feature_warp=True,
accumulate_flow=True,
use_bfloat16=False,
shared_flow_decoder=False):
super(ContourFlowModel, self).__init__()
self._use_bfloat16 = use_bfloat16
if use_bfloat16:
self._dtype_policy = tf.keras.mixed_precision.experimental.Policy(
'mixed_bfloat16')
else:
self._dtype_policy = tf.keras.mixed_precision.experimental.Policy(
'float32')
self._leaky_relu_alpha = leaky_relu_alpha
self._drop_out_rate = dropout_rate
self._num_context_up_channels = num_channels_upsampled_context
self._num_levels = num_levels
self._normalize_before_cost_volume = normalize_before_cost_volume
self._channel_multiplier = channel_multiplier
self._use_cost_volume = use_cost_volume
self._use_feature_warp = use_feature_warp
self._accumulate_flow = accumulate_flow
self._shared_flow_decoder = shared_flow_decoder
self._refine_model = self._build_refinement_model()
# print('self._refine_model', self._refine_model.summary())
self._flow_layers = self._build_flow_layers()
# print('self._flow_layers', self._flow_layers.summary())
if not self._use_cost_volume:
self._cost_volume_surrogate_convs = self._build_cost_volume_surrogate_convs(
)
if num_channels_upsampled_context:
self._context_up_layers = self._build_upsample_layers(
num_channels=int(num_channels_upsampled_context * channel_multiplier))
if self._shared_flow_decoder:
# pylint:disable=invalid-name
self._1x1_shared_decoder = self._build_1x1_shared_decoder()
def call(self, feature_pyramid1, feature_pyramid2, segmentation1, segmentation2, training=False):
"""Run the model."""
context = None
flow = None
flow_up = None
context_up = None
flows = []
# Go top down through the levels to the second to last one to estimate flow.
for level, (features1, features2) in reversed(
list(enumerate(zip(feature_pyramid1, feature_pyramid2)))[1:]):
batch_size, height, width, _ = features1.shape.as_list()
# ----------------------------------------------------------
# Feature attention to contour region only
# import pdb; pdb.set_trace()
# if training:
# # resize
# segmentation1 = tf.image.resize(-1*segmentation1+1, [height, width])
# segmentation2 = tf.image.resize(-1*segmentation2+1, [height, width])
#
# # sample features at segmentation portion only
# features1 = tf.math.multiply(features1, segmentation1)
# features2 = tf.math.multiply(features2, segmentation2)
# -------------------------------------------------------
# init flows with zeros for coarsest level if needed
if self._shared_flow_decoder and flow_up is None:
flow_up = tf.zeros(
[batch_size, height, width, 2],
dtype=tf.bfloat16 if self._use_bfloat16 else tf.float32)
if self._num_context_up_channels:
num_channels = int(self._num_context_up_channels *
self._channel_multiplier)
context_up = tf.zeros(
[batch_size, height, width, num_channels],
dtype=tf.bfloat16 if self._use_bfloat16 else tf.float32)
# --------------- Warp features2 with upsampled flow from higher level.
if flow_up is None or not self._use_feature_warp:
warped2 = features2
else:
warp_up = uflow_utils.flow_to_warp(flow_up)
warped2 = uflow_utils.resample(features2, warp_up)
# --------------- Compute cost volume by comparing features1 and warped features2.
features1_normalized, warped2_normalized = normalize_features(
[features1, warped2],
normalize=self._normalize_before_cost_volume,
center=self._normalize_before_cost_volume,
moments_across_channels=True,
moments_across_images=True)
if self._use_cost_volume:
cost_volume = compute_cost_volume(
features1_normalized, warped2_normalized, max_displacement=4)
else:
concat_features = Concatenate(axis=-1)(
[features1_normalized, warped2_normalized])
cost_volume = self._cost_volume_surrogate_convs[level](concat_features)
cost_volume = LeakyReLU(
alpha=self._leaky_relu_alpha, dtype=self._dtype_policy)(
cost_volume)
# ----------------------------------------------
if self._shared_flow_decoder:
# This will ensure to work for arbitrary feature sizes per level.
conv_1x1 = self._1x1_shared_decoder[level]
features1 = conv_1x1(features1)
# ------------------- Compute context and flow from previous flow, cost volume, and features1
if flow_up is None:
x_in = Concatenate(axis=-1)([cost_volume, features1])
else:
if context_up is None:
x_in = Concatenate(axis=-1)([flow_up, cost_volume, features1])
else:
x_in = Concatenate(axis=-1)(
[context_up, flow_up, cost_volume, features1])
# Use dense-net connections to get context
x_out = None
if self._shared_flow_decoder:
# reuse the same flow decoder on all levels
flow_layers = self._flow_layers
else:
flow_layers = self._flow_layers[level]
for layer in flow_layers[:-1]:
x_out = layer(x_in)
x_in = Concatenate(axis=-1)([x_in, x_out])
context = x_out
# ----------------- Compute Flow -----------------------------
flow = flow_layers[-1](context)
if (training and self._drop_out_rate):
maybe_dropout = tf.cast(
tf.math.greater(tf.random.uniform([]), self._drop_out_rate),
tf.bfloat16 if self._use_bfloat16 else tf.float32)
context *= maybe_dropout
flow *= maybe_dropout
if flow_up is not None and self._accumulate_flow:
flow += flow_up
# Upsample flow for the next lower level.
flow_up = uflow_utils. | upsample(flow, is_flow=True) |
if self._num_context_up_channels:
context_up = self._context_up_layers[level](context)
# Append results to list.
flows.insert(0, flow)
# Refine flow at level 1.
refinement = self._refine_model([context, flow])
if (training and self._drop_out_rate):
refinement *= tf.cast(
tf.math.greater(tf.random.uniform([]), self._drop_out_rate),
tf.bfloat16 if self._use_bfloat16 else tf.float32)
refined_flow = flow + refinement
flows[0] = refined_flow
return [tf.cast(flow, tf.float32) for flow in flows]
def _build_cost_volume_surrogate_convs(self):
layers = []
for _ in range(self._num_levels):
layers.append(
Conv2D(
int(64 * self._channel_multiplier),
kernel_size=(4, 4),
padding='same',
dtype=self._dtype_policy))
return layers
def _build_upsample_layers(self, num_channels):
"""Build layers for upsampling via deconvolution."""
layers = []
for unused_level in range(self._num_levels):
layers.append(
Conv2DTranspose(
num_channels,
kernel_size=(4, 4),
strides=2,
padding='same',
dtype=self._dtype_policy))
return layers
def _build_flow_layers(self):
"""Build layers for flow estimation."""
# Empty list of layers level 0 because flow is only estimated at levels > 0.
result = [[]]
for _ in range(1, self._num_levels):
layers = []
for c in [128, 128, 96, 64, 32]:
layers.append(
Sequential([
Conv2D(
int(c * self._channel_multiplier),
kernel_size=(3, 3),
strides=1,
padding='same',
dtype=self._dtype_policy),
LeakyReLU(
alpha=self._leaky_relu_alpha, dtype=self._dtype_policy)
]))
layers.append(
Conv2D(
2,
kernel_size=(3, 3),
strides=1,
padding='same',
dtype=self._dtype_policy))
if self._shared_flow_decoder:
return layers
result.append(layers)
return result
def _build_refinement_model(self):
"""Build model for flow refinement using dilated convolutions."""
layers = []
layers.append(Concatenate(axis=-1))
for c, d in [(128, 1), (128, 2), (128, 4), (96, 8), (64, 16), (32, 1)]:
layers.append(
Conv2D(
int(c * self._channel_multiplier),
kernel_size=(3, 3),
strides=1,
padding='same',
dilation_rate=d,
dtype=self._dtype_policy))
layers.append(
LeakyReLU(alpha=self._leaky_relu_alpha, dtype=self._dtype_policy))
layers.append(
Conv2D(
2,
kernel_size=(3, 3),
strides=1,
padding='same',
dtype=self._dtype_policy))
return Sequential(layers)
def _build_1x1_shared_decoder(self):
"""Build layers for flow estimation."""
# Empty list of layers level 0 because flow is only estimated at levels > 0.
result = [[]]
for _ in range(1, self._num_levels):
result.append(
Conv2D(
32,
kernel_size=(1, 1),
strides=1,
padding='same',
dtype=self._dtype_policy))
return result
class PWCFeaturePyramid(Model):
"""Model for computing a feature pyramid from an image."""
def __init__(self,
leaky_relu_alpha=0.1,
filters=None,
level1_num_layers=3,
level1_num_filters=16,
level1_num_1x1=0,
original_layer_sizes=False,
num_levels=5,
channel_multiplier=1.,
pyramid_resolution='half',
use_bfloat16=False):
"""Constructor.
Args:
leaky_relu_alpha: Float. Alpha for leaky ReLU.
filters: Tuple of tuples. Used to construct feature pyramid. Each tuple is
of form (num_convs_per_group, num_filters_per_conv).
level1_num_layers: How many layers and filters to use on the first
pyramid. Only relevant if filters is None and original_layer_sizes
is False.
level1_num_filters: int, how many filters to include on pyramid layer 1.
Only relevant if filters is None and original_layer_sizes if False.
level1_num_1x1: How many 1x1 convolutions to use on the first pyramid
level.
original_layer_sizes: bool, if True, use the original PWC net number
of layers and filters.
num_levels: int, How many feature pyramid levels to construct.
channel_multiplier: float, used to scale up or down the amount of
computation by increasing or decreasing the number of channels
by this factor.
pyramid_resolution: str, specifies the resolution of the lowest (closest
to input pyramid resolution)
use_bfloat16: bool, whether or not to run in bfloat16 mode.
"""
super(PWCFeaturePyramid, self).__init__()
self._use_bfloat16 = use_bfloat16
if use_bfloat16:
self._dtype_policy = tf.keras.mixed_precision.experimental.Policy(
'mixed_bfloat16')
else:
self._dtype_policy = tf.keras.mixed_precision.experimental.Policy(
'float32')
self._channel_multiplier = channel_multiplier
if num_levels > 6:
raise NotImplementedError('Max number of pyramid levels is 6')
if filters is None:
if original_layer_sizes:
# Orig - last layer
filters = ((3, 16), (3, 32), (3, 64), (3, 96), (3, 128),
(3, 196))[:num_levels]
else:
filters = ((level1_num_layers, level1_num_filters), (3, 32), (3, 32),
(3, 32), (3, 32), (3, 32))[:num_levels]
assert filters
assert all(len(t) == 2 for t in filters)
assert all(t[0] > 0 for t in filters)
self._leaky_relu_alpha = leaky_relu_alpha
self._convs = []
self._level1_num_1x1 = level1_num_1x1
for level, (num_layers, num_filters) in enumerate(filters):
group = []
for i in range(num_layers):
stride = 1
if i == 0 or (i == 1 and level == 0 and
pyramid_resolution == 'quarter'):
stride = 2
conv = Conv2D(
int(num_filters * self._channel_multiplier),
kernel_size=(3,
3) if level > 0 or i < num_layers - level1_num_1x1 else
(1, 1),
strides=stride,
padding='valid',
dtype=self._dtype_policy)
group.append(conv)
self._convs.append(group)
def call(self, x, split_features_by_sample=False):
if self._use_bfloat16:
x = tf.cast(x, tf.bfloat16)
x = x * 2. - 1. # Rescale input from [0,1] to [-1, 1]
features = []
for level, conv_tuple in enumerate(self._convs):
for i, conv in enumerate(conv_tuple):
if level > 0 or i < len(conv_tuple) - self._level1_num_1x1:
x = tf.pad(
tensor=x,
paddings=[[0, 0], [1, 1], [1, 1], [0, 0]],
mode='CONSTANT')
x = conv(x)
x = LeakyReLU(alpha=self._leaky_relu_alpha, dtype=self._dtype_policy)(x)
features.append(x)
if split_features_by_sample:
# Split the list of features per level (for all samples) into a nested
# list that can be indexed by [sample][level].
n = len(features[0])
features = [[f[i:i + 1] for f in features] for i in range(n)] # pylint: disable=g-complex-comprehension
return features
| src/contour_flow_model.py | JunbongJang-contour-tracking-1219b66 | [
{
"filename": "src/data/data_utils.py",
"retrieved_chunk": " output.append(flow_uv)\n # create valid mask\n flow_valid = tf.ones_like(flow_uv[Ellipsis, :1], dtype=tf.float32)\n output.append(flow_valid)\n if include_occlusion:\n occlusion_mask = deserialize(context_parsed['occlusion_mask'], tf.uint8, 1)\n if height is not None and width is not None:\n occlusion_mask = uflow_utils.resize_uint8(\n occlusion_mask, height, width)\n output.append(occlusion_mask)",
"score": 0.8428130149841309
},
{
"filename": "src/uflow_utils.py",
"retrieved_chunk": " # will get lower counts that pixels in the middle of the image, by padding\n # the flow field.\n if reduce_downsampling_bias:\n p = downsampling_factor // 2\n flow_height += 2 * p\n flow_width += 2 * p\n # Apply padding in multiple steps to padd with the values on the edge.\n for _ in range(p):\n flow = tf.pad(\n tensor=flow,",
"score": 0.8247625827789307
},
{
"filename": "src/uflow_augmentation.py",
"retrieved_chunk": " flow, mask = uflow_utils.resize(\n flow, new_height, new_width, is_flow=True, mask=mask)\n # crop flow and mask\n flow = tf.image.crop_to_bounding_box(\n flow,\n offset_height=joint_offset_h,\n offset_width=joint_offset_w,\n target_height=crop_height,\n target_width=crop_width)\n mask = tf.image.crop_to_bounding_box(",
"score": 0.8155704736709595
},
{
"filename": "src/uflow_augmentation.py",
"retrieved_chunk": " true_fn=lambda: tf.reverse(flow, axis=[-3]),\n false_fn=lambda: flow)\n mask = tf.cond(pred=perform_flip,\n true_fn=lambda: tf.reverse(mask, axis=[-3]),\n false_fn=lambda: mask)\n # correct sign of flow\n sign_correction = tf.reshape([-1.0, 1.0], [1, 1, 2])\n flow = tf.cond(pred=perform_flip,\n true_fn=lambda: flow * sign_correction,\n false_fn=lambda: flow)",
"score": 0.8128091096878052
},
{
"filename": "src/data/data_utils.py",
"retrieved_chunk": " output = [images]\n if include_flow:\n flow_uv = deserialize(context_parsed['flow_uv'], tf.float32, 2)\n flow_uv = flow_uv[Ellipsis, ::-1]\n if height is not None and width is not None and resize_gt_flow:\n flow_uv = uflow_utils.resize(flow_uv, height, width, is_flow=True)\n else:\n if gt_flow_shape is not None:\n flow_uv.set_shape(gt_flow_shape)\n # To be consistent with uflow internals, we flip the ordering of flow.",
"score": 0.8104661703109741
}
] | python | upsample(flow, is_flow=True) |
# coding=utf-8
# Copyright 2023 Junbong Jang.
#
# 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.
'''
Implement contour flow model takes features along the contour
Estimates the optical flow along the contour
'''
import collections
import tensorflow as tf
from tensorflow.keras import Model
from tensorflow.keras.layers import Concatenate
from tensorflow.keras.layers import Conv2D
from tensorflow.keras.layers import Conv2DTranspose
from tensorflow.keras.layers import LeakyReLU
from tensorflow.keras.models import Sequential
from src import uflow_utils
def normalize_features(feature_list, normalize, center, moments_across_channels,
moments_across_images):
"""Normalizes feature tensors (e.g., before computing the cost volume).
Args:
feature_list: list of tf.tensors, each with dimensions [b, h, w, c]
normalize: bool flag, divide features by their standard deviation
center: bool flag, subtract feature mean
moments_across_channels: bool flag, compute mean and std across channels
moments_across_images: bool flag, compute mean and std across images
Returns:
list, normalized feature_list
"""
# Compute feature statistics.
statistics = collections.defaultdict(list)
axes = [-3, -2, -1] if moments_across_channels else [-3, -2]
for feature_image in feature_list:
mean, variance = tf.nn.moments(x=feature_image, axes=axes, keepdims=True)
statistics['mean'].append(mean)
statistics['var'].append(variance)
if moments_across_images:
statistics['mean'] = ([tf.reduce_mean(input_tensor=statistics['mean'])] *
len(feature_list))
statistics['var'] = [tf.reduce_mean(input_tensor=statistics['var'])
] * len(feature_list)
statistics['std'] = [tf.sqrt(v + 1e-16) for v in statistics['var']]
# Center and normalize features.
if center:
feature_list = [
f - mean for f, mean in zip(feature_list, statistics['mean'])
]
if normalize:
feature_list = [f / std for f, std in zip(feature_list, statistics['std'])]
return feature_list
def compute_cost_volume(features1, features2, max_displacement):
"""Compute the cost volume between features1 and features2.
Displace features2 up to max_displacement in any direction and compute the
per pixel cost of features1 and the displaced features2.
Args:
features1: tf.tensor of shape [b, h, w, c] which means batch, height, width, channels
features2: tf.tensor of shape [b, h, w, c]
max_displacement: int, maximum displacement for cost volume computation.
Returns:
tf.tensor of shape [b, h, w, (2 * max_displacement + 1) ** 2] of costs for
all displacements.
"""
# Set maximum displacement and compute the number of image shifts.
_, height, width, _ = features1.shape.as_list()
if max_displacement <= 0 or max_displacement >= height: # why not check width also?
raise ValueError(f'Max displacement of {max_displacement} is too large.')
max_disp = max_displacement
num_shifts = 2 * max_disp + 1
# Pad features2 such that shifts do not go out of bounds.
features2_padded = tf.pad(
tensor=features2,
paddings=[[0, 0], [max_disp, max_disp], [max_disp, max_disp], [0, 0]],
mode='CONSTANT')
# Shift features2 while keeping features1 fixed to compute the cost volume (correlation).
cost_list = []
for i in range(num_shifts):
for j in range(num_shifts):
corr = tf.reduce_mean(
input_tensor=features1 *
features2_padded[:, i:(height + i), j:(width + j), :],
axis=-1,
keepdims=True)
cost_list.append(corr)
cost_volume = tf.concat(cost_list, axis=-1)
return cost_volume
class ContourFlowModel(Model):
"""Model for estimating flow based on the feature pyramids of two images."""
def __init__(self,
leaky_relu_alpha=0.1,
dropout_rate=0.25,
num_channels_upsampled_context=32,
num_levels=5,
normalize_before_cost_volume=True,
channel_multiplier=1.,
use_cost_volume=True,
use_feature_warp=True,
accumulate_flow=True,
use_bfloat16=False,
shared_flow_decoder=False):
super(ContourFlowModel, self).__init__()
self._use_bfloat16 = use_bfloat16
if use_bfloat16:
self._dtype_policy = tf.keras.mixed_precision.experimental.Policy(
'mixed_bfloat16')
else:
self._dtype_policy = tf.keras.mixed_precision.experimental.Policy(
'float32')
self._leaky_relu_alpha = leaky_relu_alpha
self._drop_out_rate = dropout_rate
self._num_context_up_channels = num_channels_upsampled_context
self._num_levels = num_levels
self._normalize_before_cost_volume = normalize_before_cost_volume
self._channel_multiplier = channel_multiplier
self._use_cost_volume = use_cost_volume
self._use_feature_warp = use_feature_warp
self._accumulate_flow = accumulate_flow
self._shared_flow_decoder = shared_flow_decoder
self._refine_model = self._build_refinement_model()
# print('self._refine_model', self._refine_model.summary())
self._flow_layers = self._build_flow_layers()
# print('self._flow_layers', self._flow_layers.summary())
if not self._use_cost_volume:
self._cost_volume_surrogate_convs = self._build_cost_volume_surrogate_convs(
)
if num_channels_upsampled_context:
self._context_up_layers = self._build_upsample_layers(
num_channels=int(num_channels_upsampled_context * channel_multiplier))
if self._shared_flow_decoder:
# pylint:disable=invalid-name
self._1x1_shared_decoder = self._build_1x1_shared_decoder()
def call(self, feature_pyramid1, feature_pyramid2, segmentation1, segmentation2, training=False):
"""Run the model."""
context = None
flow = None
flow_up = None
context_up = None
flows = []
# Go top down through the levels to the second to last one to estimate flow.
for level, (features1, features2) in reversed(
list(enumerate(zip(feature_pyramid1, feature_pyramid2)))[1:]):
batch_size, height, width, _ = features1.shape.as_list()
# ----------------------------------------------------------
# Feature attention to contour region only
# import pdb; pdb.set_trace()
# if training:
# # resize
# segmentation1 = tf.image.resize(-1*segmentation1+1, [height, width])
# segmentation2 = tf.image.resize(-1*segmentation2+1, [height, width])
#
# # sample features at segmentation portion only
# features1 = tf.math.multiply(features1, segmentation1)
# features2 = tf.math.multiply(features2, segmentation2)
# -------------------------------------------------------
# init flows with zeros for coarsest level if needed
if self._shared_flow_decoder and flow_up is None:
flow_up = tf.zeros(
[batch_size, height, width, 2],
dtype=tf.bfloat16 if self._use_bfloat16 else tf.float32)
if self._num_context_up_channels:
num_channels = int(self._num_context_up_channels *
self._channel_multiplier)
context_up = tf.zeros(
[batch_size, height, width, num_channels],
dtype=tf.bfloat16 if self._use_bfloat16 else tf.float32)
# --------------- Warp features2 with upsampled flow from higher level.
if flow_up is None or not self._use_feature_warp:
warped2 = features2
else:
warp_up = uflow_utils.flow_to_warp(flow_up)
warped2 = uflow_utils. | resample(features2, warp_up) |
# --------------- Compute cost volume by comparing features1 and warped features2.
features1_normalized, warped2_normalized = normalize_features(
[features1, warped2],
normalize=self._normalize_before_cost_volume,
center=self._normalize_before_cost_volume,
moments_across_channels=True,
moments_across_images=True)
if self._use_cost_volume:
cost_volume = compute_cost_volume(
features1_normalized, warped2_normalized, max_displacement=4)
else:
concat_features = Concatenate(axis=-1)(
[features1_normalized, warped2_normalized])
cost_volume = self._cost_volume_surrogate_convs[level](concat_features)
cost_volume = LeakyReLU(
alpha=self._leaky_relu_alpha, dtype=self._dtype_policy)(
cost_volume)
# ----------------------------------------------
if self._shared_flow_decoder:
# This will ensure to work for arbitrary feature sizes per level.
conv_1x1 = self._1x1_shared_decoder[level]
features1 = conv_1x1(features1)
# ------------------- Compute context and flow from previous flow, cost volume, and features1
if flow_up is None:
x_in = Concatenate(axis=-1)([cost_volume, features1])
else:
if context_up is None:
x_in = Concatenate(axis=-1)([flow_up, cost_volume, features1])
else:
x_in = Concatenate(axis=-1)(
[context_up, flow_up, cost_volume, features1])
# Use dense-net connections to get context
x_out = None
if self._shared_flow_decoder:
# reuse the same flow decoder on all levels
flow_layers = self._flow_layers
else:
flow_layers = self._flow_layers[level]
for layer in flow_layers[:-1]:
x_out = layer(x_in)
x_in = Concatenate(axis=-1)([x_in, x_out])
context = x_out
# ----------------- Compute Flow -----------------------------
flow = flow_layers[-1](context)
if (training and self._drop_out_rate):
maybe_dropout = tf.cast(
tf.math.greater(tf.random.uniform([]), self._drop_out_rate),
tf.bfloat16 if self._use_bfloat16 else tf.float32)
context *= maybe_dropout
flow *= maybe_dropout
if flow_up is not None and self._accumulate_flow:
flow += flow_up
# Upsample flow for the next lower level.
flow_up = uflow_utils.upsample(flow, is_flow=True)
if self._num_context_up_channels:
context_up = self._context_up_layers[level](context)
# Append results to list.
flows.insert(0, flow)
# Refine flow at level 1.
refinement = self._refine_model([context, flow])
if (training and self._drop_out_rate):
refinement *= tf.cast(
tf.math.greater(tf.random.uniform([]), self._drop_out_rate),
tf.bfloat16 if self._use_bfloat16 else tf.float32)
refined_flow = flow + refinement
flows[0] = refined_flow
return [tf.cast(flow, tf.float32) for flow in flows]
def _build_cost_volume_surrogate_convs(self):
layers = []
for _ in range(self._num_levels):
layers.append(
Conv2D(
int(64 * self._channel_multiplier),
kernel_size=(4, 4),
padding='same',
dtype=self._dtype_policy))
return layers
def _build_upsample_layers(self, num_channels):
"""Build layers for upsampling via deconvolution."""
layers = []
for unused_level in range(self._num_levels):
layers.append(
Conv2DTranspose(
num_channels,
kernel_size=(4, 4),
strides=2,
padding='same',
dtype=self._dtype_policy))
return layers
def _build_flow_layers(self):
"""Build layers for flow estimation."""
# Empty list of layers level 0 because flow is only estimated at levels > 0.
result = [[]]
for _ in range(1, self._num_levels):
layers = []
for c in [128, 128, 96, 64, 32]:
layers.append(
Sequential([
Conv2D(
int(c * self._channel_multiplier),
kernel_size=(3, 3),
strides=1,
padding='same',
dtype=self._dtype_policy),
LeakyReLU(
alpha=self._leaky_relu_alpha, dtype=self._dtype_policy)
]))
layers.append(
Conv2D(
2,
kernel_size=(3, 3),
strides=1,
padding='same',
dtype=self._dtype_policy))
if self._shared_flow_decoder:
return layers
result.append(layers)
return result
def _build_refinement_model(self):
"""Build model for flow refinement using dilated convolutions."""
layers = []
layers.append(Concatenate(axis=-1))
for c, d in [(128, 1), (128, 2), (128, 4), (96, 8), (64, 16), (32, 1)]:
layers.append(
Conv2D(
int(c * self._channel_multiplier),
kernel_size=(3, 3),
strides=1,
padding='same',
dilation_rate=d,
dtype=self._dtype_policy))
layers.append(
LeakyReLU(alpha=self._leaky_relu_alpha, dtype=self._dtype_policy))
layers.append(
Conv2D(
2,
kernel_size=(3, 3),
strides=1,
padding='same',
dtype=self._dtype_policy))
return Sequential(layers)
def _build_1x1_shared_decoder(self):
"""Build layers for flow estimation."""
# Empty list of layers level 0 because flow is only estimated at levels > 0.
result = [[]]
for _ in range(1, self._num_levels):
result.append(
Conv2D(
32,
kernel_size=(1, 1),
strides=1,
padding='same',
dtype=self._dtype_policy))
return result
class PWCFeaturePyramid(Model):
"""Model for computing a feature pyramid from an image."""
def __init__(self,
leaky_relu_alpha=0.1,
filters=None,
level1_num_layers=3,
level1_num_filters=16,
level1_num_1x1=0,
original_layer_sizes=False,
num_levels=5,
channel_multiplier=1.,
pyramid_resolution='half',
use_bfloat16=False):
"""Constructor.
Args:
leaky_relu_alpha: Float. Alpha for leaky ReLU.
filters: Tuple of tuples. Used to construct feature pyramid. Each tuple is
of form (num_convs_per_group, num_filters_per_conv).
level1_num_layers: How many layers and filters to use on the first
pyramid. Only relevant if filters is None and original_layer_sizes
is False.
level1_num_filters: int, how many filters to include on pyramid layer 1.
Only relevant if filters is None and original_layer_sizes if False.
level1_num_1x1: How many 1x1 convolutions to use on the first pyramid
level.
original_layer_sizes: bool, if True, use the original PWC net number
of layers and filters.
num_levels: int, How many feature pyramid levels to construct.
channel_multiplier: float, used to scale up or down the amount of
computation by increasing or decreasing the number of channels
by this factor.
pyramid_resolution: str, specifies the resolution of the lowest (closest
to input pyramid resolution)
use_bfloat16: bool, whether or not to run in bfloat16 mode.
"""
super(PWCFeaturePyramid, self).__init__()
self._use_bfloat16 = use_bfloat16
if use_bfloat16:
self._dtype_policy = tf.keras.mixed_precision.experimental.Policy(
'mixed_bfloat16')
else:
self._dtype_policy = tf.keras.mixed_precision.experimental.Policy(
'float32')
self._channel_multiplier = channel_multiplier
if num_levels > 6:
raise NotImplementedError('Max number of pyramid levels is 6')
if filters is None:
if original_layer_sizes:
# Orig - last layer
filters = ((3, 16), (3, 32), (3, 64), (3, 96), (3, 128),
(3, 196))[:num_levels]
else:
filters = ((level1_num_layers, level1_num_filters), (3, 32), (3, 32),
(3, 32), (3, 32), (3, 32))[:num_levels]
assert filters
assert all(len(t) == 2 for t in filters)
assert all(t[0] > 0 for t in filters)
self._leaky_relu_alpha = leaky_relu_alpha
self._convs = []
self._level1_num_1x1 = level1_num_1x1
for level, (num_layers, num_filters) in enumerate(filters):
group = []
for i in range(num_layers):
stride = 1
if i == 0 or (i == 1 and level == 0 and
pyramid_resolution == 'quarter'):
stride = 2
conv = Conv2D(
int(num_filters * self._channel_multiplier),
kernel_size=(3,
3) if level > 0 or i < num_layers - level1_num_1x1 else
(1, 1),
strides=stride,
padding='valid',
dtype=self._dtype_policy)
group.append(conv)
self._convs.append(group)
def call(self, x, split_features_by_sample=False):
if self._use_bfloat16:
x = tf.cast(x, tf.bfloat16)
x = x * 2. - 1. # Rescale input from [0,1] to [-1, 1]
features = []
for level, conv_tuple in enumerate(self._convs):
for i, conv in enumerate(conv_tuple):
if level > 0 or i < len(conv_tuple) - self._level1_num_1x1:
x = tf.pad(
tensor=x,
paddings=[[0, 0], [1, 1], [1, 1], [0, 0]],
mode='CONSTANT')
x = conv(x)
x = LeakyReLU(alpha=self._leaky_relu_alpha, dtype=self._dtype_policy)(x)
features.append(x)
if split_features_by_sample:
# Split the list of features per level (for all samples) into a nested
# list that can be indexed by [sample][level].
n = len(features[0])
features = [[f[i:i + 1] for f in features] for i in range(n)] # pylint: disable=g-complex-comprehension
return features
| src/contour_flow_model.py | JunbongJang-contour-tracking-1219b66 | [
{
"filename": "src/uflow_utils.py",
"retrieved_chunk": " image_1 = batch[:, 1]\n features_0 = feature_model(\n image_0, split_features_by_sample=False, training=training)\n features_1 = feature_model(\n image_1, split_features_by_sample=False, training=training)\n # -------------------------------------------\n # ------------------------------------------\n flow = flow_model(features_0, features_1, training=training)\n flow_level2 = flow[0]\n flow_level1 = upsample(flow_level2, is_flow=True)",
"score": 0.8427361249923706
},
{
"filename": "src/contour_flow_net.py",
"retrieved_chunk": " images,\n [batch_size * seq_len, input_height, input_width, image_channels])\n # noinspection PyCallingNonCallable\n features_flattened = self._feature_model(\n images_flattened, split_features_by_sample=False)\n features = [\n tf.reshape(f, [batch_size, seq_len] + f.shape.as_list()[1:])\n for f in features_flattened\n ]\n features1, features2 = [[f[:, i] for f in features] for i in range(2)]",
"score": 0.8213365077972412
},
{
"filename": "src/uflow_utils.py",
"retrieved_chunk": " coords_floor = tf.floor(coords)\n coords_offset = coords - coords_floor\n coords_floor = tf.cast(coords_floor, 'int32')\n # Define a batch offset for flattened indexes into all pixels.\n batch_range = tf.reshape(tf.range(batch_size), [batch_size, 1, 1])\n idx_batch_offset = tf.tile(\n batch_range, [1, flow_height, flow_width]) * output_height * output_width\n # Flatten everything.\n coords_floor_flattened = tf.reshape(coords_floor, [-1, 2])\n coords_offset_flattened = tf.reshape(coords_offset, [-1, 2])",
"score": 0.8158703446388245
},
{
"filename": "src/data/data_utils.py",
"retrieved_chunk": " output = [images]\n if include_flow:\n flow_uv = deserialize(context_parsed['flow_uv'], tf.float32, 2)\n flow_uv = flow_uv[Ellipsis, ::-1]\n if height is not None and width is not None and resize_gt_flow:\n flow_uv = uflow_utils.resize(flow_uv, height, width, is_flow=True)\n else:\n if gt_flow_shape is not None:\n flow_uv.set_shape(gt_flow_shape)\n # To be consistent with uflow internals, we flip the ordering of flow.",
"score": 0.8136569857597351
},
{
"filename": "src/uflow_augmentation.py",
"retrieved_chunk": " new_height = tf.cast(\n tf.math.ceil(tf.cast(orig_height, tf.float32) * scale), tf.int32)\n new_width = tf.cast(\n tf.math.ceil(tf.cast(orig_width, tf.float32) * scale), tf.int32)\n # rescale the images (and flow)\n images = uflow_utils.resize(images, new_height, new_width, is_flow=False)\n if flow is not None:\n flow, mask = uflow_utils.resize(\n flow, new_height, new_width, is_flow=True, mask=mask)\n return images, flow, mask",
"score": 0.8117212057113647
}
] | python | resample(features2, warp_up) |
# coding=utf-8
# Copyright 2023 Junbong Jang.
#
# 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.
"""
Some plotting functionality for contour tracking inference.
"""
import io
import os
import time
import matplotlib
matplotlib.use('Agg') # None-interactive plots do not need tk
import matplotlib.pyplot as plt # pylint: disable=g-import-not-at-top
import numpy as np
import tensorflow as tf
import cv2
import pylab
from tqdm import tqdm
from src import uflow_utils # for resampling the warped image
# How much to scale motion magnitude in visualization.
_FLOW_SCALING_FACTOR = 50.0
# pylint:disable=g-long-lambda
def print_log(log, epoch=None, mean_over_num_steps=1):
"""Print log returned by UFlow.train(...)."""
if epoch is None:
status = ''
else:
status = '{} -- '.format(epoch)
status += 'total-loss: {:.6f}'.format(
np.mean(log['total-loss'][-mean_over_num_steps:]))
for key in sorted(log):
if key not in ['total-loss']:
loss_mean = np.mean(log[key][-mean_over_num_steps:])
status += ', {}: {:.6f}'.format(key, loss_mean)
print(status)
def print_eval(eval_dict):
"""Prints eval_dict to console."""
status = ''.join(
['{}: {:.6f}, '.format(key, eval_dict[key]) for key in sorted(eval_dict)])
print(status[:-2])
def plot_log(log, plot_dir):
plt.figure(1)
plt.clf()
keys = ['total-loss'
] + [key for key in sorted(log) if key not in ['total-loss']]
for key in keys:
plt.plot(log[key], '--' if key == 'total-loss' else '-', label=key)
plt.legend()
save_and_close(os.path.join(plot_dir, 'log.png'))
def log_to_tensorboard(summary_writer, log, saved_offset_dict, epoch=None, mean_over_num_steps=1):
with summary_writer.as_default():
for key in sorted(log):
tf.summary.scalar(key, np.mean(log[key][-mean_over_num_steps:]), step=epoch)
with tf.name_scope("saved_offset_dict"):
for seq_key in saved_offset_dict.keys():
for layer_key in saved_offset_dict[seq_key].keys():
a_string_tensor = tf.strings.as_string(saved_offset_dict[seq_key][layer_key])
tf.summary.text(f"seq_pair {seq_key}, layer {layer_key}:", a_string_tensor, step=epoch)
def save_and_close(filename):
"""Save figures."""
# Create a python byte stream into which to write the plot image.
buf = io.BytesIO()
# Save the image into the buffer.
plt.savefig(buf, format='png')
# Seek the buffer back to the beginning, then either write to file or stdout.
buf.seek(0)
with tf.io.gfile.GFile(filename, 'w') as f:
f.write(buf.read(-1))
plt.close('all')
def time_data_it(data_it, simulated_train_time_ms=100.0):
print('Timing training iterator with simulated train time of {:.2f}ms'.format(
simulated_train_time_ms))
for i in range(100):
start = time.time()
_ = data_it.get_next()
end = time.time()
print(i, 'Time to get one batch (ms):', (end - start) * 1000)
if simulated_train_time_ms > 0.0:
plt.pause(simulated_train_time_ms / 1000.)
def save_image_as_png(image, filename):
image_uint8 = tf.image.convert_image_dtype(image, tf.uint8, saturate=True)
image_png = tf.image.encode_png(image_uint8)
tf.io.write_file(filename, image_png)
def plot_data(data_it, plot_dir, num_plots):
print('Saving images from the dataset to', plot_dir)
for i, (image_batch, _) in enumerate(data_it):
if i >= num_plots:
break
for j, image_sequence in enumerate(image_batch):
for k, image in enumerate(image_sequence):
save_image_as_png(
image, os.path.join(plot_dir, '{}_{}_{}.png'.format(i, j, k)))
def flow_to_rgb(flow):
"""Computes an RGB visualization of a flow field."""
shape = flow.shape
is_graph_mode = False
if not isinstance(shape[0], int): # In graph mode, this is a Dimension object
is_graph_mode = True
shape = [s.value for s in shape]
height, width = [float(s) for s in shape[-3:-1]]
scaling = _FLOW_SCALING_FACTOR / (height**2 + width**2)**0.5
# Compute angles and lengths of motion vectors.
if is_graph_mode:
motion_angle = tf.atan2(flow[Ellipsis, 1], flow[Ellipsis, 0])
else:
motion_angle = np.arctan2(flow[Ellipsis, 1], flow[Ellipsis, 0])
motion_magnitude = (flow[Ellipsis, 1]**2 + flow[Ellipsis, 0]**2)**0.5
# print('motion_angle', motion_angle * (180 / np.pi))
# print('motion_magnitude', motion_magnitude)
# Visualize flow using the HSV color space, where angles are represented by
# hue and magnitudes are represented by saturation.
if is_graph_mode:
flow_hsv = tf.stack([((motion_angle / np.math.pi) + 1.) / 2.,
tf.clip_by_value(motion_magnitude * scaling, 0.0, 1.0),
tf.ones_like(motion_magnitude)],
axis=-1)
else:
flow_hsv = np.stack([((motion_angle / np.math.pi) + 1.) / 2.,
np.clip(motion_magnitude * scaling, 0.0, 1.0),
np.ones_like(motion_magnitude)],
axis=-1)
# Transform colors from HSV to RGB color space for plotting.
if is_graph_mode:
return tf.image.hsv_to_rgb(flow_hsv)
return matplotlib.colors.hsv_to_rgb(flow_hsv)
# --------------------------------------------------------------------------------------------
def save_tracked_contour_indices(plot_dir, cur_index, num_plots, np_all_cur_id_assign):
file_path = f"{plot_dir}/tracked_contour_points.npy"
# save previous predicted tracking points
if cur_index == 1:
saved_tracking_points = np.zeros(shape=(num_plots, np_all_cur_id_assign.shape[0]), dtype=np.int32)
else:
if os.path.exists(file_path):
saved_tracking_points = np.load(file_path)
saved_tracking_points[cur_index - 1, :] = np_all_cur_id_assign
np.save(file_path, saved_tracking_points)
def predict_tracking_plot_manuscript(plot_dir,
cur_index,
image1,
image2,
seg_point1,
seg_point2,
pred_tracking_points,
num_plots):
'''
Plot tracking points on the corresponding frame
'''
a_image = image2
cm = pylab.get_cmap('gist_rainbow')
# prepare save folder
if not os.path.exists(f"{plot_dir}/"):
os.makedirs(f"{plot_dir}/")
file_path = f"{plot_dir}/saved_pred_offset_points.npy"
# save previous predicted tracking points
if cur_index == 1:
saved_tracking_points = np.zeros(shape=(num_plots, pred_tracking_points.shape[0], pred_tracking_points.shape[1]), dtype=np.float32)
else:
if os.path.exists(file_path):
saved_tracking_points = np.load(file_path)
saved_tracking_points[cur_index - 1, :, :] = pred_tracking_points
np.save(file_path, saved_tracking_points)
def predict_tracking_plot(plot_dir,
cur_index,
image1,
image2,
segmentation1,
segmentation2,
seg_point1,
seg_point2,
gt_tracking_points,
pred_tracking_points,
num_plots,
frame_skip=None):
'''
Plot tracking points on the corresponding frame
'''
# --------------- Plot Original Image -------------------------
# save_fig(plot_dir, cur_index, frame_skip, name='image_rgb', cv2_imwrite_data=image1)
# ---------------- Plot Segmentation ------------------
# save_fig(plot_dir, cur_index, frame_skip, name='segmentation1', cv2_imwrite_data=segmentation1)
# ---------------- Plot 2D correlation matrix ----------------
# prepare save folder
# save_folder_name = 'corr_2d_matrix'
# if not os.path.exists(f"{plot_dir}/{save_folder_name}/"):
# os.makedirs(f"{plot_dir}/{save_folder_name}/")
#
# cv2.imwrite(f"{plot_dir}/{save_folder_name}/pred_{cur_index}.png", np.expand_dims(corr_2d_matrix[0], axis=-1) * 255)
# --------------- Plot Tracking Points ---------------
def plot_tracking_points(plot_dir, num_plots, cur_index, gt_tracking_points, pred_tracking_points, a_image):
'''
visualize and save moved tracking points
:return:
'''
cm = pylab.get_cmap('gist_rainbow')
# prepare save folder
if not os.path.exists(f"{plot_dir}/"):
os.makedirs(f"{plot_dir}/")
file_path = f"{plot_dir}/saved_tracking_points.npy"
# save previous predicted tracking points
if cur_index == 1:
saved_tracking_points = np.zeros(shape=(num_plots, pred_tracking_points.shape[0], pred_tracking_points.shape[1]), dtype=np.int32 )
else:
if os.path.exists(file_path):
saved_tracking_points = np.load(file_path)
saved_tracking_points[cur_index-1,:,:] = np.round(pred_tracking_points)
np.save(file_path, saved_tracking_points)
MAX_NUM_POINTS = pred_tracking_points.shape[0]
# -------------- draw predicted points on an image --------------
for point_index, (pred_tracking_point, gt_tracking_point) in enumerate(zip(pred_tracking_points, gt_tracking_points)):
pred_col, pred_row = pred_tracking_point
# TODO: is it ok to ignore these points going outside the image?
if pred_col >= 0 and pred_row >= 0 and pred_col < a_image.shape[1] and pred_row < a_image.shape[0]:
plt.scatter(x=pred_col, y=pred_row, c=np.array([cm(1. * point_index / MAX_NUM_POINTS)]), s=5)
gt_col, gt_row = gt_tracking_point
plt.scatter(x=gt_col, y=gt_row, s=5, facecolors='none', linewidths=0.5, edgecolors=np.array([cm(1. * point_index / MAX_NUM_POINTS)]))
plt.imshow(a_image, cmap='gray')
plt.axis('off')
plt.savefig(f"{plot_dir}/pred_{cur_index}.png", bbox_inches="tight", pad_inches=0)
plt.close()
# -------------- draw GT points on an image --------------
# for point_index, gt_tracking_point in enumerate(gt_tracking_points):
# gt_col, gt_row = gt_tracking_point
# plt.scatter(x=gt_col, y=gt_row, s=5, facecolors='none', linewidths=0.5, edgecolors=np.array([cm(1. * point_index / MAX_NUM_POINTS)]))
#
# plt.imshow(a_image, cmap='gray')
# plt.axis('off')
# plt.savefig(f"{plot_dir}/gt_{cur_index}.png", bbox_inches="tight", pad_inches=0)
# plt.close()
if cur_index == num_plots: # e.g) final frame's index is 50
# -------------- draw trajectory of tracking points in the last image --------------------
plt.imshow(a_image, cmap='gray')
# draw points from each frame on an image
# saved_tracking_points shape is [#frames, #points, 2]
for a_point_index in range(saved_tracking_points.shape[1]):
col_list = saved_tracking_points[:, a_point_index, 0]
row_list = saved_tracking_points[:, a_point_index, 1]
plt.plot(col_list, row_list, c=np.array(cm(1. * a_point_index / MAX_NUM_POINTS)), marker='o', linewidth=2, markersize=2)
plt.savefig(f"{plot_dir}/trajectory.png", bbox_inches="tight", pad_inches=0)
plt.close()
# to reduce the number of tracking points
if gt_tracking_points.shape[0] > 20:
gt_tracking_points = gt_tracking_points[::3, :]
pred_tracking_points = pred_tracking_points[::3, :]
plot_tracking_points(plot_dir, num_plots=num_plots, cur_index=cur_index, gt_tracking_points=gt_tracking_points, pred_tracking_points=pred_tracking_points, a_image=image2)
def predict_plot(plot_dir,
index,
image1,
image2,
segmentation1,
segmentation2,
tracking_point1,
tracking_point2,
flow_uv,
predicted_occlusion,
predicted_range_map,
forward_warp,
forward_valid_warp_mask,
num_plots,
frame_skip=None):
'''
Plots rgb image, flow, occlusions, all as separate images.
'''
# --------------- Plot Original Image -------------------------
save_fig(plot_dir, index, frame_skip, name='image_rgb', cv2_imwrite_data=image1)
# --------------- Convert flow map to arrow map --------------
flow_uv = -flow_uv[:, :, ::-1]
quiver_U = flow_uv[Ellipsis, 0]
quiver_V = flow_uv[Ellipsis, 1]
# maxpooling to make arrows more visible
resize_factor = 8
reshaped_quiver_U = tf.reshape(quiver_U, (1, quiver_U.shape[0], quiver_U.shape[1], 1))
quiver_U = tf.nn.max_pool(reshaped_quiver_U, ksize=resize_factor, strides=resize_factor, padding='VALID')
quiver_U = quiver_U[0,:,:,0]
reshaped_quiver_V = tf.reshape(quiver_V, (1, quiver_V.shape[0], quiver_V.shape[1], 1))
quiver_V = tf.nn.max_pool(reshaped_quiver_V, ksize=resize_factor, strides=resize_factor, padding='VALID')
quiver_V = quiver_V[0,:,:,0]
# set up the figure
fig = plt.figure()
ax = fig.add_subplot(111)
ax.set_aspect('equal')
# ax.set_xlim(left=0, right=flow_uv.shape[1] / resize_factor)
# ax.set_ylim(bottom=0, top=flow_uv.shape[0] / resize_factor)
# draw arrows
ax.quiver(-1*np.flip(quiver_U,0), np.flip(quiver_V,0), units="width", alpha=0.8)
save_fig(plot_dir, index, frame_skip, name='predicted_flow_arrow', fig=fig)
# --------------------------------------------------------------------------------------
# --- this is only works if image1 is the segmented image because the canny edge works well on segmented images ---
# blurred_image1 = cv2.blur(np.uint8(image1), (7, 7))
# edge_image = cv2.Canny(blurred_image1, 0.5, 1, 3, L2gradient=True) # because the image1's intensity is in range [0, 1]
# flow_rgb = flow_to_rgb(flow_uv)
# flow_rgb[edge_image>0] = 0
# ----------------- Plot Optical Flow ------------------
flow_rgb = flow_to_rgb(flow_uv)
save_fig(plot_dir, index, frame_skip, name='predicted_flow', cv2_imwrite_data=flow_rgb)
print("unique flow values: ", np.unique(flow_uv))
# ---------------- Plot Occlusion ---------------------
# occluded region is white
# save_fig(plot_dir, index, frame_skip, name='predicted_occlusion', cv2_imwrite_data=predicted_occlusion[:, :, 0])
# ---------------- Plot Range Map ---------------------
# save_fig(plot_dir, index, frame_skip, name='predicted_range_map', cv2_imwrite_data=predicted_range_map[:, :, 0])
# ---------------- Plot Warped image and contour ------------------
a_warp = uflow_utils. | flow_to_warp_np(flow_uv) |
def save_result_to_npy(a_result, save_path):
if index == 1:
list_of_result = np.expand_dims(a_result, axis=0)
else:
list_of_result = np.load(save_path, allow_pickle=True)
list_of_result = np.append([a_result], list_of_result, axis=0)
np.save(save_path, list_of_result, allow_pickle=True)
# save warp to plot dense correspondence later
warp_path = f"{plot_dir}/warp_list.npy"
save_result_to_npy(a_warp, warp_path)
# Warp Image
warped_image1 = uflow_utils.resample_np(image2, a_warp)
save_fig(plot_dir, index, frame_skip, name='predicted_warped_image', cv2_imwrite_data=warped_image1.numpy()[0])
# Warp contour
# tf.unique_with_counts(tf.reshape(warped_contour1, -1))
warped_contour1 = uflow_utils.resample_np(segmentation2, a_warp) # uint8 [ 474, 392, 1] -> uint8 [474, 392, 1]
warped_contour1 = warped_contour1.numpy()[0]
save_fig(plot_dir, index, frame_skip, name='predicted_warped_contour', cv2_imwrite_data=warped_contour1)
error1 = warped_contour1.astype(np.int32) - segmentation1.astype(np.int32) # e.g. 127 - 255 or 127 - 0
error2 = segmentation1.astype(np.int32) - warped_contour1.astype(np.int32) # e.g. 255 - 127 or 0 - 127
# clipping to ignore negative values
cliped_error1 = np.clip(error1, 0, 255)
cliped_error2 = np.clip(error2, 0, 255)
error = cliped_error1 + cliped_error2
save_fig(plot_dir, index, frame_skip, name='contour_warp_error', cv2_imwrite_data=error.astype(np.uint8))
# ---------------- Plot Segmentation ------------------
save_fig(plot_dir, index, frame_skip, name='segmentation1', cv2_imwrite_data=segmentation1)
# --------------- Plot Tracking Points ---------------
if index>1:
tracking_point1=None
tracking_points = plot_tracking_points_from_optical_flow(plot_dir, save_name='optical_flow_tracking_points', num_plots=num_plots, cur_index=index, a_optical_flow=flow_uv, a_tracking_point=tracking_point1, a_image=image1)
# if index == 50:
# plot_contour_correspondence_with_color(plot_dir, final_frame_index=index, save_name='correspondence_warped_contour', final_frame_contour=segmentation2[:, :, 0]) # segmentation2 only has one channel
return warped_contour1, tracking_points
def plot_tracking_points_from_optical_flow(plot_dir, save_name, num_plots, cur_index, a_optical_flow, a_tracking_point, a_image):
'''
get tracking point from the previous frame
move tracking points using the current frame's optical flow
save moved tracking point
:param plot_dir:
:param save_name:
:param image:
:return:
'''
cm = pylab.get_cmap('gist_rainbow')
# prepare save folder
if not os.path.exists(f"{plot_dir}/{save_name}/"):
os.makedirs(f"{plot_dir}/{save_name}/")
# get tracking points from the previous frame
if a_tracking_point is None:
file_path = f"{plot_dir}/{save_name}/saved_tracking_points.npy"
if os.path.exists(file_path):
loaded_tracking_points = np.load(file_path)
else:
loaded_tracking_points = np.zeros(shape=(num_plots+1, a_tracking_point.shape[0], a_tracking_point.shape[1]), dtype=np.int32 )
loaded_tracking_points[0,:,:] = a_tracking_point
MAX_NUM_POINTS = loaded_tracking_points.shape[1]
# move tracking points using the optical flow
for point_index, a_tracking_point in enumerate(loaded_tracking_points[cur_index-1]):
col, row = a_tracking_point
col_dif = round(a_optical_flow[row, col, 0])
row_dif = round(a_optical_flow[row, col, 1])
new_col = col + col_dif
new_row = row + row_dif
# TODO: is it ok to ignore these points going outside the image?
# draw points on an image
if new_col >= 0 and new_row >= 0 and new_col < a_image.shape[1] and new_row < a_image.shape[0]:
plt.scatter(x=new_col, y=new_row, c=np.array([cm(1. * point_index / MAX_NUM_POINTS)]), s=10)
loaded_tracking_points[cur_index, point_index, 0] = new_col
loaded_tracking_points[cur_index, point_index, 1] = new_row
plt.imshow(a_image, cmap='gray')
plt.axis('off')
plt.savefig(f"{plot_dir}/{save_name}/{cur_index}.png", bbox_inches="tight", pad_inches=0)
plt.close()
# save moved tracking point
np.save(f"{plot_dir}/{save_name}/saved_tracking_points.npy", loaded_tracking_points)
if cur_index == num_plots: # e.g) final frame's index is 50
# -------------- draw trajectory of tracking points in the last image --------------------
plt.imshow(a_image, cmap='gray')
# draw points from each frame on an image
for a_frame in loaded_tracking_points:
for tracking_point_index, a_tracking_point in enumerate(a_frame):
col, row = a_tracking_point
plt.plot(col, row, c=np.array(cm(1. * tracking_point_index / MAX_NUM_POINTS)), marker='o', linewidth=2, markersize=2)
plt.savefig(f"{plot_dir}/{save_name}/trajectory.png", bbox_inches="tight", pad_inches=0)
plt.close()
return loaded_tracking_points
def plot_contour_correspondence_with_color(plot_dir, final_frame_index, save_name, final_frame_contour):
'''
Visualize correspondence between contours in the video by color
Using the saved optical flow at each time step, warp the 200th frame contour back to 1st frame contour
For colormap inspiration, Refer to https://github.com/microsoft/DIF-Net/blob/main/generate.py
:return:
'''
# ------------------- Color the contour -----------------------------
cm = pylab.get_cmap('gist_rainbow') # get color map
y_coords, x_coords = np.where(final_frame_contour > 0) # get coords of the contour points
# assign color to each contour point in order
NUM_COLORS = len(x_coords)
print('Total # of edge pixels', NUM_COLORS)
color_edge = np.zeros((final_frame_contour.shape[0], final_frame_contour.shape[1], 3), dtype=np.float32)
for a_index, (x_coord, y_coord) in enumerate(zip(x_coords, y_coords)):
color_edge[y_coord, x_coord, :] = cm(1. * a_index / NUM_COLORS)[:3]
save_fig(plot_dir, final_frame_index+1, frame_skip=None, name=save_name, cv2_imwrite_data=color_edge)
# ----------------- Warp the colored contour continuously -------
# get list of warps saved in the computer
warp_path = f"{plot_dir}/warp_list.npy"
list_of_warps = np.load(warp_path, allow_pickle=True)
print('Original Contour: ', np.sum(np.sum(color_edge, axis=-1) > 0), ' Unique Colors:', np.unique(np.reshape(color_edge, (-1, 3)), axis=0).shape[0] - 1 )
# i.e. Warps 200th frame to 199th frame and then from 199th frame to 198th frame and so on...
for a_index, a_warp in enumerate(list_of_warps):
if a_index == 0:
warped_contour = uflow_utils.resample_np(color_edge, a_warp)
else:
warped_contour = uflow_utils.resample_np(warped_contour, a_warp)
warped_contour = warped_contour.numpy()[0]
print('Warped Contour: ', np.sum(np.sum(warped_contour, axis=-1) > 0), ' Unique Colors:', np.unique(np.reshape(warped_contour, (-1, 3)), axis=0).shape[0] - 1 )
save_fig(plot_dir, final_frame_index-a_index, frame_skip=None, name=save_name, cv2_imwrite_data=warped_contour)
def save_fig(plot_dir, index, frame_skip, name, fig=None, cv2_imwrite_data=None):
plot_dir = f"{plot_dir}/{name}/"
if not os.path.exists(plot_dir):
os.makedirs(plot_dir)
if frame_skip is not None:
filename = f"{str(index)}_{str(frame_skip)}_{name}.png"
else:
filename = f"{str(index)}_{name}.png"
full_path = os.path.join(plot_dir, filename)
if cv2_imwrite_data is not None:
if cv2_imwrite_data.dtype != np.uint8:
cv2_imwrite_data = (cv2_imwrite_data*255).astype(np.uint8)
cv2_imwrite_data = cv2.cvtColor(cv2_imwrite_data, cv2.COLOR_BGR2RGB)
cv2.imwrite(full_path, cv2_imwrite_data)
else:
plt.xticks([])
plt.yticks([])
if fig is None:
fig = plt
fig.savefig(full_path, bbox_inches='tight')
plt.close('all')
def plot_cum_accuracy_from_first_to_last_frame(plot_dir, list_of_sa_ours, list_of_ca_ours):
num_frames = len(list_of_sa_ours)
x_range = range(num_frames)
np_frames = np.linspace(1, num_frames, num=num_frames)
# ---------------------------------------------------------------------------------
# rebuttal - on phase contrast videos
list_of_sa_ours1 = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.6, 0.6, 0.6, 0.8, 0.8, 0.8, 0.8, 0.6, 0.6, 0.4, 0.4, 0.8, 0.8, 0.8, 0.8, 0.4, 0.4, 0.4, 0.6, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.6, 0.6, 0.4, 0.4, 0.6]
list_of_sa_ours2 = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.6, 0.8, 0.6]
list_of_sa_ours3 = [1.0, 1.0, 0.8, 0.8, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 1.0, 1.0, 1.0, 1.0, 0.8, 1.0, 0.8, 0.6, 0.6, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.2, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2]
list_of_sa_ours4 = [1.0, 1.0, 1.0, 0.8571428571428571, 0.8571428571428571, 0.5714285714285714, 0.7142857142857143, 0.5714285714285714, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.8571428571428571, 1.0, 0.8571428571428571, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.5714285714285714, 0.5714285714285714, 0.7142857142857143, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.42857142857142855, 0.42857142857142855, 0.42857142857142855, 0.42857142857142855, 0.42857142857142855, 0.42857142857142855, 0.2857142857142857, 0.2857142857142857]
list_of_sa_ours = ( np.array(list_of_sa_ours1) + np.array(list_of_sa_ours2) + np.array(list_of_sa_ours3) + np.array(list_of_sa_ours4) ) / 4
list_of_ca_ours1 = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.6, 0.6, 0.6, 0.8, 0.8, 0.8, 0.8, 0.6, 0.6, 0.6, 0.6, 0.8, 0.8, 0.8, 0.8, 0.4, 0.4, 0.6, 0.8, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.6]
list_of_ca_ours2 = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8]
list_of_ca_ours3 = [1.0, 1.0, 0.8, 0.8, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 1.0, 0.8, 1.0, 1.0, 0.8, 1.0, 1.0, 0.8, 0.4, 0.4, 0.4, 0.6, 0.4, 0.4, 0.4, 0.2, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2]
list_of_ca_ours4 = [1.0, 1.0, 1.0, 0.8571428571428571, 0.8571428571428571, 0.7142857142857143, 0.7142857142857143, 0.5714285714285714, 0.7142857142857143, 0.5714285714285714, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.8571428571428571, 1.0, 0.8571428571428571, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.5714285714285714, 0.5714285714285714, 0.7142857142857143, 0.5714285714285714, 0.5714285714285714, 0.42857142857142855, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.42857142857142855, 0.5714285714285714, 0.42857142857142855, 0.42857142857142855, 0.42857142857142855, 0.42857142857142855, 0.42857142857142855, 0.42857142857142855]
list_of_ca_ours = ( np.array(list_of_ca_ours1) + np.array(list_of_ca_ours2) + np.array(list_of_ca_ours3) + np.array(list_of_ca_ours4) ) / 4
list_of_sa_mechanical1 = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.6, 0.6, 0.6, 0.6, 0.4, 0.4, 0.4, 0.4, 0.4, 0.2, 0.4, 0.2, 0.2, 0.2, 0.4, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2]
list_of_sa_mechanical2 = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.6, 0.6, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.6, 0.6, 0.8, 0.8]
list_of_sa_mechanical3 = [1.0, 1.0, 0.8, 0.8, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.6, 0.8, 0.6, 0.6, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4]
list_of_sa_mechanical4 = [1.0, 1.0, 1.0, 1.0, 0.8571428571428571, 1.0, 0.8571428571428571, 0.8571428571428571, 0.8571428571428571, 0.8571428571428571, 0.7142857142857143, 0.8571428571428571, 0.8571428571428571, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.8571428571428571, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.7142857142857143, 0.5714285714285714, 0.5714285714285714, 0.42857142857142855, 0.5714285714285714, 0.5714285714285714, 0.42857142857142855, 0.42857142857142855]
list_of_sa_mechanical = ( np.array(list_of_sa_mechanical1) + np.array(list_of_sa_mechanical2) + np.array(list_of_sa_mechanical3) + np.array(list_of_sa_mechanical4) ) / 4
list_of_ca_mechanical1 = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.6, 0.6, 0.6, 0.2, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.2, 0.2, 0.2, 0.4, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2]
list_of_ca_mechanical2 = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8]
list_of_ca_mechanical3 = [1.0, 1.0, 0.8, 0.8, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.6, 0.6, 0.6, 0.6, 0.4, 0.4, 0.4, 0.6, 0.6, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4]
list_of_ca_mechanical4 = [1.0, 1.0, 1.0, 1.0, 0.8571428571428571, 1.0, 0.8571428571428571, 0.8571428571428571, 0.8571428571428571, 1.0, 1.0, 1.0, 0.8571428571428571, 1.0, 0.7142857142857143, 0.7142857142857143, 0.8571428571428571, 0.8571428571428571, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.5714285714285714, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.5714285714285714, 0.7142857142857143, 0.5714285714285714, 0.5714285714285714, 0.7142857142857143, 0.7142857142857143, 0.42857142857142855]
list_of_ca_mechanical = ( np.array(list_of_ca_mechanical1) + np.array(list_of_ca_mechanical2) + np.array(list_of_ca_mechanical3) + np.array(list_of_ca_mechanical4) ) / 4
# list_of_sa_mechanical = [1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.6, 0.8, 0.8, 0.8, 0.8, 0.8, 0.6, 0.6, 0.8, 0.6, 0.8, 0.6, 0.6, 0.8, 0.8, 0.8, 0.6, 0.6, 0.6, 0.6, 0.8, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6]
# list_of_ca_mechanical = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.6, 0.8, 0.6, 0.8, 0.8, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.8, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6]
# ---------------------------------------------------------------------------------
# get cumulative accuracy
np_cum_sa = np.cumsum(list_of_sa_ours)
np_cum_mean_sa = np_cum_sa/np_frames
np_cum_ca = np.cumsum(list_of_ca_ours)
np_cum_mean_ca = np_cum_ca/np_frames
np_cum_sa_mechanical = np.cumsum(list_of_sa_mechanical)
np_cum_mean_sa_mechanical = np_cum_sa_mechanical/np_frames
np_cum_ca_mechanical = np.cumsum(list_of_ca_mechanical)
np_cum_mean_ca_mechanical = np_cum_ca_mechanical/np_frames
plt.figure(figsize=(6, 2), dpi=300)
plt.plot(x_range, np_cum_mean_sa, label='Ours (SA$_{.02}$)', color='lawngreen')
plt.plot(x_range, np_cum_mean_ca, label='Ours (CA$_{.01}$)', color='lawngreen', linestyle='dashed')
plt.plot(x_range, np_cum_mean_sa_mechanical, label='Mechanical (SA$_{.02}$)', color='darkorange')
plt.plot(x_range, np_cum_mean_ca_mechanical, label='Mechanical (CA$_{.01}$)', color='darkorange', linestyle='dashed')
plt.xlabel('Frames')
plt.ylabel('CMA')
plt.legend(loc='lower left')
plt.tight_layout()
plt.savefig(f'{plot_dir}/cumulative_accuracy.svg')
| src/uflow_plotting.py | JunbongJang-contour-tracking-1219b66 | [
{
"filename": "src/data/data_utils.py",
"retrieved_chunk": " seg_points_batch[1].numpy(),\n gt_tracking_points,\n pred_tracking_points,\n num_plots,\n frame_skip=None)\n # Dense correspondence figure for manuscript\n uflow_plotting.save_tracked_contour_indices(save_dir, plot_count, num_plots, np_all_cur_id_assign[:,0])\n uflow_plotting.predict_tracking_plot_manuscript(save_dir,\n plot_count,\n image_batch[0].numpy(),",
"score": 0.8150898814201355
},
{
"filename": "src/data_conversion_scripts/conversion_utils.py",
"retrieved_chunk": " uv: np.array, predicted flow in u, v coordinates (horizontal, vertical)\n \"\"\"\n n_bands = 2\n tag_char = np.array([MIDDLEBURY_MAGIC], np.float32)\n assert uv.ndim == 3\n assert uv.shape[2] == 2\n u = uv[:, :, 0]\n v = uv[:, :, 1]\n assert u.shape == v.shape\n height, width = u.shape",
"score": 0.8079584836959839
},
{
"filename": "src/data/data_utils.py",
"retrieved_chunk": " if plot_dir and plot_count < num_plots:\n plot_count += 1\n save_dir = f'{plot_dir}/pred_tracking_points'\n uflow_plotting.predict_tracking_plot(save_dir,\n plot_count,\n image_batch[0].numpy(),\n image_batch[1].numpy(),\n segmentation_batch[0].numpy(),\n segmentation_batch[1].numpy(),\n seg_points_batch[0].numpy(),",
"score": 0.8067789077758789
},
{
"filename": "src/data/data_utils.py",
"retrieved_chunk": " output.append(flow_uv)\n # create valid mask\n flow_valid = tf.ones_like(flow_uv[Ellipsis, :1], dtype=tf.float32)\n output.append(flow_valid)\n if include_occlusion:\n occlusion_mask = deserialize(context_parsed['occlusion_mask'], tf.uint8, 1)\n if height is not None and width is not None:\n occlusion_mask = uflow_utils.resize_uint8(\n occlusion_mask, height, width)\n output.append(occlusion_mask)",
"score": 0.8015685081481934
},
{
"filename": "src/contour_flow_main.py",
"retrieved_chunk": " predict = uflow_data.make_predict_function(\n FLAGS.predict_on,\n FLAGS.height,\n FLAGS.width,\n progress_bar=True,\n plot_dir=FLAGS.plot_dir,\n num_plots=FLAGS.num_plot,\n include_segmentations=FLAGS.use_segmentations,\n include_seg_points=FLAGS.use_seg_points,\n include_tracking_points=FLAGS.use_tracking_points,",
"score": 0.7950992584228516
}
] | python | flow_to_warp_np(flow_uv) |
# coding=utf-8
# Copyright 2023 Junbong Jang.
#
# 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.
"""
Some plotting functionality for contour tracking inference.
"""
import io
import os
import time
import matplotlib
matplotlib.use('Agg') # None-interactive plots do not need tk
import matplotlib.pyplot as plt # pylint: disable=g-import-not-at-top
import numpy as np
import tensorflow as tf
import cv2
import pylab
from tqdm import tqdm
from src import uflow_utils # for resampling the warped image
# How much to scale motion magnitude in visualization.
_FLOW_SCALING_FACTOR = 50.0
# pylint:disable=g-long-lambda
def print_log(log, epoch=None, mean_over_num_steps=1):
"""Print log returned by UFlow.train(...)."""
if epoch is None:
status = ''
else:
status = '{} -- '.format(epoch)
status += 'total-loss: {:.6f}'.format(
np.mean(log['total-loss'][-mean_over_num_steps:]))
for key in sorted(log):
if key not in ['total-loss']:
loss_mean = np.mean(log[key][-mean_over_num_steps:])
status += ', {}: {:.6f}'.format(key, loss_mean)
print(status)
def print_eval(eval_dict):
"""Prints eval_dict to console."""
status = ''.join(
['{}: {:.6f}, '.format(key, eval_dict[key]) for key in sorted(eval_dict)])
print(status[:-2])
def plot_log(log, plot_dir):
plt.figure(1)
plt.clf()
keys = ['total-loss'
] + [key for key in sorted(log) if key not in ['total-loss']]
for key in keys:
plt.plot(log[key], '--' if key == 'total-loss' else '-', label=key)
plt.legend()
save_and_close(os.path.join(plot_dir, 'log.png'))
def log_to_tensorboard(summary_writer, log, saved_offset_dict, epoch=None, mean_over_num_steps=1):
with summary_writer.as_default():
for key in sorted(log):
tf.summary.scalar(key, np.mean(log[key][-mean_over_num_steps:]), step=epoch)
with tf.name_scope("saved_offset_dict"):
for seq_key in saved_offset_dict.keys():
for layer_key in saved_offset_dict[seq_key].keys():
a_string_tensor = tf.strings.as_string(saved_offset_dict[seq_key][layer_key])
tf.summary.text(f"seq_pair {seq_key}, layer {layer_key}:", a_string_tensor, step=epoch)
def save_and_close(filename):
"""Save figures."""
# Create a python byte stream into which to write the plot image.
buf = io.BytesIO()
# Save the image into the buffer.
plt.savefig(buf, format='png')
# Seek the buffer back to the beginning, then either write to file or stdout.
buf.seek(0)
with tf.io.gfile.GFile(filename, 'w') as f:
f.write(buf.read(-1))
plt.close('all')
def time_data_it(data_it, simulated_train_time_ms=100.0):
print('Timing training iterator with simulated train time of {:.2f}ms'.format(
simulated_train_time_ms))
for i in range(100):
start = time.time()
_ = data_it.get_next()
end = time.time()
print(i, 'Time to get one batch (ms):', (end - start) * 1000)
if simulated_train_time_ms > 0.0:
plt.pause(simulated_train_time_ms / 1000.)
def save_image_as_png(image, filename):
image_uint8 = tf.image.convert_image_dtype(image, tf.uint8, saturate=True)
image_png = tf.image.encode_png(image_uint8)
tf.io.write_file(filename, image_png)
def plot_data(data_it, plot_dir, num_plots):
print('Saving images from the dataset to', plot_dir)
for i, (image_batch, _) in enumerate(data_it):
if i >= num_plots:
break
for j, image_sequence in enumerate(image_batch):
for k, image in enumerate(image_sequence):
save_image_as_png(
image, os.path.join(plot_dir, '{}_{}_{}.png'.format(i, j, k)))
def flow_to_rgb(flow):
"""Computes an RGB visualization of a flow field."""
shape = flow.shape
is_graph_mode = False
if not isinstance(shape[0], int): # In graph mode, this is a Dimension object
is_graph_mode = True
shape = [s.value for s in shape]
height, width = [float(s) for s in shape[-3:-1]]
scaling = _FLOW_SCALING_FACTOR / (height**2 + width**2)**0.5
# Compute angles and lengths of motion vectors.
if is_graph_mode:
motion_angle = tf.atan2(flow[Ellipsis, 1], flow[Ellipsis, 0])
else:
motion_angle = np.arctan2(flow[Ellipsis, 1], flow[Ellipsis, 0])
motion_magnitude = (flow[Ellipsis, 1]**2 + flow[Ellipsis, 0]**2)**0.5
# print('motion_angle', motion_angle * (180 / np.pi))
# print('motion_magnitude', motion_magnitude)
# Visualize flow using the HSV color space, where angles are represented by
# hue and magnitudes are represented by saturation.
if is_graph_mode:
flow_hsv = tf.stack([((motion_angle / np.math.pi) + 1.) / 2.,
tf.clip_by_value(motion_magnitude * scaling, 0.0, 1.0),
tf.ones_like(motion_magnitude)],
axis=-1)
else:
flow_hsv = np.stack([((motion_angle / np.math.pi) + 1.) / 2.,
np.clip(motion_magnitude * scaling, 0.0, 1.0),
np.ones_like(motion_magnitude)],
axis=-1)
# Transform colors from HSV to RGB color space for plotting.
if is_graph_mode:
return tf.image.hsv_to_rgb(flow_hsv)
return matplotlib.colors.hsv_to_rgb(flow_hsv)
# --------------------------------------------------------------------------------------------
def save_tracked_contour_indices(plot_dir, cur_index, num_plots, np_all_cur_id_assign):
file_path = f"{plot_dir}/tracked_contour_points.npy"
# save previous predicted tracking points
if cur_index == 1:
saved_tracking_points = np.zeros(shape=(num_plots, np_all_cur_id_assign.shape[0]), dtype=np.int32)
else:
if os.path.exists(file_path):
saved_tracking_points = np.load(file_path)
saved_tracking_points[cur_index - 1, :] = np_all_cur_id_assign
np.save(file_path, saved_tracking_points)
def predict_tracking_plot_manuscript(plot_dir,
cur_index,
image1,
image2,
seg_point1,
seg_point2,
pred_tracking_points,
num_plots):
'''
Plot tracking points on the corresponding frame
'''
a_image = image2
cm = pylab.get_cmap('gist_rainbow')
# prepare save folder
if not os.path.exists(f"{plot_dir}/"):
os.makedirs(f"{plot_dir}/")
file_path = f"{plot_dir}/saved_pred_offset_points.npy"
# save previous predicted tracking points
if cur_index == 1:
saved_tracking_points = np.zeros(shape=(num_plots, pred_tracking_points.shape[0], pred_tracking_points.shape[1]), dtype=np.float32)
else:
if os.path.exists(file_path):
saved_tracking_points = np.load(file_path)
saved_tracking_points[cur_index - 1, :, :] = pred_tracking_points
np.save(file_path, saved_tracking_points)
def predict_tracking_plot(plot_dir,
cur_index,
image1,
image2,
segmentation1,
segmentation2,
seg_point1,
seg_point2,
gt_tracking_points,
pred_tracking_points,
num_plots,
frame_skip=None):
'''
Plot tracking points on the corresponding frame
'''
# --------------- Plot Original Image -------------------------
# save_fig(plot_dir, cur_index, frame_skip, name='image_rgb', cv2_imwrite_data=image1)
# ---------------- Plot Segmentation ------------------
# save_fig(plot_dir, cur_index, frame_skip, name='segmentation1', cv2_imwrite_data=segmentation1)
# ---------------- Plot 2D correlation matrix ----------------
# prepare save folder
# save_folder_name = 'corr_2d_matrix'
# if not os.path.exists(f"{plot_dir}/{save_folder_name}/"):
# os.makedirs(f"{plot_dir}/{save_folder_name}/")
#
# cv2.imwrite(f"{plot_dir}/{save_folder_name}/pred_{cur_index}.png", np.expand_dims(corr_2d_matrix[0], axis=-1) * 255)
# --------------- Plot Tracking Points ---------------
def plot_tracking_points(plot_dir, num_plots, cur_index, gt_tracking_points, pred_tracking_points, a_image):
'''
visualize and save moved tracking points
:return:
'''
cm = pylab.get_cmap('gist_rainbow')
# prepare save folder
if not os.path.exists(f"{plot_dir}/"):
os.makedirs(f"{plot_dir}/")
file_path = f"{plot_dir}/saved_tracking_points.npy"
# save previous predicted tracking points
if cur_index == 1:
saved_tracking_points = np.zeros(shape=(num_plots, pred_tracking_points.shape[0], pred_tracking_points.shape[1]), dtype=np.int32 )
else:
if os.path.exists(file_path):
saved_tracking_points = np.load(file_path)
saved_tracking_points[cur_index-1,:,:] = np.round(pred_tracking_points)
np.save(file_path, saved_tracking_points)
MAX_NUM_POINTS = pred_tracking_points.shape[0]
# -------------- draw predicted points on an image --------------
for point_index, (pred_tracking_point, gt_tracking_point) in enumerate(zip(pred_tracking_points, gt_tracking_points)):
pred_col, pred_row = pred_tracking_point
# TODO: is it ok to ignore these points going outside the image?
if pred_col >= 0 and pred_row >= 0 and pred_col < a_image.shape[1] and pred_row < a_image.shape[0]:
plt.scatter(x=pred_col, y=pred_row, c=np.array([cm(1. * point_index / MAX_NUM_POINTS)]), s=5)
gt_col, gt_row = gt_tracking_point
plt.scatter(x=gt_col, y=gt_row, s=5, facecolors='none', linewidths=0.5, edgecolors=np.array([cm(1. * point_index / MAX_NUM_POINTS)]))
plt.imshow(a_image, cmap='gray')
plt.axis('off')
plt.savefig(f"{plot_dir}/pred_{cur_index}.png", bbox_inches="tight", pad_inches=0)
plt.close()
# -------------- draw GT points on an image --------------
# for point_index, gt_tracking_point in enumerate(gt_tracking_points):
# gt_col, gt_row = gt_tracking_point
# plt.scatter(x=gt_col, y=gt_row, s=5, facecolors='none', linewidths=0.5, edgecolors=np.array([cm(1. * point_index / MAX_NUM_POINTS)]))
#
# plt.imshow(a_image, cmap='gray')
# plt.axis('off')
# plt.savefig(f"{plot_dir}/gt_{cur_index}.png", bbox_inches="tight", pad_inches=0)
# plt.close()
if cur_index == num_plots: # e.g) final frame's index is 50
# -------------- draw trajectory of tracking points in the last image --------------------
plt.imshow(a_image, cmap='gray')
# draw points from each frame on an image
# saved_tracking_points shape is [#frames, #points, 2]
for a_point_index in range(saved_tracking_points.shape[1]):
col_list = saved_tracking_points[:, a_point_index, 0]
row_list = saved_tracking_points[:, a_point_index, 1]
plt.plot(col_list, row_list, c=np.array(cm(1. * a_point_index / MAX_NUM_POINTS)), marker='o', linewidth=2, markersize=2)
plt.savefig(f"{plot_dir}/trajectory.png", bbox_inches="tight", pad_inches=0)
plt.close()
# to reduce the number of tracking points
if gt_tracking_points.shape[0] > 20:
gt_tracking_points = gt_tracking_points[::3, :]
pred_tracking_points = pred_tracking_points[::3, :]
plot_tracking_points(plot_dir, num_plots=num_plots, cur_index=cur_index, gt_tracking_points=gt_tracking_points, pred_tracking_points=pred_tracking_points, a_image=image2)
def predict_plot(plot_dir,
index,
image1,
image2,
segmentation1,
segmentation2,
tracking_point1,
tracking_point2,
flow_uv,
predicted_occlusion,
predicted_range_map,
forward_warp,
forward_valid_warp_mask,
num_plots,
frame_skip=None):
'''
Plots rgb image, flow, occlusions, all as separate images.
'''
# --------------- Plot Original Image -------------------------
save_fig(plot_dir, index, frame_skip, name='image_rgb', cv2_imwrite_data=image1)
# --------------- Convert flow map to arrow map --------------
flow_uv = -flow_uv[:, :, ::-1]
quiver_U = flow_uv[Ellipsis, 0]
quiver_V = flow_uv[Ellipsis, 1]
# maxpooling to make arrows more visible
resize_factor = 8
reshaped_quiver_U = tf.reshape(quiver_U, (1, quiver_U.shape[0], quiver_U.shape[1], 1))
quiver_U = tf.nn.max_pool(reshaped_quiver_U, ksize=resize_factor, strides=resize_factor, padding='VALID')
quiver_U = quiver_U[0,:,:,0]
reshaped_quiver_V = tf.reshape(quiver_V, (1, quiver_V.shape[0], quiver_V.shape[1], 1))
quiver_V = tf.nn.max_pool(reshaped_quiver_V, ksize=resize_factor, strides=resize_factor, padding='VALID')
quiver_V = quiver_V[0,:,:,0]
# set up the figure
fig = plt.figure()
ax = fig.add_subplot(111)
ax.set_aspect('equal')
# ax.set_xlim(left=0, right=flow_uv.shape[1] / resize_factor)
# ax.set_ylim(bottom=0, top=flow_uv.shape[0] / resize_factor)
# draw arrows
ax.quiver(-1*np.flip(quiver_U,0), np.flip(quiver_V,0), units="width", alpha=0.8)
save_fig(plot_dir, index, frame_skip, name='predicted_flow_arrow', fig=fig)
# --------------------------------------------------------------------------------------
# --- this is only works if image1 is the segmented image because the canny edge works well on segmented images ---
# blurred_image1 = cv2.blur(np.uint8(image1), (7, 7))
# edge_image = cv2.Canny(blurred_image1, 0.5, 1, 3, L2gradient=True) # because the image1's intensity is in range [0, 1]
# flow_rgb = flow_to_rgb(flow_uv)
# flow_rgb[edge_image>0] = 0
# ----------------- Plot Optical Flow ------------------
flow_rgb = flow_to_rgb(flow_uv)
save_fig(plot_dir, index, frame_skip, name='predicted_flow', cv2_imwrite_data=flow_rgb)
print("unique flow values: ", np.unique(flow_uv))
# ---------------- Plot Occlusion ---------------------
# occluded region is white
# save_fig(plot_dir, index, frame_skip, name='predicted_occlusion', cv2_imwrite_data=predicted_occlusion[:, :, 0])
# ---------------- Plot Range Map ---------------------
# save_fig(plot_dir, index, frame_skip, name='predicted_range_map', cv2_imwrite_data=predicted_range_map[:, :, 0])
# ---------------- Plot Warped image and contour ------------------
a_warp = uflow_utils.flow_to_warp_np(flow_uv)
def save_result_to_npy(a_result, save_path):
if index == 1:
list_of_result = np.expand_dims(a_result, axis=0)
else:
list_of_result = np.load(save_path, allow_pickle=True)
list_of_result = np.append([a_result], list_of_result, axis=0)
np.save(save_path, list_of_result, allow_pickle=True)
# save warp to plot dense correspondence later
warp_path = f"{plot_dir}/warp_list.npy"
save_result_to_npy(a_warp, warp_path)
# Warp Image
warped_image1 = uflow_utils. | resample_np(image2, a_warp) |
save_fig(plot_dir, index, frame_skip, name='predicted_warped_image', cv2_imwrite_data=warped_image1.numpy()[0])
# Warp contour
# tf.unique_with_counts(tf.reshape(warped_contour1, -1))
warped_contour1 = uflow_utils.resample_np(segmentation2, a_warp) # uint8 [ 474, 392, 1] -> uint8 [474, 392, 1]
warped_contour1 = warped_contour1.numpy()[0]
save_fig(plot_dir, index, frame_skip, name='predicted_warped_contour', cv2_imwrite_data=warped_contour1)
error1 = warped_contour1.astype(np.int32) - segmentation1.astype(np.int32) # e.g. 127 - 255 or 127 - 0
error2 = segmentation1.astype(np.int32) - warped_contour1.astype(np.int32) # e.g. 255 - 127 or 0 - 127
# clipping to ignore negative values
cliped_error1 = np.clip(error1, 0, 255)
cliped_error2 = np.clip(error2, 0, 255)
error = cliped_error1 + cliped_error2
save_fig(plot_dir, index, frame_skip, name='contour_warp_error', cv2_imwrite_data=error.astype(np.uint8))
# ---------------- Plot Segmentation ------------------
save_fig(plot_dir, index, frame_skip, name='segmentation1', cv2_imwrite_data=segmentation1)
# --------------- Plot Tracking Points ---------------
if index>1:
tracking_point1=None
tracking_points = plot_tracking_points_from_optical_flow(plot_dir, save_name='optical_flow_tracking_points', num_plots=num_plots, cur_index=index, a_optical_flow=flow_uv, a_tracking_point=tracking_point1, a_image=image1)
# if index == 50:
# plot_contour_correspondence_with_color(plot_dir, final_frame_index=index, save_name='correspondence_warped_contour', final_frame_contour=segmentation2[:, :, 0]) # segmentation2 only has one channel
return warped_contour1, tracking_points
def plot_tracking_points_from_optical_flow(plot_dir, save_name, num_plots, cur_index, a_optical_flow, a_tracking_point, a_image):
'''
get tracking point from the previous frame
move tracking points using the current frame's optical flow
save moved tracking point
:param plot_dir:
:param save_name:
:param image:
:return:
'''
cm = pylab.get_cmap('gist_rainbow')
# prepare save folder
if not os.path.exists(f"{plot_dir}/{save_name}/"):
os.makedirs(f"{plot_dir}/{save_name}/")
# get tracking points from the previous frame
if a_tracking_point is None:
file_path = f"{plot_dir}/{save_name}/saved_tracking_points.npy"
if os.path.exists(file_path):
loaded_tracking_points = np.load(file_path)
else:
loaded_tracking_points = np.zeros(shape=(num_plots+1, a_tracking_point.shape[0], a_tracking_point.shape[1]), dtype=np.int32 )
loaded_tracking_points[0,:,:] = a_tracking_point
MAX_NUM_POINTS = loaded_tracking_points.shape[1]
# move tracking points using the optical flow
for point_index, a_tracking_point in enumerate(loaded_tracking_points[cur_index-1]):
col, row = a_tracking_point
col_dif = round(a_optical_flow[row, col, 0])
row_dif = round(a_optical_flow[row, col, 1])
new_col = col + col_dif
new_row = row + row_dif
# TODO: is it ok to ignore these points going outside the image?
# draw points on an image
if new_col >= 0 and new_row >= 0 and new_col < a_image.shape[1] and new_row < a_image.shape[0]:
plt.scatter(x=new_col, y=new_row, c=np.array([cm(1. * point_index / MAX_NUM_POINTS)]), s=10)
loaded_tracking_points[cur_index, point_index, 0] = new_col
loaded_tracking_points[cur_index, point_index, 1] = new_row
plt.imshow(a_image, cmap='gray')
plt.axis('off')
plt.savefig(f"{plot_dir}/{save_name}/{cur_index}.png", bbox_inches="tight", pad_inches=0)
plt.close()
# save moved tracking point
np.save(f"{plot_dir}/{save_name}/saved_tracking_points.npy", loaded_tracking_points)
if cur_index == num_plots: # e.g) final frame's index is 50
# -------------- draw trajectory of tracking points in the last image --------------------
plt.imshow(a_image, cmap='gray')
# draw points from each frame on an image
for a_frame in loaded_tracking_points:
for tracking_point_index, a_tracking_point in enumerate(a_frame):
col, row = a_tracking_point
plt.plot(col, row, c=np.array(cm(1. * tracking_point_index / MAX_NUM_POINTS)), marker='o', linewidth=2, markersize=2)
plt.savefig(f"{plot_dir}/{save_name}/trajectory.png", bbox_inches="tight", pad_inches=0)
plt.close()
return loaded_tracking_points
def plot_contour_correspondence_with_color(plot_dir, final_frame_index, save_name, final_frame_contour):
'''
Visualize correspondence between contours in the video by color
Using the saved optical flow at each time step, warp the 200th frame contour back to 1st frame contour
For colormap inspiration, Refer to https://github.com/microsoft/DIF-Net/blob/main/generate.py
:return:
'''
# ------------------- Color the contour -----------------------------
cm = pylab.get_cmap('gist_rainbow') # get color map
y_coords, x_coords = np.where(final_frame_contour > 0) # get coords of the contour points
# assign color to each contour point in order
NUM_COLORS = len(x_coords)
print('Total # of edge pixels', NUM_COLORS)
color_edge = np.zeros((final_frame_contour.shape[0], final_frame_contour.shape[1], 3), dtype=np.float32)
for a_index, (x_coord, y_coord) in enumerate(zip(x_coords, y_coords)):
color_edge[y_coord, x_coord, :] = cm(1. * a_index / NUM_COLORS)[:3]
save_fig(plot_dir, final_frame_index+1, frame_skip=None, name=save_name, cv2_imwrite_data=color_edge)
# ----------------- Warp the colored contour continuously -------
# get list of warps saved in the computer
warp_path = f"{plot_dir}/warp_list.npy"
list_of_warps = np.load(warp_path, allow_pickle=True)
print('Original Contour: ', np.sum(np.sum(color_edge, axis=-1) > 0), ' Unique Colors:', np.unique(np.reshape(color_edge, (-1, 3)), axis=0).shape[0] - 1 )
# i.e. Warps 200th frame to 199th frame and then from 199th frame to 198th frame and so on...
for a_index, a_warp in enumerate(list_of_warps):
if a_index == 0:
warped_contour = uflow_utils.resample_np(color_edge, a_warp)
else:
warped_contour = uflow_utils.resample_np(warped_contour, a_warp)
warped_contour = warped_contour.numpy()[0]
print('Warped Contour: ', np.sum(np.sum(warped_contour, axis=-1) > 0), ' Unique Colors:', np.unique(np.reshape(warped_contour, (-1, 3)), axis=0).shape[0] - 1 )
save_fig(plot_dir, final_frame_index-a_index, frame_skip=None, name=save_name, cv2_imwrite_data=warped_contour)
def save_fig(plot_dir, index, frame_skip, name, fig=None, cv2_imwrite_data=None):
plot_dir = f"{plot_dir}/{name}/"
if not os.path.exists(plot_dir):
os.makedirs(plot_dir)
if frame_skip is not None:
filename = f"{str(index)}_{str(frame_skip)}_{name}.png"
else:
filename = f"{str(index)}_{name}.png"
full_path = os.path.join(plot_dir, filename)
if cv2_imwrite_data is not None:
if cv2_imwrite_data.dtype != np.uint8:
cv2_imwrite_data = (cv2_imwrite_data*255).astype(np.uint8)
cv2_imwrite_data = cv2.cvtColor(cv2_imwrite_data, cv2.COLOR_BGR2RGB)
cv2.imwrite(full_path, cv2_imwrite_data)
else:
plt.xticks([])
plt.yticks([])
if fig is None:
fig = plt
fig.savefig(full_path, bbox_inches='tight')
plt.close('all')
def plot_cum_accuracy_from_first_to_last_frame(plot_dir, list_of_sa_ours, list_of_ca_ours):
num_frames = len(list_of_sa_ours)
x_range = range(num_frames)
np_frames = np.linspace(1, num_frames, num=num_frames)
# ---------------------------------------------------------------------------------
# rebuttal - on phase contrast videos
list_of_sa_ours1 = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.6, 0.6, 0.6, 0.8, 0.8, 0.8, 0.8, 0.6, 0.6, 0.4, 0.4, 0.8, 0.8, 0.8, 0.8, 0.4, 0.4, 0.4, 0.6, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.6, 0.6, 0.4, 0.4, 0.6]
list_of_sa_ours2 = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.6, 0.8, 0.6]
list_of_sa_ours3 = [1.0, 1.0, 0.8, 0.8, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 1.0, 1.0, 1.0, 1.0, 0.8, 1.0, 0.8, 0.6, 0.6, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.2, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2]
list_of_sa_ours4 = [1.0, 1.0, 1.0, 0.8571428571428571, 0.8571428571428571, 0.5714285714285714, 0.7142857142857143, 0.5714285714285714, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.8571428571428571, 1.0, 0.8571428571428571, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.5714285714285714, 0.5714285714285714, 0.7142857142857143, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.42857142857142855, 0.42857142857142855, 0.42857142857142855, 0.42857142857142855, 0.42857142857142855, 0.42857142857142855, 0.2857142857142857, 0.2857142857142857]
list_of_sa_ours = ( np.array(list_of_sa_ours1) + np.array(list_of_sa_ours2) + np.array(list_of_sa_ours3) + np.array(list_of_sa_ours4) ) / 4
list_of_ca_ours1 = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.6, 0.6, 0.6, 0.8, 0.8, 0.8, 0.8, 0.6, 0.6, 0.6, 0.6, 0.8, 0.8, 0.8, 0.8, 0.4, 0.4, 0.6, 0.8, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.6]
list_of_ca_ours2 = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8]
list_of_ca_ours3 = [1.0, 1.0, 0.8, 0.8, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 1.0, 0.8, 1.0, 1.0, 0.8, 1.0, 1.0, 0.8, 0.4, 0.4, 0.4, 0.6, 0.4, 0.4, 0.4, 0.2, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.2]
list_of_ca_ours4 = [1.0, 1.0, 1.0, 0.8571428571428571, 0.8571428571428571, 0.7142857142857143, 0.7142857142857143, 0.5714285714285714, 0.7142857142857143, 0.5714285714285714, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.8571428571428571, 1.0, 0.8571428571428571, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.5714285714285714, 0.5714285714285714, 0.7142857142857143, 0.5714285714285714, 0.5714285714285714, 0.42857142857142855, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.42857142857142855, 0.5714285714285714, 0.42857142857142855, 0.42857142857142855, 0.42857142857142855, 0.42857142857142855, 0.42857142857142855, 0.42857142857142855]
list_of_ca_ours = ( np.array(list_of_ca_ours1) + np.array(list_of_ca_ours2) + np.array(list_of_ca_ours3) + np.array(list_of_ca_ours4) ) / 4
list_of_sa_mechanical1 = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.6, 0.6, 0.6, 0.6, 0.4, 0.4, 0.4, 0.4, 0.4, 0.2, 0.4, 0.2, 0.2, 0.2, 0.4, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2]
list_of_sa_mechanical2 = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.6, 0.6, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.6, 0.6, 0.8, 0.8]
list_of_sa_mechanical3 = [1.0, 1.0, 0.8, 0.8, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.6, 0.8, 0.6, 0.6, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4]
list_of_sa_mechanical4 = [1.0, 1.0, 1.0, 1.0, 0.8571428571428571, 1.0, 0.8571428571428571, 0.8571428571428571, 0.8571428571428571, 0.8571428571428571, 0.7142857142857143, 0.8571428571428571, 0.8571428571428571, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.8571428571428571, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.7142857142857143, 0.5714285714285714, 0.5714285714285714, 0.42857142857142855, 0.5714285714285714, 0.5714285714285714, 0.42857142857142855, 0.42857142857142855]
list_of_sa_mechanical = ( np.array(list_of_sa_mechanical1) + np.array(list_of_sa_mechanical2) + np.array(list_of_sa_mechanical3) + np.array(list_of_sa_mechanical4) ) / 4
list_of_ca_mechanical1 = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.6, 0.6, 0.6, 0.2, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.2, 0.2, 0.2, 0.4, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2]
list_of_ca_mechanical2 = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8]
list_of_ca_mechanical3 = [1.0, 1.0, 0.8, 0.8, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.6, 0.6, 0.6, 0.6, 0.4, 0.4, 0.4, 0.6, 0.6, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4]
list_of_ca_mechanical4 = [1.0, 1.0, 1.0, 1.0, 0.8571428571428571, 1.0, 0.8571428571428571, 0.8571428571428571, 0.8571428571428571, 1.0, 1.0, 1.0, 0.8571428571428571, 1.0, 0.7142857142857143, 0.7142857142857143, 0.8571428571428571, 0.8571428571428571, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.5714285714285714, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.5714285714285714, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.7142857142857143, 0.5714285714285714, 0.7142857142857143, 0.5714285714285714, 0.5714285714285714, 0.7142857142857143, 0.7142857142857143, 0.42857142857142855]
list_of_ca_mechanical = ( np.array(list_of_ca_mechanical1) + np.array(list_of_ca_mechanical2) + np.array(list_of_ca_mechanical3) + np.array(list_of_ca_mechanical4) ) / 4
# list_of_sa_mechanical = [1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.6, 0.8, 0.8, 0.8, 0.8, 0.8, 0.6, 0.6, 0.8, 0.6, 0.8, 0.6, 0.6, 0.8, 0.8, 0.8, 0.6, 0.6, 0.6, 0.6, 0.8, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6]
# list_of_ca_mechanical = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.6, 0.8, 0.6, 0.8, 0.8, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.8, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6]
# ---------------------------------------------------------------------------------
# get cumulative accuracy
np_cum_sa = np.cumsum(list_of_sa_ours)
np_cum_mean_sa = np_cum_sa/np_frames
np_cum_ca = np.cumsum(list_of_ca_ours)
np_cum_mean_ca = np_cum_ca/np_frames
np_cum_sa_mechanical = np.cumsum(list_of_sa_mechanical)
np_cum_mean_sa_mechanical = np_cum_sa_mechanical/np_frames
np_cum_ca_mechanical = np.cumsum(list_of_ca_mechanical)
np_cum_mean_ca_mechanical = np_cum_ca_mechanical/np_frames
plt.figure(figsize=(6, 2), dpi=300)
plt.plot(x_range, np_cum_mean_sa, label='Ours (SA$_{.02}$)', color='lawngreen')
plt.plot(x_range, np_cum_mean_ca, label='Ours (CA$_{.01}$)', color='lawngreen', linestyle='dashed')
plt.plot(x_range, np_cum_mean_sa_mechanical, label='Mechanical (SA$_{.02}$)', color='darkorange')
plt.plot(x_range, np_cum_mean_ca_mechanical, label='Mechanical (CA$_{.01}$)', color='darkorange', linestyle='dashed')
plt.xlabel('Frames')
plt.ylabel('CMA')
plt.legend(loc='lower left')
plt.tight_layout()
plt.savefig(f'{plot_dir}/cumulative_accuracy.svg')
| src/uflow_plotting.py | JunbongJang-contour-tracking-1219b66 | [
{
"filename": "src/preprocessing/visualization_utils.py",
"retrieved_chunk": " fig, ax = display_image_in_actual_size(a_img, cmap)\n NUM_COLORS = len(ndarray_points)\n cm = pylab.get_cmap('gist_rainbow')\n for a_key in tracking_points:\n # draw all points\n x, y = tracking_points[a_key]\n ax.plot(x, y, c=np.array([cm(1. * a_key / NUM_COLORS)]), marker='o', linewidth=1, markersize=1)\n fig.savefig(f\"{save_path}/trajectory_{last_image_name}.png\", bbox_inches=\"tight\", pad_inches=0)\n plt.close()\ndef visualize_points_in_frame(a_image_path, ordered_contour_points, save_path, save_name):",
"score": 0.8062549829483032
},
{
"filename": "src/preprocessing/visualization_utils.py",
"retrieved_chunk": " for a_key in tracking_points:\n tracking_points_np[a_key, 0] = tracking_points[a_key][0][image_index]\n tracking_points_np[a_key, 1] = tracking_points[a_key][1][image_index]\n # a_mask = cnt2mask(tracking_points_np, im.shape)\n # cv2.imwrite(f\"{save_path}/cnt2mask_{image_name}.png\", a_mask*255)\n # -------------- draw trajectory of tracking points in the last image --------------------\n last_image_name = get_image_name(last_image_path, image_format)\n ndarray_points = np.loadtxt(f\"{root_path}/{points_path}/{last_image_name}.txt\")\n # set up image\n a_img = plt.imread(last_image_path) # .astype('uint8')",
"score": 0.7982600927352905
},
{
"filename": "src/preprocessing/visualization_utils.py",
"retrieved_chunk": " cur_image = plt.imread(a_image_path)\n plt.imshow(cur_image, cmap='gray')\n cmap = pylab.get_cmap('gist_rainbow')\n NUM_COLORS = len(ordered_contour_points)\n for a_index, a_coord in enumerate(ordered_contour_points):\n if a_coord is not None:\n plt.scatter(x=a_coord[0], y=a_coord[1], c=np.array([cmap(1. * a_index / NUM_COLORS)]), s=1)\n if not os.path.exists(f\"{save_path}\"):\n os.mkdir(f\"{save_path}\")\n # save figure",
"score": 0.7969292402267456
},
{
"filename": "src/preprocessing/contour_tracking_manuscript_figures.py",
"retrieved_chunk": " contour_points = np.loadtxt(a_contour_points_path)\n contour_points = contour_points.astype('int32')\n # contour_points = contour_points[first_contour_index:last_contour_index,:]\n # a_color = np.array([contour_cmap(1. * (cur_frame-initial_frame) / total_frames)])\n # for point_index, a_point in enumerate(contour_points):\n # a_col, a_row = a_point\n # plt.scatter(x=a_col, y=a_row, c=a_color, s=1, marker='s',linewidths=1, antialiased=True)\n if not arrow_plot:\n a_image = plt.imread(img_path_list[cur_frame +1])\n plt.imshow(a_image, cmap='gray')",
"score": 0.7965391278266907
},
{
"filename": "src/preprocessing/visualization_utils.py",
"retrieved_chunk": " # TODO: is it ok to ignore these points going outside the image?\n if x >= 0 and y >= 0 and x < im.shape[1] and y < im.shape[0]:\n plt.scatter(x=x, y=y, c=np.array([cm(1. * a_index / MAX_NUM_POINTS)]), s=10)\n tracking_points[a_index][0].append(x)\n tracking_points[a_index][1].append(y)\n plt.axis('off')\n plt.savefig(f\"{save_path}/{image_name}.png\", bbox_inches=\"tight\", pad_inches=0)\n plt.close()\n # --------- Visualize contour points as mask -----------------\n tracking_points_np = np.zeros((len(tracking_points), 2))",
"score": 0.7865961194038391
}
] | python | resample_np(image2, a_warp) |
from urllib.parse import quote
import pytest
from databasez import DatabaseURL
def test_database_url_repr():
u = DatabaseURL("postgresql://localhost/name")
assert repr(u) == "DatabaseURL('postgresql://localhost/name')"
u = DatabaseURL("postgresql://username@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username@localhost/name')"
u = DatabaseURL("postgresql://username:password@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username:********@localhost/name')"
u = DatabaseURL(f"postgresql://username:{quote('[password')}@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username:********@localhost/name')"
def test_database_url_properties():
u = DatabaseURL("postgresql+asyncpg://username:password@localhost:123/mydatabase")
assert u.dialect == "postgresql"
assert u.driver == "asyncpg"
assert u.username == "username"
assert u.password == "password"
assert u. | hostname == "localhost" |
assert u.port == 123
assert u.database == "mydatabase"
u = DatabaseURL(
"postgresql://username:password@/mydatabase?host=/var/run/postgresql/.s.PGSQL.5432"
)
assert u.dialect == "postgresql"
assert u.username == "username"
assert u.password == "password"
assert u.hostname == "/var/run/postgresql/.s.PGSQL.5432"
assert u.database == "mydatabase"
u = DatabaseURL(
"postgresql://username:password@/mydatabase?unix_sock=/var/run/postgresql/.s.PGSQL.5432"
)
assert u.hostname == "/var/run/postgresql/.s.PGSQL.5432"
def test_database_url_escape():
u = DatabaseURL(f"postgresql://username:{quote('[password')}@localhost/mydatabase")
assert u.username == "username"
assert u.password == "[password"
assert u.userinfo == f"username:{quote('[password')}".encode("utf-8")
u2 = DatabaseURL(u)
assert u2.password == "[password"
u3 = DatabaseURL(str(u))
assert u3.password == "[password"
def test_database_url_constructor():
with pytest.raises(TypeError):
DatabaseURL(("postgresql", "username", "password", "localhost", "mydatabase"))
u = DatabaseURL("postgresql+asyncpg://username:password@localhost:123/mydatabase")
assert DatabaseURL(u) == u
def test_database_url_options():
u = DatabaseURL("postgresql://localhost/mydatabase?pool_size=20&ssl=true")
assert u.options == {"pool_size": "20", "ssl": "true"}
u = DatabaseURL("mysql+asyncmy://username/testsuite?unix_socket=/tmp/mysqld/mysqld.sock")
assert u.options == {"unix_socket": "/tmp/mysqld/mysqld.sock"}
def test_replace_database_url_components():
u = DatabaseURL("postgresql://localhost/mydatabase")
assert u.database == "mydatabase"
new = u.replace(database="test_" + u.database)
assert new.database == "test_mydatabase"
assert str(new) == "postgresql://localhost/test_mydatabase"
assert u.driver == ""
new = u.replace(driver="asyncpg")
assert new.driver == "asyncpg"
assert str(new) == "postgresql+asyncpg://localhost/mydatabase"
assert u.port is None
new = u.replace(port=123)
assert new.port == 123
assert str(new) == "postgresql://localhost:123/mydatabase"
assert u.username is None
assert u.userinfo is None
u = DatabaseURL("sqlite:///mydatabase")
assert u.database == "mydatabase"
new = u.replace(database="test_" + u.database)
assert new.database == "test_mydatabase"
assert str(new) == "sqlite:///test_mydatabase"
u = DatabaseURL("sqlite:////absolute/path")
assert u.database == "/absolute/path"
new = u.replace(database=u.database + "_test")
assert new.database == "/absolute/path_test"
assert str(new) == "sqlite:////absolute/path_test"
| tests/test_database_url.py | tarsil-databasez-01b23b0 | [
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " data = {\"config\": database_url}\n async with Database(**data) as database:\n assert isinstance(database.url, DatabaseURL)\n if isinstance(database_url, str):\n assert database.url == database_url\n@pytest.mark.parametrize(\"database_url\", DATABASE_URLS)\n@async_adapter\nasync def test_concurrent_access_on_single_connection(database_url):\n database_url = DatabaseURL(database_url)\n if database_url.dialect != \"postgresql\":",
"score": 0.853700578212738
},
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " data = {\"config\": database_url}\n database = Database(**data)\n assert not database.is_connected\n await database.connect()\n assert database.is_connected\n await database.disconnect()\n assert not database.is_connected\n # connect and disconnect idempotence\n await database.connect()\n await database.connect()",
"score": 0.8482851982116699
},
{
"filename": "databasez/core.py",
"retrieved_chunk": " await self._connection.__aexit__()\n self._transaction = None\nclass _EmptyNetloc(str):\n def __bool__(self) -> bool:\n return True\nclass DatabaseURL:\n def __init__(self, url: typing.Union[str, \"DatabaseURL\"]):\n if isinstance(url, DatabaseURL):\n self._url: str = url._url\n elif isinstance(url, str):",
"score": 0.8457156419754028
},
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " database_url = database_url[0]\n if isinstance(database_url, str):\n data = {\"url\": database_url}\n else:\n data = {\"config\": database_url}\n async with Database(**data) as database:\n async with database.transaction(force_rollback=True):\n query = \"SELECT 1 AS id, 2 AS id\"\n row = await database.fetch_one(query=query)\n assert list(row._mapping.keys()) == [\"id\", \"id\"]",
"score": 0.8448054194450378
},
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " database_url = database_url[0]\n if isinstance(database_url, str):\n data = {\"url\": database_url}\n else:\n data = {\"config\": database_url}\n async with Database(**data) as database:\n async with database.connection() as connection_1:\n async with database.connection() as connection_2:\n assert connection_1 is connection_2\n async with Database(**data) as database:",
"score": 0.8433834314346313
}
] | python | hostname == "localhost" |
from urllib.parse import quote
import pytest
from databasez import DatabaseURL
def test_database_url_repr():
u = DatabaseURL("postgresql://localhost/name")
assert repr(u) == "DatabaseURL('postgresql://localhost/name')"
u = DatabaseURL("postgresql://username@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username@localhost/name')"
u = DatabaseURL("postgresql://username:password@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username:********@localhost/name')"
u = DatabaseURL(f"postgresql://username:{quote('[password')}@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username:********@localhost/name')"
def test_database_url_properties():
u = DatabaseURL("postgresql+asyncpg://username:password@localhost:123/mydatabase")
assert u.dialect == "postgresql"
assert u.driver == "asyncpg"
assert u.username == "username"
assert u.password == "password"
assert u.hostname == "localhost"
assert u.port == 123
assert u.database == "mydatabase"
u = DatabaseURL(
"postgresql://username:password@/mydatabase?host=/var/run/postgresql/.s.PGSQL.5432"
)
assert u.dialect == "postgresql"
assert u.username == "username"
assert u.password == "password"
assert u.hostname == "/var/run/postgresql/.s.PGSQL.5432"
assert u.database == "mydatabase"
u = DatabaseURL(
"postgresql://username:password@/mydatabase?unix_sock=/var/run/postgresql/.s.PGSQL.5432"
)
assert u.hostname == "/var/run/postgresql/.s.PGSQL.5432"
def test_database_url_escape():
u = DatabaseURL(f"postgresql://username:{quote('[password')}@localhost/mydatabase")
assert u.username == "username"
assert u.password == "[password"
assert u. | userinfo == f"username:{quote('[password')}".encode("utf-8") |
u2 = DatabaseURL(u)
assert u2.password == "[password"
u3 = DatabaseURL(str(u))
assert u3.password == "[password"
def test_database_url_constructor():
with pytest.raises(TypeError):
DatabaseURL(("postgresql", "username", "password", "localhost", "mydatabase"))
u = DatabaseURL("postgresql+asyncpg://username:password@localhost:123/mydatabase")
assert DatabaseURL(u) == u
def test_database_url_options():
u = DatabaseURL("postgresql://localhost/mydatabase?pool_size=20&ssl=true")
assert u.options == {"pool_size": "20", "ssl": "true"}
u = DatabaseURL("mysql+asyncmy://username/testsuite?unix_socket=/tmp/mysqld/mysqld.sock")
assert u.options == {"unix_socket": "/tmp/mysqld/mysqld.sock"}
def test_replace_database_url_components():
u = DatabaseURL("postgresql://localhost/mydatabase")
assert u.database == "mydatabase"
new = u.replace(database="test_" + u.database)
assert new.database == "test_mydatabase"
assert str(new) == "postgresql://localhost/test_mydatabase"
assert u.driver == ""
new = u.replace(driver="asyncpg")
assert new.driver == "asyncpg"
assert str(new) == "postgresql+asyncpg://localhost/mydatabase"
assert u.port is None
new = u.replace(port=123)
assert new.port == 123
assert str(new) == "postgresql://localhost:123/mydatabase"
assert u.username is None
assert u.userinfo is None
u = DatabaseURL("sqlite:///mydatabase")
assert u.database == "mydatabase"
new = u.replace(database="test_" + u.database)
assert new.database == "test_mydatabase"
assert str(new) == "sqlite:///test_mydatabase"
u = DatabaseURL("sqlite:////absolute/path")
assert u.database == "/absolute/path"
new = u.replace(database=u.database + "_test")
assert new.database == "/absolute/path_test"
assert str(new) == "sqlite:////absolute/path_test"
| tests/test_database_url.py | tarsil-databasez-01b23b0 | [
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " data = {\"config\": database_url}\n async with Database(**data) as database:\n assert isinstance(database.url, DatabaseURL)\n if isinstance(database_url, str):\n assert database.url == database_url\n@pytest.mark.parametrize(\"database_url\", DATABASE_URLS)\n@async_adapter\nasync def test_concurrent_access_on_single_connection(database_url):\n database_url = DatabaseURL(database_url)\n if database_url.dialect != \"postgresql\":",
"score": 0.8472338318824768
},
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " data = {\"config\": database_url}\n database = Database(**data)\n assert not database.is_connected\n await database.connect()\n assert database.is_connected\n await database.disconnect()\n assert not database.is_connected\n # connect and disconnect idempotence\n await database.connect()\n await database.connect()",
"score": 0.836438775062561
},
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " database_url = database_url[0]\n if isinstance(database_url, str):\n data = {\"url\": database_url}\n else:\n data = {\"config\": database_url}\n async with Database(**data) as database:\n async with database.connection() as connection_1:\n async with database.connection() as connection_2:\n assert connection_1 is connection_2\n async with Database(**data) as database:",
"score": 0.8331051468849182
},
{
"filename": "tests/test_integration.py",
"retrieved_chunk": " \"postgresql+asyncpg\",\n ]:\n url = str(database_url.replace(driver=None))\n elif database_url.scheme in [\n \"mssql\",\n \"mssql+pyodbc\",\n \"mssql+aioodbc\",\n \"mssql+pymssql\",\n ]:\n url = str(database_url.replace(driver=\"pyodbc\"))",
"score": 0.8297653198242188
},
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " database_url = database_url[0]\n if isinstance(database_url, str):\n data = {\"url\": database_url}\n else:\n data = {\"config\": database_url}\n async with Database(**data) as database:\n async with database.transaction(force_rollback=True):\n query = \"SELECT 1 AS id, 2 AS id\"\n row = await database.fetch_one(query=query)\n assert list(row._mapping.keys()) == [\"id\", \"id\"]",
"score": 0.8286514282226562
}
] | python | userinfo == f"username:{quote('[password')}".encode("utf-8") |
# Copyright 2023 Google LLC
#
# 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.
import asyncio
from threading import Thread
from mock import patch
from mocks import FakeAlloyDBClient, FakeCredentials
import pytest
from google.cloud.alloydb.connector import Connector
def test_Connector_init(credentials: FakeCredentials) -> None:
"""
Test to check whether the __init__ method of Connector
properly sets default attributes.
"""
connector = Connector(credentials)
assert connector._quota_project is None
assert connector. | _alloydb_api_endpoint == "https://alloydb.googleapis.com" |
assert connector._client is None
assert connector._credentials == credentials
connector.close()
def test_Connector_context_manager(credentials: FakeCredentials) -> None:
"""
Test to check whether the __init__ method of Connector
properly sets defaults as context manager.
"""
with Connector(credentials) as connector:
assert connector._quota_project is None
assert connector._alloydb_api_endpoint == "https://alloydb.googleapis.com"
assert connector._client is None
assert connector._credentials == credentials
def test_Connector_close(credentials: FakeCredentials) -> None:
"""
Test that Connector's close method stops event loop and
background thread.
"""
with Connector(credentials) as connector:
loop: asyncio.AbstractEventLoop = connector._loop
thread: Thread = connector._thread
assert loop.is_running() is True
assert thread.is_alive() is True
assert loop.is_running() is False
assert thread.is_alive() is False
def test_connect(credentials: FakeCredentials) -> None:
"""
Test that connector.connect returns connection object.
"""
client = FakeAlloyDBClient()
with Connector(credentials) as connector:
connector._client = client
# patch db connection creation
with patch("pg8000.dbapi.connect") as mock_connect:
mock_connect.return_value = True
connection = connector.connect(
"projects/test-project/locations/test-region/clusters/test-cluster/instances/test-instance",
"pg8000",
user="test-user",
password="test-password",
db="test-db",
)
# check connection is returned
assert connection is True
def test_connect_unsupported_driver(credentials: FakeCredentials) -> None:
"""
Test that connector.connect errors with unsupported database driver.
"""
client = FakeAlloyDBClient()
with Connector(credentials) as connector:
connector._client = client
# try to connect using unsupported driver, should raise ValueError
with pytest.raises(ValueError) as exc_info:
connector.connect(
"projects/test-project/locations/test-region/clusters/test-cluster/instances/test-instance",
"bad_driver",
)
# assert custom error message for unsupported driver is present
assert (
exc_info.value.args[0]
== "Driver 'bad_driver' is not a supported database driver."
)
| tests/unit/test_connector.py | GoogleCloudPlatform-alloydb-python-connector-a397ea7 | [
{
"filename": "tests/unit/test_client.py",
"retrieved_chunk": " assert client_cert == \"This is the client cert\"\n assert cert_chain[0] == \"This is the intermediate cert\"\n assert cert_chain[1] == \"This is the root cert\"\n@pytest.mark.asyncio\nasync def test_AlloyDBClient_init_(credentials: FakeCredentials) -> None:\n \"\"\"\n Test to check whether the __init__ method of AlloyDBClient\n can correctly initialize a client.\n \"\"\"\n client = AlloyDBClient(\"www.test-endpoint.com\", \"my-quota-project\", credentials)",
"score": 0.866268515586853
},
{
"filename": "tests/unit/test_client.py",
"retrieved_chunk": " # verify base endpoint is set\n assert client._alloydb_api_endpoint == \"www.test-endpoint.com\"\n # verify proper headers are set\n assert client._client.headers[\"User-Agent\"] == f\"alloydb-python-connector/{version}\"\n assert client._client.headers[\"x-goog-user-project\"] == \"my-quota-project\"\n # close client\n await client.close()",
"score": 0.8303207159042358
},
{
"filename": "google/cloud/alloydb/connector/connector.py",
"retrieved_chunk": " def __init__(\n self,\n credentials: Optional[Credentials] = None,\n quota_project: Optional[str] = None,\n alloydb_api_endpoint: str = \"https://alloydb.googleapis.com\",\n ) -> None:\n # create event loop and start it in background thread\n self._loop: asyncio.AbstractEventLoop = asyncio.new_event_loop()\n self._thread = Thread(target=self._loop.run_forever, daemon=True)\n self._thread.start()",
"score": 0.8109292984008789
},
{
"filename": "google/cloud/alloydb/connector/connector.py",
"retrieved_chunk": " credentials (google.auth.credentials.Credentials):\n A credentials object created from the google-auth Python library.\n If not specified, Application Default Credentials are used.\n quota_project (str): The Project ID for an existing Google Cloud\n project. The project specified is used for quota and\n billing purposes.\n Defaults to None, picking up project from environment.\n alloydb_api_endpoint (str): Base URL to use when calling\n the AlloyDB API endpoint. Defaults to \"https://alloydb.googleapis.com\".\n \"\"\"",
"score": 0.8081638813018799
},
{
"filename": "google/cloud/alloydb/connector/client.py",
"retrieved_chunk": "from google.cloud.alloydb.connector.version import __version__ as version\nif TYPE_CHECKING:\n from cryptography.hazmat.primitives.asymmetric import rsa\n from google.auth.credentials import Credentials\nUSER_AGENT: str = f\"alloydb-python-connector/{version}\"\nAPI_VERSION: str = \"v1beta\"\nlogger = logging.getLogger(name=__name__)\nclass AlloyDBClient:\n def __init__(\n self,",
"score": 0.801939070224762
}
] | python | _alloydb_api_endpoint == "https://alloydb.googleapis.com" |
from urllib.parse import quote
import pytest
from databasez import DatabaseURL
def test_database_url_repr():
u = DatabaseURL("postgresql://localhost/name")
assert repr(u) == "DatabaseURL('postgresql://localhost/name')"
u = DatabaseURL("postgresql://username@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username@localhost/name')"
u = DatabaseURL("postgresql://username:password@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username:********@localhost/name')"
u = DatabaseURL(f"postgresql://username:{quote('[password')}@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username:********@localhost/name')"
def test_database_url_properties():
u = DatabaseURL("postgresql+asyncpg://username:password@localhost:123/mydatabase")
assert u.dialect == "postgresql"
assert u.driver == "asyncpg"
assert u.username == "username"
assert u.password == "password"
assert u.hostname == "localhost"
assert u.port == 123
assert u.database == "mydatabase"
u = DatabaseURL(
"postgresql://username:password@/mydatabase?host=/var/run/postgresql/.s.PGSQL.5432"
)
assert u.dialect == "postgresql"
assert u.username == "username"
assert u.password == "password"
assert u.hostname == "/var/run/postgresql/.s.PGSQL.5432"
assert u.database == "mydatabase"
u = DatabaseURL(
"postgresql://username:password@/mydatabase?unix_sock=/var/run/postgresql/.s.PGSQL.5432"
)
assert u.hostname == "/var/run/postgresql/.s.PGSQL.5432"
def test_database_url_escape():
u = DatabaseURL(f"postgresql://username:{quote('[password')}@localhost/mydatabase")
assert u.username == "username"
assert u.password == "[password"
assert u.userinfo == f"username:{quote('[password')}".encode("utf-8")
u2 = DatabaseURL(u)
assert u2.password == "[password"
u3 = DatabaseURL(str(u))
assert u3.password == "[password"
def test_database_url_constructor():
with pytest.raises(TypeError):
DatabaseURL(("postgresql", "username", "password", "localhost", "mydatabase"))
u = DatabaseURL("postgresql+asyncpg://username:password@localhost:123/mydatabase")
assert DatabaseURL(u) == u
def test_database_url_options():
u = DatabaseURL("postgresql://localhost/mydatabase?pool_size=20&ssl=true")
assert u. | options == {"pool_size": "20", "ssl": "true"} |
u = DatabaseURL("mysql+asyncmy://username/testsuite?unix_socket=/tmp/mysqld/mysqld.sock")
assert u.options == {"unix_socket": "/tmp/mysqld/mysqld.sock"}
def test_replace_database_url_components():
u = DatabaseURL("postgresql://localhost/mydatabase")
assert u.database == "mydatabase"
new = u.replace(database="test_" + u.database)
assert new.database == "test_mydatabase"
assert str(new) == "postgresql://localhost/test_mydatabase"
assert u.driver == ""
new = u.replace(driver="asyncpg")
assert new.driver == "asyncpg"
assert str(new) == "postgresql+asyncpg://localhost/mydatabase"
assert u.port is None
new = u.replace(port=123)
assert new.port == 123
assert str(new) == "postgresql://localhost:123/mydatabase"
assert u.username is None
assert u.userinfo is None
u = DatabaseURL("sqlite:///mydatabase")
assert u.database == "mydatabase"
new = u.replace(database="test_" + u.database)
assert new.database == "test_mydatabase"
assert str(new) == "sqlite:///test_mydatabase"
u = DatabaseURL("sqlite:////absolute/path")
assert u.database == "/absolute/path"
new = u.replace(database=u.database + "_test")
assert new.database == "/absolute/path_test"
assert str(new) == "sqlite:////absolute/path_test"
| tests/test_database_url.py | tarsil-databasez-01b23b0 | [
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " data = {\"config\": database_url}\n async with Database(**data) as database:\n assert isinstance(database.url, DatabaseURL)\n if isinstance(database_url, str):\n assert database.url == database_url\n@pytest.mark.parametrize(\"database_url\", DATABASE_URLS)\n@async_adapter\nasync def test_concurrent_access_on_single_connection(database_url):\n database_url = DatabaseURL(database_url)\n if database_url.dialect != \"postgresql\":",
"score": 0.8649566173553467
},
{
"filename": "tests/test_connection_options.py",
"retrieved_chunk": "from databasez.core import DatabaseURL\ndef test_postgres_pool_size():\n backend = PostgresBackend(\"postgres://localhost/database?min_size=1&max_size=20\")\n kwargs = backend._get_connection_kwargs()\n assert kwargs == {\"min_size\": 1, \"max_size\": 20}\n@async_adapter\nasync def test_postgres_pool_size_connect():\n for url in DATABASE_URLS:\n if DatabaseURL(url).dialect != \"postgresql\":\n continue",
"score": 0.8485065698623657
},
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " database_url = database_url[0]\n if isinstance(database_url, str):\n data = {\"url\": database_url}\n else:\n data = {\"config\": database_url}\n async with Database(**data) as database:\n async with database.connection() as connection_1:\n async with database.connection() as connection_2:\n assert connection_1 is connection_2\n async with Database(**data) as database:",
"score": 0.8476611375808716
},
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " data = {\"config\": database_url}\n database = Database(**data)\n assert not database.is_connected\n await database.connect()\n assert database.is_connected\n await database.disconnect()\n assert not database.is_connected\n # connect and disconnect idempotence\n await database.connect()\n await database.connect()",
"score": 0.8473870754241943
},
{
"filename": "tests/test_connection_options.py",
"retrieved_chunk": " backend = PostgresBackend(url + \"?min_size=1&max_size=20\")\n await backend.connect()\n await backend.disconnect()\ndef test_postgres_explicit_pool_size():\n backend = PostgresBackend(\"postgres://localhost/database\", min_size=1, max_size=20)\n kwargs = backend._get_connection_kwargs()\n assert kwargs == {\"min_size\": 1, \"max_size\": 20}\ndef test_postgres_ssl():\n backend = PostgresBackend(\"postgres://localhost/database?ssl=true\")\n kwargs = backend._get_connection_kwargs()",
"score": 0.8452835083007812
}
] | python | options == {"pool_size": "20", "ssl": "true"} |
# coding=utf-8
# Copyright 2021 The Google Research Authors.
#
# 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.
"""UFlow augmentation.
This library contains various augmentation functions.
"""
# pylint:disable=g-importing-member
from functools import partial
from math import pi
import gin
import gin.tf
import tensorflow as tf
from tensorflow_addons import image as tfa_image
from src import uflow_utils
def apply_augmentation(images, flow=None, mask=None,
crop_height=640, crop_width=640):
"""Applies photometric and geometric augmentations to images and flow."""
# ensure sequence length of two, to be able to unstack images
images = tf.ensure_shape(images, (2, None, None, None))
# apply geometric augmentation functions
images, flow, mask = geometric_augmentation(
images, flow, mask, crop_height, crop_width)
# apply photometric augmentation functions
images_aug = photometric_augmentation(images)
# return flow and mask if available
if flow is not None:
return images_aug, images, flow, mask
return images_aug, images
@gin.configurable
def photometric_augmentation(images,
augment_color_swap=True,
augment_hue_shift=True,
augment_saturation=False,
augment_brightness=False,
augment_contrast=False,
augment_gaussian_noise=False,
augment_brightness_individual=False,
augment_contrast_individual=False,
max_delta_hue=0.5,
min_bound_saturation=0.8,
max_bound_saturation=1.2,
max_delta_brightness=0.1,
min_bound_contrast=0.8,
max_bound_contrast=1.2,
min_bound_gaussian_noise=0.0,
max_bound_gaussian_noise=0.02,
max_delta_brightness_individual=0.02,
min_bound_contrast_individual=0.95,
max_bound_contrast_individual=1.05):
"""Applies photometric augmentations to an image pair."""
# Randomly permute colors by rolling and reversing.
# This covers all permutations.
if augment_color_swap:
r = tf.random.uniform([], maxval=3, dtype=tf.int32)
images = tf.roll(images, r, axis=-1)
r = tf.equal(tf.random.uniform([], maxval=2, dtype=tf.int32), 1)
images = tf.cond(pred=r,
true_fn=lambda: tf.reverse(images, axis=[-1]),
false_fn=lambda: images)
if augment_hue_shift:
images = tf.image.random_hue(images, max_delta_hue)
if augment_saturation:
images = tf.image.random_saturation(
images, min_bound_saturation, max_bound_saturation)
if augment_brightness:
images = tf.image.random_brightness(images, max_delta_brightness)
if augment_contrast:
images = tf.image.random_contrast(
images, min_bound_contrast, max_bound_contrast)
if augment_gaussian_noise:
sigma = tf.random.uniform([],
minval=min_bound_gaussian_noise,
maxval=max_bound_gaussian_noise,
dtype=tf.float32)
noise = tf.random.normal(
tf.shape(input=images), stddev=sigma, dtype=tf.float32)
images = images + noise
# perform relative photometric augmentation (individually per image)
image_1, image_2 = tf.unstack(images)
if augment_brightness_individual:
image_1 = tf.image.random_contrast(
image_1, min_bound_contrast_individual, max_bound_contrast_individual)
image_2 = tf.image.random_contrast(
image_2, min_bound_contrast_individual, max_bound_contrast_individual)
if augment_contrast_individual:
image_1 = tf.image.random_brightness(
image_1, max_delta_brightness_individual)
image_2 = tf.image.random_brightness(
image_2, max_delta_brightness_individual)
# crop values to ensure values in [0,1] (some augmentations can violate this)
image_1 = tf.clip_by_value(image_1, 0.0, 1.0)
image_2 = tf.clip_by_value(image_2, 0.0, 1.0)
return tf.stack([image_1, image_2])
@gin.configurable
def geometric_augmentation(images,
flow=None,
mask=None,
crop_height=640,
crop_width=640,
augment_flip_left_right=False,
augment_flip_up_down=False,
augment_scale=False,
augment_relative_scale=False,
augment_rotation=False,
augment_relative_rotation=False,
augment_crop_offset=False,
min_bound_scale=0.9,
max_bound_scale=1.5,
min_bound_relative_scale=0.95,
max_bound_relative_scale=1.05,
max_rotation_deg=15,
max_relative_rotation_deg=3,
max_relative_crop_offset=5):
"""Apply geometric augmentations to an image pair and corresponding flow."""
# apply geometric augmentation
if augment_flip_left_right:
images, flow, mask = random_flip_left_right(images, flow, mask)
if augment_flip_up_down:
images, flow, mask = random_flip_up_down(images, flow, mask)
if augment_scale:
images, flow, mask = random_scale(
images,
flow,
mask,
min_scale=min_bound_scale,
max_scale=max_bound_scale)
if augment_relative_scale:
images, flow, mask = random_scale_second(
images, flow, mask,
min_scale=min_bound_relative_scale, max_scale=max_bound_relative_scale)
if augment_rotation:
images, flow, mask = random_rotation(
images, flow, mask,
max_rotation=max_rotation_deg, not_empty_crop=True)
if augment_relative_rotation:
images, flow, mask = random_rotation_second(
images, flow, mask,
max_rotation=max_relative_rotation_deg, not_empty_crop=True)
# always perform random cropping
if not augment_crop_offset:
max_relative_crop_offset = 0
images, flow, mask = random_crop(
images, flow, mask, crop_height, crop_width,
relative_offset=max_relative_crop_offset)
# return flow and mask if available
return images, flow, mask
def _center_crop(images, height, width):
"""Performs a center crop with the given heights and width."""
# ensure height, width to be int
height = tf.cast(height, tf.int32)
width = tf.cast(width, tf.int32)
# get current size
images_shape = tf.shape(images)
current_height = images_shape[-3]
current_width = images_shape[-2]
# compute required offset
offset_height = tf.cast((current_height - height) / 2, tf.int32)
offset_width = tf.cast((current_width - width) / 2, tf.int32)
# perform the crop
images = tf.image.crop_to_bounding_box(
images, offset_height, offset_width, height, width)
return images
def _positions_center_origin(height, width):
"""Returns image coordinates where the origin at the image center."""
h = tf.range(0.0, height, 1)
w = tf.range(0.0, width, 1)
center_h = tf.cast(height, tf.float32) / 2.0 - 0.5
center_w = tf.cast(width, tf.float32) / 2.0 - 0.5
return tf.stack(tf.meshgrid(h - center_h, w - center_w, indexing='ij'), -1)
def rotate(img, angle_radian, is_flow, mask=None):
"""Rotate an image or flow field."""
def _rotate(img, mask=None):
if angle_radian == 0.0:
# early return if no resizing is required
if mask is not None:
return img, mask
else:
return img
if mask is not None:
# multiply with mask, to ensure non-valid locations are zero
img = tf.math.multiply(img, mask)
# rotate img
img_rotated = tfa_image.rotate(
img, angle_radian, interpolation='BILINEAR')
# rotate mask (will serve as normalization weights)
mask_rotated = tfa_image.rotate(
mask, angle_radian, interpolation='BILINEAR')
# normalize sparse flow field and mask
img_rotated = tf.math.multiply(
img_rotated, tf.math.reciprocal_no_nan(mask_rotated))
mask_rotated = tf.math.multiply(
mask_rotated, tf.math.reciprocal_no_nan(mask_rotated))
else:
img_rotated = tfa_image.rotate(
img, angle_radian, interpolation='BILINEAR')
if is_flow:
# If image is a flow image, scale flow values to be consistent with the
# rotation.
cos = tf.math.cos(angle_radian)
sin = tf.math.sin(angle_radian)
rotation_matrix = tf.reshape([cos, sin, -sin, cos], [2, 2])
img_rotated = tf.linalg.matmul(img_rotated, rotation_matrix)
if mask is not None:
return img_rotated, mask_rotated
return img_rotated
# Apply resizing at the right shape.
shape = img.shape.as_list()
if len(shape) == 3:
if mask is not None:
img_rotated, mask_rotated = _rotate(img[None], mask[None])
return img_rotated[0], mask_rotated[0]
else:
return _rotate(img[None])[0]
elif len(shape) == 4:
# Input at the right shape.
return _rotate(img, mask)
else:
raise ValueError('Cannot rotate an image of shape', shape)
def random_flip_left_right(images, flow=None, mask=None):
"""Performs a random left/right flip."""
# 50/50 chance
perform_flip = tf.equal(tf.random.uniform([], maxval=2, dtype=tf.int32), 1)
# apply flip
images = tf.cond(pred=perform_flip,
true_fn=lambda: tf.reverse(images, axis=[-2]),
false_fn=lambda: images)
if flow is not None:
flow = tf.cond(pred=perform_flip,
true_fn=lambda: tf.reverse(flow, axis=[-2]),
false_fn=lambda: flow)
mask = tf.cond(pred=perform_flip,
true_fn=lambda: tf.reverse(mask, axis=[-2]),
false_fn=lambda: mask)
# correct sign of flow
sign_correction = tf.reshape([1.0, -1.0], [1, 1, 2])
flow = tf.cond(pred=perform_flip,
true_fn=lambda: flow * sign_correction,
false_fn=lambda: flow)
return images, flow, mask
def random_flip_up_down(images, flow=None, mask=None):
"""Performs a random up/down flip."""
# 50/50 chance
perform_flip = tf.equal(tf.random.uniform([], maxval=2, dtype=tf.int32), 1)
# apply flip
images = tf.cond(pred=perform_flip,
true_fn=lambda: tf.reverse(images, axis=[-3]),
false_fn=lambda: images)
if flow is not None:
flow = tf.cond(pred=perform_flip,
true_fn=lambda: tf.reverse(flow, axis=[-3]),
false_fn=lambda: flow)
mask = tf.cond(pred=perform_flip,
true_fn=lambda: tf.reverse(mask, axis=[-3]),
false_fn=lambda: mask)
# correct sign of flow
sign_correction = tf.reshape([-1.0, 1.0], [1, 1, 2])
flow = tf.cond(pred=perform_flip,
true_fn=lambda: flow * sign_correction,
false_fn=lambda: flow)
return images, flow, mask
def random_scale(images, flow=None, mask=None, min_scale=1.0, max_scale=1.0):
"""Performs a random scaling in the given range."""
# choose a random scale factor and compute new resolution
orig_height = tf.shape(images)[-3]
orig_width = tf.shape(images)[-2]
scale = tf.random.uniform([],
minval=min_scale,
maxval=max_scale,
dtype=tf.float32)
new_height = tf.cast(
tf.math.ceil(tf.cast(orig_height, tf.float32) * scale), tf.int32)
new_width = tf.cast(
tf.math.ceil(tf.cast(orig_width, tf.float32) * scale), tf.int32)
# rescale the images (and flow)
images = uflow_utils. | resize(images, new_height, new_width, is_flow=False) |
if flow is not None:
flow, mask = uflow_utils.resize(
flow, new_height, new_width, is_flow=True, mask=mask)
return images, flow, mask
def random_scale_second(
images, flow=None, mask=None, min_scale=1.0, max_scale=1.0):
"""Performs a random scaling on the second image in the given range."""
# choose a random scale factor and compute new resolution
orig_height = tf.shape(images)[-3]
orig_width = tf.shape(images)[-2]
scale = tf.random.uniform(
[], minval=min_scale, maxval=max_scale, dtype=tf.float32)
new_height = tf.cast(
tf.math.ceil(tf.cast(orig_height, tf.float32) * scale), tf.int32)
new_width = tf.cast(
tf.math.ceil(tf.cast(orig_width, tf.float32) * scale), tf.int32)
# rescale only the second image
image_1, image_2 = tf.unstack(images)
image_2 = uflow_utils.resize(image_2, new_height, new_width, is_flow=False)
# crop either first or second image to have matching dimensions
if scale < 1.0:
image_1 = _center_crop(image_1, new_height, new_width)
else:
image_2 = _center_crop(image_2, orig_height, orig_width)
images = tf.stack([image_1, image_2])
if flow is not None:
# get current locations (with the origin in the image center)
positions = _positions_center_origin(orig_height, orig_width)
# compute scale factor of the actual new image resolution
scale_flow_h = tf.cast(new_height, tf.float32) / tf.cast(
orig_height, tf.float32)
scale_flow_w = tf.cast(new_width, tf.float32) / tf.cast(
orig_width, tf.float32)
scale_flow = tf.stack([scale_flow_h, scale_flow_w])
# compute augmented flow (multiply by mask to zero invalid flow locations)
flow = ((positions + flow) * scale_flow - positions) * mask
if scale < 1.0:
# in case we downsample the image we crop the reference image to keep the
# same shape
flow = _center_crop(flow, new_height, new_width)
mask = _center_crop(mask, new_height, new_width)
return images, flow, mask
def random_crop(images, flow=None, mask=None, crop_height=None, crop_width=None,
relative_offset=0):
"""Performs a random crop with the given height and width."""
# early return if crop_height or crop_width is not specified
if crop_height is None or crop_width is None:
return images, flow, mask
orig_height = tf.shape(images)[-3]
orig_width = tf.shape(images)[-2]
# check if crop size fits the image size
scale = 1.0
ratio = tf.cast(crop_height, tf.float32) / tf.cast(orig_height, tf.float32)
scale = tf.math.maximum(scale, ratio)
ratio = tf.cast(crop_width, tf.float32) / tf.cast(orig_width, tf.float32)
scale = tf.math.maximum(scale, ratio)
# compute minimum required hight
new_height = tf.cast(
tf.math.ceil(tf.cast(orig_height, tf.float32) * scale), tf.int32)
new_width = tf.cast(
tf.math.ceil(tf.cast(orig_width, tf.float32) * scale), tf.int32)
# perform resize (scales with 1 if not required)
images = uflow_utils.resize(images, new_height, new_width, is_flow=False)
# compute joint offset
max_offset_h = new_height - tf.cast(crop_height, dtype=tf.int32)
max_offset_w = new_width - tf.cast(crop_width, dtype=tf.int32)
joint_offset_h = tf.random.uniform([], maxval=max_offset_h+1, dtype=tf.int32)
joint_offset_w = tf.random.uniform([], maxval=max_offset_w+1, dtype=tf.int32)
# compute relative offset
min_relative_offset_h = tf.math.maximum(
joint_offset_h - relative_offset, 0)
max_relative_offset_h = tf.math.minimum(
joint_offset_h + relative_offset, max_offset_h)
min_relative_offset_w = tf.math.maximum(
joint_offset_w - relative_offset, 0)
max_relative_offset_w = tf.math.minimum(
joint_offset_w + relative_offset, max_offset_w)
relative_offset_h = tf.random.uniform(
[], minval=min_relative_offset_h, maxval=max_relative_offset_h+1,
dtype=tf.int32)
relative_offset_w = tf.random.uniform(
[], minval=min_relative_offset_w, maxval=max_relative_offset_w+1,
dtype=tf.int32)
# crop both images
image_1, image_2 = tf.unstack(images)
image_1 = tf.image.crop_to_bounding_box(
image_1, offset_height=joint_offset_h, offset_width=joint_offset_w,
target_height=crop_height, target_width=crop_width)
image_2 = tf.image.crop_to_bounding_box(
image_2, offset_height=relative_offset_h, offset_width=relative_offset_w,
target_height=crop_height, target_width=crop_width)
images = tf.stack([image_1, image_2])
if flow is not None:
# perform resize (scales with 1 if not required)
flow, mask = uflow_utils.resize(
flow, new_height, new_width, is_flow=True, mask=mask)
# crop flow and mask
flow = tf.image.crop_to_bounding_box(
flow,
offset_height=joint_offset_h,
offset_width=joint_offset_w,
target_height=crop_height,
target_width=crop_width)
mask = tf.image.crop_to_bounding_box(
mask,
offset_height=joint_offset_h,
offset_width=joint_offset_w,
target_height=crop_height,
target_width=crop_width)
# correct flow for relative shift (/crop)
flow_delta = tf.stack(
[tf.cast(relative_offset_h - joint_offset_h, tf.float32),
tf.cast(relative_offset_w - joint_offset_w, tf.float32)])
flow = (flow - flow_delta) * mask
return images, flow, mask
def random_rotation(
images, flow=None, mask=None, max_rotation=10, not_empty_crop=True):
"""Performs a random rotation with the specified maximum rotation."""
angle_radian = tf.random.uniform(
[], minval=-max_rotation, maxval=max_rotation,
dtype=tf.float32) * pi / 180.0
images = rotate(images, angle_radian, is_flow=False, mask=None)
if not_empty_crop:
orig_height = tf.shape(images)[-3]
orig_width = tf.shape(images)[-2]
# introduce abbreviations for shorter notation
cos = tf.math.cos(angle_radian % pi)
sin = tf.math.sin(angle_radian % pi)
h = tf.cast(orig_height, tf.float32)
w = tf.cast(orig_width, tf.float32)
# compute required scale factor
scale = tf.cond(tf.math.less(angle_radian % pi, pi/2.0),
lambda: tf.math.maximum((w/h)*sin+cos, (h/w)*sin+cos),
lambda: tf.math.maximum((w/h)*sin-cos, (h/w)*sin-cos))
new_height = tf.math.floor(h / scale)
new_width = tf.math.floor(w / scale)
# crop image again to original size
offset_height = tf.cast((h - new_height) / 2, tf.int32)
offset_width = tf.cast((w - new_width) / 2, tf.int32)
images = tf.image.crop_to_bounding_box(
images,
offset_height=offset_height,
offset_width=offset_width,
target_height=tf.cast(new_height, tf.int32),
target_width=tf.cast(new_width, tf.int32))
if flow is not None:
flow, mask = rotate(flow, angle_radian, is_flow=True, mask=mask)
if not_empty_crop:
# crop flow and mask again to original size
flow = tf.image.crop_to_bounding_box(
flow,
offset_height=offset_height,
offset_width=offset_width,
target_height=tf.cast(new_height, tf.int32),
target_width=tf.cast(new_width, tf.int32))
mask = tf.image.crop_to_bounding_box(
mask,
offset_height=offset_height,
offset_width=offset_width,
target_height=tf.cast(new_height, tf.int32),
target_width=tf.cast(new_width, tf.int32))
return images, flow, mask
def random_rotation_second(
images, flow=None, mask=None, max_rotation=10, not_empty_crop=True):
"""Performs a random rotation on only the second image."""
angle_radian = tf.random.uniform(
[], minval=-max_rotation, maxval=max_rotation, dtype=tf.float32)*pi/180.0
image_1, image_2 = tf.unstack(images)
image_2 = rotate(image_2, angle_radian, is_flow=False, mask=None)
images = tf.stack([image_1, image_2])
if not_empty_crop:
orig_height = tf.shape(images)[-3]
orig_width = tf.shape(images)[-2]
# introduce abbreviations for shorter notation
cos = tf.math.cos(angle_radian % pi)
sin = tf.math.sin(angle_radian % pi)
h = tf.cast(orig_height, tf.float32)
w = tf.cast(orig_width, tf.float32)
# compute required scale factor
scale = tf.cond(tf.math.less(angle_radian % pi, pi/2.0),
lambda: tf.math.maximum((w/h)*sin+cos, (h/w)*sin+cos),
lambda: tf.math.maximum((w/h)*sin-cos, (h/w)*sin-cos))
new_height = tf.math.floor(h / scale)
new_width = tf.math.floor(w / scale)
# crop image again to original size
offset_height = tf.cast((h-new_height)/2, tf.int32)
offset_width = tf.cast((w-new_width)/2, tf.int32)
images = tf.image.crop_to_bounding_box(
images,
offset_height=offset_height,
offset_width=offset_width,
target_height=tf.cast(new_height, tf.int32),
target_width=tf.cast(new_width, tf.int32))
if flow is not None:
# get current locations (with the origin in the image center)
positions = _positions_center_origin(orig_height, orig_width)
# compute augmented flow (multiply by mask to zero invalid flow locations)
cos = tf.math.cos(angle_radian)
sin = tf.math.sin(angle_radian)
rotation_matrix = tf.reshape([cos, sin, -sin, cos], [2, 2])
flow = (tf.linalg.matmul((positions+flow), rotation_matrix)-positions)*mask
if not_empty_crop:
# crop flow and mask again to original size
flow = tf.image.crop_to_bounding_box(
flow,
offset_height=offset_height,
offset_width=offset_width,
target_height=tf.cast(new_height, tf.int32),
target_width=tf.cast(new_width, tf.int32))
mask = tf.image.crop_to_bounding_box(
mask,
offset_height=offset_height,
offset_width=offset_width,
target_height=tf.cast(new_height, tf.int32),
target_width=tf.cast(new_width, tf.int32))
return images, flow, mask
def build_selfsup_transformations(num_flow_levels=3,
seq_len=2,
crop_height=0,
crop_width=0,
max_shift_height=0,
max_shift_width=0,
resize=True):
"""Apply augmentations to a list of student images."""
def transform(images, i_or_ij, is_flow, crop_height, crop_width,
shift_heights, shift_widths, resize):
# Expect (i, j) for flows and masks and i for images.
if isinstance(i_or_ij, int):
i = i_or_ij
# Flow needs i and j.
assert not is_flow
else:
i, j = i_or_ij
if is_flow:
shifts = tf.stack([shift_heights, shift_widths], axis=-1)
flow_offset = shifts[i] - shifts[j]
images = images + tf.cast(flow_offset, tf.float32)
shift_height = shift_heights[i]
shift_width = shift_widths[i]
height = images.shape[-3]
width = images.shape[-2]
# Assert that the cropped bounding box does not go out of the image frame.
op1 = tf.compat.v1.assert_greater_equal(crop_height + shift_height, 0)
op2 = tf.compat.v1.assert_greater_equal(crop_width + shift_width, 0)
op3 = tf.compat.v1.assert_less_equal(height - crop_height + shift_height,
height)
op4 = tf.compat.v1.assert_less_equal(width - crop_width + shift_width,
width)
op5 = tf.compat.v1.assert_greater(
height,
2 * crop_height,
message='Image height is too small for cropping.')
op6 = tf.compat.v1.assert_greater(
width, 2 * crop_width, message='Image width is too small for cropping.')
with tf.control_dependencies([op1, op2, op3, op4, op5, op6]):
images = images[:, crop_height + shift_height:height - crop_height +
shift_height, crop_width + shift_width:width -
crop_width + shift_width, :]
if resize:
images = uflow_utils.resize(images, height, width, is_flow=is_flow)
images.set_shape((images.shape[0], height, width, images.shape[3]))
else:
images.set_shape((images.shape[0], height - 2 * crop_height,
width - 2 * crop_width, images.shape[3]))
return images
max_divisor = 2**(num_flow_levels - 1)
assert crop_height % max_divisor == 0
assert crop_width % max_divisor == 0
assert max_shift_height <= crop_height
assert max_shift_width <= crop_width
# Compute random shifts for different images in a sequence.
if max_shift_height > 0 or max_shift_width > 0:
max_rand = max_shift_height // max_divisor
shift_height_at_highest_level = tf.random.uniform([seq_len],
minval=-max_rand,
maxval=max_rand + 1,
dtype=tf.int32)
shift_heights = shift_height_at_highest_level * max_divisor
max_rand = max_shift_height // max_divisor
shift_width_at_highest_level = tf.random.uniform([seq_len],
minval=-max_rand,
maxval=max_rand + 1,
dtype=tf.int32)
shift_widths = shift_width_at_highest_level * max_divisor
transform_fns = []
for level in range(num_flow_levels):
if max_shift_height == 0 and max_shift_width == 0:
shift_heights = [0, 0]
shift_widths = [0, 0]
else:
shift_heights = shift_heights // (2**level)
shift_widths = shift_widths // (2**level)
fn = partial(
transform,
crop_height=crop_height // (2**level),
crop_width=crop_width // (2**level),
shift_heights=shift_heights,
shift_widths=shift_widths,
resize=resize)
transform_fns.append(fn)
assert len(transform_fns) == num_flow_levels
return transform_fns
| src/uflow_augmentation.py | JunbongJang-contour-tracking-1219b66 | [
{
"filename": "src/data/data_utils.py",
"retrieved_chunk": " # check if pre-specified size is given\n if height is None or width is None:\n # If specified size is not feasible with the model, change it to a feasible resolution (used to be ceil, instead of round)\n _num_levels = 5\n divisible_by_num = int(pow(2.0, _num_levels))\n height = tf.math.round(orig_height / divisible_by_num) * divisible_by_num\n width = tf.math.round(orig_width / divisible_by_num) * divisible_by_num\n height = tf.cast(height, 'float32')\n width = tf.cast(width, 'float32')\n images = uflow_utils.resize(images, height, width, is_flow=False)",
"score": 0.8914059400558472
},
{
"filename": "src/uflow_utils.py",
"retrieved_chunk": " if orig_dtype != tf.float32:\n img = tf.cast(img, tf.float32)\n img_resized = tf.compat.v2.image.resize(img,\n (int(height * 2), int(width * 2)))\n if is_flow:\n # Scale flow values to be consistent with the new image size.\n img_resized *= 2\n if img_resized.dtype != orig_dtype:\n return tf.cast(img_resized, orig_dtype)\n return img_resized",
"score": 0.847894549369812
},
{
"filename": "src/data_conversion_scripts/convert_custom_to_tfrecords.py",
"retrieved_chunk": " # new image size.\n scaling = tf.reshape([\n float(height) / tf.cast(orig_height, tf.float32),\n float(width) / tf.cast(orig_width, tf.float32)\n ], [1, 1, 1, 2])\n img_resized *= scaling\n if mask is not None:\n return img_resized, mask_resized\n return img_resized\n # Apply resizing at the right shape.",
"score": 0.8403034210205078
},
{
"filename": "src/data_conversion_scripts/convert_custom_to_tfrecords.py",
"retrieved_chunk": " Resized and potentially scaled image or flow field (and mask).\n \"\"\"\n def _resize(img):\n orig_height = tf.shape(input=img)[1]\n orig_width = tf.shape(input=img)[2]\n if orig_height == height and orig_width == width:\n # early return if no resizing is required\n return img\n # normal resize without anti-alaising\n prev_img_dtype = img.dtype",
"score": 0.8334364295005798
},
{
"filename": "src/uflow_utils.py",
"retrieved_chunk": " # If image is a flow image, scale flow values to be consistent with the\n # new image size.\n scaling = tf.reshape([\n tf.cast(height,'float32') / tf.cast(orig_height, tf.float32),\n tf.cast(width,'float32') / tf.cast(orig_width, tf.float32)\n ], [1, 1, 1, 2])\n img_resized *= scaling\n if mask is not None:\n return img_resized, mask_resized\n return img_resized",
"score": 0.8309068083763123
}
] | python | resize(images, new_height, new_width, is_flow=False) |
# Copyright 2023 Google LLC
#
# 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.
import asyncio
from threading import Thread
from mock import patch
from mocks import FakeAlloyDBClient, FakeCredentials
import pytest
from google.cloud.alloydb.connector import Connector
def test_Connector_init(credentials: FakeCredentials) -> None:
"""
Test to check whether the __init__ method of Connector
properly sets default attributes.
"""
connector = Connector(credentials)
assert connector._quota_project is None
assert connector._alloydb_api_endpoint == "https://alloydb.googleapis.com"
assert connector._client is None
assert connector. | _credentials == credentials |
connector.close()
def test_Connector_context_manager(credentials: FakeCredentials) -> None:
"""
Test to check whether the __init__ method of Connector
properly sets defaults as context manager.
"""
with Connector(credentials) as connector:
assert connector._quota_project is None
assert connector._alloydb_api_endpoint == "https://alloydb.googleapis.com"
assert connector._client is None
assert connector._credentials == credentials
def test_Connector_close(credentials: FakeCredentials) -> None:
"""
Test that Connector's close method stops event loop and
background thread.
"""
with Connector(credentials) as connector:
loop: asyncio.AbstractEventLoop = connector._loop
thread: Thread = connector._thread
assert loop.is_running() is True
assert thread.is_alive() is True
assert loop.is_running() is False
assert thread.is_alive() is False
def test_connect(credentials: FakeCredentials) -> None:
"""
Test that connector.connect returns connection object.
"""
client = FakeAlloyDBClient()
with Connector(credentials) as connector:
connector._client = client
# patch db connection creation
with patch("pg8000.dbapi.connect") as mock_connect:
mock_connect.return_value = True
connection = connector.connect(
"projects/test-project/locations/test-region/clusters/test-cluster/instances/test-instance",
"pg8000",
user="test-user",
password="test-password",
db="test-db",
)
# check connection is returned
assert connection is True
def test_connect_unsupported_driver(credentials: FakeCredentials) -> None:
"""
Test that connector.connect errors with unsupported database driver.
"""
client = FakeAlloyDBClient()
with Connector(credentials) as connector:
connector._client = client
# try to connect using unsupported driver, should raise ValueError
with pytest.raises(ValueError) as exc_info:
connector.connect(
"projects/test-project/locations/test-region/clusters/test-cluster/instances/test-instance",
"bad_driver",
)
# assert custom error message for unsupported driver is present
assert (
exc_info.value.args[0]
== "Driver 'bad_driver' is not a supported database driver."
)
| tests/unit/test_connector.py | GoogleCloudPlatform-alloydb-python-connector-a397ea7 | [
{
"filename": "tests/unit/test_client.py",
"retrieved_chunk": " assert client_cert == \"This is the client cert\"\n assert cert_chain[0] == \"This is the intermediate cert\"\n assert cert_chain[1] == \"This is the root cert\"\n@pytest.mark.asyncio\nasync def test_AlloyDBClient_init_(credentials: FakeCredentials) -> None:\n \"\"\"\n Test to check whether the __init__ method of AlloyDBClient\n can correctly initialize a client.\n \"\"\"\n client = AlloyDBClient(\"www.test-endpoint.com\", \"my-quota-project\", credentials)",
"score": 0.8460670113563538
},
{
"filename": "tests/unit/test_client.py",
"retrieved_chunk": " # verify base endpoint is set\n assert client._alloydb_api_endpoint == \"www.test-endpoint.com\"\n # verify proper headers are set\n assert client._client.headers[\"User-Agent\"] == f\"alloydb-python-connector/{version}\"\n assert client._client.headers[\"x-goog-user-project\"] == \"my-quota-project\"\n # close client\n await client.close()",
"score": 0.8379229307174683
},
{
"filename": "google/cloud/alloydb/connector/connector.py",
"retrieved_chunk": " self._instances: Dict[str, Instance] = {}\n # initialize default params\n self._quota_project = quota_project\n self._alloydb_api_endpoint = alloydb_api_endpoint\n # initialize credentials\n scopes = [\"https://www.googleapis.com/auth/cloud-platform\"]\n if credentials:\n self._credentials = with_scopes_if_required(credentials, scopes=scopes)\n # otherwise use application default credentials\n else:",
"score": 0.8002058267593384
},
{
"filename": "google/cloud/alloydb/connector/connector.py",
"retrieved_chunk": " def __init__(\n self,\n credentials: Optional[Credentials] = None,\n quota_project: Optional[str] = None,\n alloydb_api_endpoint: str = \"https://alloydb.googleapis.com\",\n ) -> None:\n # create event loop and start it in background thread\n self._loop: asyncio.AbstractEventLoop = asyncio.new_event_loop()\n self._thread = Thread(target=self._loop.run_forever, daemon=True)\n self._thread.start()",
"score": 0.7932798862457275
},
{
"filename": "tests/unit/test_instance.py",
"retrieved_chunk": "from google.cloud.alloydb.connector.instance import Instance\nfrom google.cloud.alloydb.connector.refresh import _is_valid, RefreshResult\n@pytest.mark.asyncio\nasync def test_Instance_init() -> None:\n \"\"\"\n Test to check whether the __init__ method of Instance\n can tell if the instance URI that's passed in is formatted correctly.\n \"\"\"\n key = rsa.generate_private_key(public_exponent=65537, key_size=2048)\n async with aiohttp.ClientSession() as client:",
"score": 0.788651168346405
}
] | python | _credentials == credentials |
# Copyright 2023 Google LLC
#
# 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.
import asyncio
from threading import Thread
from mock import patch
from mocks import FakeAlloyDBClient, FakeCredentials
import pytest
from google.cloud.alloydb.connector import Connector
def test_Connector_init(credentials: FakeCredentials) -> None:
"""
Test to check whether the __init__ method of Connector
properly sets default attributes.
"""
connector = Connector(credentials)
assert connector. | _quota_project is None |
assert connector._alloydb_api_endpoint == "https://alloydb.googleapis.com"
assert connector._client is None
assert connector._credentials == credentials
connector.close()
def test_Connector_context_manager(credentials: FakeCredentials) -> None:
"""
Test to check whether the __init__ method of Connector
properly sets defaults as context manager.
"""
with Connector(credentials) as connector:
assert connector._quota_project is None
assert connector._alloydb_api_endpoint == "https://alloydb.googleapis.com"
assert connector._client is None
assert connector._credentials == credentials
def test_Connector_close(credentials: FakeCredentials) -> None:
"""
Test that Connector's close method stops event loop and
background thread.
"""
with Connector(credentials) as connector:
loop: asyncio.AbstractEventLoop = connector._loop
thread: Thread = connector._thread
assert loop.is_running() is True
assert thread.is_alive() is True
assert loop.is_running() is False
assert thread.is_alive() is False
def test_connect(credentials: FakeCredentials) -> None:
"""
Test that connector.connect returns connection object.
"""
client = FakeAlloyDBClient()
with Connector(credentials) as connector:
connector._client = client
# patch db connection creation
with patch("pg8000.dbapi.connect") as mock_connect:
mock_connect.return_value = True
connection = connector.connect(
"projects/test-project/locations/test-region/clusters/test-cluster/instances/test-instance",
"pg8000",
user="test-user",
password="test-password",
db="test-db",
)
# check connection is returned
assert connection is True
def test_connect_unsupported_driver(credentials: FakeCredentials) -> None:
"""
Test that connector.connect errors with unsupported database driver.
"""
client = FakeAlloyDBClient()
with Connector(credentials) as connector:
connector._client = client
# try to connect using unsupported driver, should raise ValueError
with pytest.raises(ValueError) as exc_info:
connector.connect(
"projects/test-project/locations/test-region/clusters/test-cluster/instances/test-instance",
"bad_driver",
)
# assert custom error message for unsupported driver is present
assert (
exc_info.value.args[0]
== "Driver 'bad_driver' is not a supported database driver."
)
| tests/unit/test_connector.py | GoogleCloudPlatform-alloydb-python-connector-a397ea7 | [
{
"filename": "tests/unit/test_client.py",
"retrieved_chunk": " assert client_cert == \"This is the client cert\"\n assert cert_chain[0] == \"This is the intermediate cert\"\n assert cert_chain[1] == \"This is the root cert\"\n@pytest.mark.asyncio\nasync def test_AlloyDBClient_init_(credentials: FakeCredentials) -> None:\n \"\"\"\n Test to check whether the __init__ method of AlloyDBClient\n can correctly initialize a client.\n \"\"\"\n client = AlloyDBClient(\"www.test-endpoint.com\", \"my-quota-project\", credentials)",
"score": 0.8554256558418274
},
{
"filename": "tests/unit/test_client.py",
"retrieved_chunk": " # verify base endpoint is set\n assert client._alloydb_api_endpoint == \"www.test-endpoint.com\"\n # verify proper headers are set\n assert client._client.headers[\"User-Agent\"] == f\"alloydb-python-connector/{version}\"\n assert client._client.headers[\"x-goog-user-project\"] == \"my-quota-project\"\n # close client\n await client.close()",
"score": 0.8170063495635986
},
{
"filename": "google/cloud/alloydb/connector/connector.py",
"retrieved_chunk": " credentials (google.auth.credentials.Credentials):\n A credentials object created from the google-auth Python library.\n If not specified, Application Default Credentials are used.\n quota_project (str): The Project ID for an existing Google Cloud\n project. The project specified is used for quota and\n billing purposes.\n Defaults to None, picking up project from environment.\n alloydb_api_endpoint (str): Base URL to use when calling\n the AlloyDB API endpoint. Defaults to \"https://alloydb.googleapis.com\".\n \"\"\"",
"score": 0.7993135452270508
},
{
"filename": "google/cloud/alloydb/connector/connector.py",
"retrieved_chunk": " def __init__(\n self,\n credentials: Optional[Credentials] = None,\n quota_project: Optional[str] = None,\n alloydb_api_endpoint: str = \"https://alloydb.googleapis.com\",\n ) -> None:\n # create event loop and start it in background thread\n self._loop: asyncio.AbstractEventLoop = asyncio.new_event_loop()\n self._thread = Thread(target=self._loop.run_forever, daemon=True)\n self._thread.start()",
"score": 0.7968822121620178
},
{
"filename": "tests/unit/conftest.py",
"retrieved_chunk": "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\nfrom mocks import (\n FakeCredentials,\n FakeInstance,\n)\nimport pytest\n@pytest.fixture\ndef credentials() -> FakeCredentials:",
"score": 0.7965441942214966
}
] | python | _quota_project is None |
from urllib.parse import quote
import pytest
from databasez import DatabaseURL
def test_database_url_repr():
u = DatabaseURL("postgresql://localhost/name")
assert repr(u) == "DatabaseURL('postgresql://localhost/name')"
u = DatabaseURL("postgresql://username@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username@localhost/name')"
u = DatabaseURL("postgresql://username:password@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username:********@localhost/name')"
u = DatabaseURL(f"postgresql://username:{quote('[password')}@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username:********@localhost/name')"
def test_database_url_properties():
u = DatabaseURL("postgresql+asyncpg://username:password@localhost:123/mydatabase")
assert u. | dialect == "postgresql" |
assert u.driver == "asyncpg"
assert u.username == "username"
assert u.password == "password"
assert u.hostname == "localhost"
assert u.port == 123
assert u.database == "mydatabase"
u = DatabaseURL(
"postgresql://username:password@/mydatabase?host=/var/run/postgresql/.s.PGSQL.5432"
)
assert u.dialect == "postgresql"
assert u.username == "username"
assert u.password == "password"
assert u.hostname == "/var/run/postgresql/.s.PGSQL.5432"
assert u.database == "mydatabase"
u = DatabaseURL(
"postgresql://username:password@/mydatabase?unix_sock=/var/run/postgresql/.s.PGSQL.5432"
)
assert u.hostname == "/var/run/postgresql/.s.PGSQL.5432"
def test_database_url_escape():
u = DatabaseURL(f"postgresql://username:{quote('[password')}@localhost/mydatabase")
assert u.username == "username"
assert u.password == "[password"
assert u.userinfo == f"username:{quote('[password')}".encode("utf-8")
u2 = DatabaseURL(u)
assert u2.password == "[password"
u3 = DatabaseURL(str(u))
assert u3.password == "[password"
def test_database_url_constructor():
with pytest.raises(TypeError):
DatabaseURL(("postgresql", "username", "password", "localhost", "mydatabase"))
u = DatabaseURL("postgresql+asyncpg://username:password@localhost:123/mydatabase")
assert DatabaseURL(u) == u
def test_database_url_options():
u = DatabaseURL("postgresql://localhost/mydatabase?pool_size=20&ssl=true")
assert u.options == {"pool_size": "20", "ssl": "true"}
u = DatabaseURL("mysql+asyncmy://username/testsuite?unix_socket=/tmp/mysqld/mysqld.sock")
assert u.options == {"unix_socket": "/tmp/mysqld/mysqld.sock"}
def test_replace_database_url_components():
u = DatabaseURL("postgresql://localhost/mydatabase")
assert u.database == "mydatabase"
new = u.replace(database="test_" + u.database)
assert new.database == "test_mydatabase"
assert str(new) == "postgresql://localhost/test_mydatabase"
assert u.driver == ""
new = u.replace(driver="asyncpg")
assert new.driver == "asyncpg"
assert str(new) == "postgresql+asyncpg://localhost/mydatabase"
assert u.port is None
new = u.replace(port=123)
assert new.port == 123
assert str(new) == "postgresql://localhost:123/mydatabase"
assert u.username is None
assert u.userinfo is None
u = DatabaseURL("sqlite:///mydatabase")
assert u.database == "mydatabase"
new = u.replace(database="test_" + u.database)
assert new.database == "test_mydatabase"
assert str(new) == "sqlite:///test_mydatabase"
u = DatabaseURL("sqlite:////absolute/path")
assert u.database == "/absolute/path"
new = u.replace(database=u.database + "_test")
assert new.database == "/absolute/path_test"
assert str(new) == "sqlite:////absolute/path_test"
| tests/test_database_url.py | tarsil-databasez-01b23b0 | [
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " data = {\"config\": database_url}\n async with Database(**data) as database:\n assert isinstance(database.url, DatabaseURL)\n if isinstance(database_url, str):\n assert database.url == database_url\n@pytest.mark.parametrize(\"database_url\", DATABASE_URLS)\n@async_adapter\nasync def test_concurrent_access_on_single_connection(database_url):\n database_url = DatabaseURL(database_url)\n if database_url.dialect != \"postgresql\":",
"score": 0.8584764003753662
},
{
"filename": "databasez/core.py",
"retrieved_chunk": " await self._connection.__aexit__()\n self._transaction = None\nclass _EmptyNetloc(str):\n def __bool__(self) -> bool:\n return True\nclass DatabaseURL:\n def __init__(self, url: typing.Union[str, \"DatabaseURL\"]):\n if isinstance(url, DatabaseURL):\n self._url: str = url._url\n elif isinstance(url, str):",
"score": 0.8488413095474243
},
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " data = {\"config\": database_url}\n database = Database(**data)\n assert not database.is_connected\n await database.connect()\n assert database.is_connected\n await database.disconnect()\n assert not database.is_connected\n # connect and disconnect idempotence\n await database.connect()\n await database.connect()",
"score": 0.8458476066589355
},
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " database_url = database_url[0]\n if isinstance(database_url, str):\n data = {\"url\": database_url}\n else:\n data = {\"config\": database_url}\n async with Database(**data) as database:\n async with database.connection() as connection_1:\n async with database.connection() as connection_2:\n assert connection_1 is connection_2\n async with Database(**data) as database:",
"score": 0.8445841073989868
},
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " database_url = database_url[0]\n if isinstance(database_url, str):\n data = {\"url\": database_url}\n else:\n data = {\"config\": database_url}\n async with Database(**data) as database:\n async with database.transaction(force_rollback=True):\n query = \"SELECT 1 AS id, 2 AS id\"\n row = await database.fetch_one(query=query)\n assert list(row._mapping.keys()) == [\"id\", \"id\"]",
"score": 0.8407026529312134
}
] | python | dialect == "postgresql" |
# Copyright 2023 Google LLC
#
# 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.
from __future__ import annotations
import logging
from typing import List, Optional, Tuple, TYPE_CHECKING
import aiohttp
from cryptography.hazmat.primitives import serialization
from google.auth.transport.requests import Request
from google.cloud.alloydb.connector.utils import _create_certificate_request
from google.cloud.alloydb.connector.version import __version__ as version
if TYPE_CHECKING:
from cryptography.hazmat.primitives.asymmetric import rsa
from google.auth.credentials import Credentials
USER_AGENT: str = f"alloydb-python-connector/{version}"
API_VERSION: str = "v1beta"
logger = logging.getLogger(name=__name__)
class AlloyDBClient:
def __init__(
self,
alloydb_api_endpoint: str,
quota_project: Optional[str],
credentials: Credentials,
client: Optional[aiohttp.ClientSession] = None,
) -> None:
"""
Establish the client to be used for AlloyDB Admin API requests.
Args:
alloydb_api_endpoint (str): Base URL to use when calling
the AlloyDB API endpoint.
quota_project (str): The Project ID for an existing Google Cloud
project. The project specified is used for quota and
billing purposes.
credentials (google.auth.credentials.Credentials):
A credentials object created from the google-auth Python library.
Must have the AlloyDB Admin scopes. For more info check out
https://google-auth.readthedocs.io/en/latest/.
client (aiohttp.ClientSession): Async client used to make requests to
AlloyDB Admin APIs.
Optional, defaults to None and creates new client.
"""
headers = {
"x-goog-api-client": USER_AGENT,
"User-Agent": USER_AGENT,
"Content-Type": "application/json",
}
if quota_project:
headers["x-goog-user-project"] = quota_project
self._client = client if client else aiohttp.ClientSession(headers=headers)
self._credentials = credentials
self._alloydb_api_endpoint = alloydb_api_endpoint
async def _get_metadata(
self,
project: str,
region: str,
cluster: str,
name: str,
) -> str:
"""
Fetch the metadata for a given AlloyDB instance.
Call the AlloyDB Admin APIs connectInfo method to retrieve the
information about an AlloyDB instance that is used to create secure
connections.
Args:
project (str): Google Cloud project ID that the AlloyDB instance
resides in.
region (str): Google Cloud region of the AlloyDB instance.
cluster (str): The name of the AlloyDB cluster.
name (str): The name of the AlloyDB instance.
Returns:
str: IP address of the AlloyDB instance.
"""
logger.debug(f"['{project}/{region}/{cluster}/{name}']: Requesting metadata")
if not self._credentials.valid:
request = Request()
self._credentials.refresh(request)
headers = {
"Authorization": f"Bearer {self._credentials.token}",
}
url = f"{self._alloydb_api_endpoint}/{API_VERSION}/projects/{project}/locations/{region}/clusters/{cluster}/instances/{name}/connectionInfo"
resp = await self._client.get(url, headers=headers, raise_for_status=True)
resp_dict = await resp.json()
return resp_dict["ipAddress"]
async def _get_client_certificate(
self,
project: str,
region: str,
cluster: str,
key: rsa.RSAPrivateKey,
) -> Tuple[str, List[str]]:
"""
Fetch a client certificate for the given AlloyDB cluster.
Call the AlloyDB Admin API's generateClientCertificate
method to create a signed TLS certificate that is authorized to connect via the
AlloyDB instance's serverside proxy. The cert is valid for twenty-four hours.
Args:
project (str): Google Cloud project ID that the AlloyDB instance
resides in.
region (str): Google Cloud region of the AlloyDB instance.
cluster (str): The name of the AlloyDB cluster.
key (rsa.RSAPrivateKey): Client private key used in refresh operation
to generate client certificate.
Returns:
Tuple[str, list[str]]: Tuple containing the client certificate
and certificate chain for the AlloyDB instance.
"""
logger.debug(f"['{project}/{region}/{cluster}']: Requesting client certificate")
if not self._credentials.valid:
request = Request()
self._credentials.refresh(request)
headers = {
"Authorization": f"Bearer {self._credentials.token}",
}
url = f"{self._alloydb_api_endpoint}/{API_VERSION}/projects/{project}/locations/{region}/clusters/{cluster}:generateClientCertificate"
# create the certificate signing request
csr = _create_certificate_request(key)
csr_str = csr. | public_bytes(encoding=serialization.Encoding.PEM).decode("utf-8") |
data = {
"pemCsr": csr_str,
"certDuration": "3600s",
}
resp = await self._client.post(
url, headers=headers, json=data, raise_for_status=True
)
resp_dict = await resp.json()
return (resp_dict["pemCertificate"], resp_dict["pemCertificateChain"])
async def close(self) -> None:
"""Close AlloyDBClient gracefully."""
await self._client.close()
| google/cloud/alloydb/connector/client.py | GoogleCloudPlatform-alloydb-python-connector-a397ea7 | [
{
"filename": "google/cloud/alloydb/connector/instance.py",
"retrieved_chunk": " )\n )\n # generate client and CA certs\n certs_task = asyncio.create_task(\n self._client._get_client_certificate(\n self._project,\n self._region,\n self._cluster,\n self._key,\n )",
"score": 0.8536419868469238
},
{
"filename": "tests/unit/mocks.py",
"retrieved_chunk": " region: str,\n cluster: str,\n key: rsa.RSAPrivateKey,\n ) -> Tuple[str, List[str]]:\n self.instance.generate_certs()\n root_cert, intermediate_cert, _ = self.instance.get_pem_certs()\n csr = _create_certificate_request(key)\n # build client cert\n client_cert = (\n x509.CertificateBuilder()",
"score": 0.8449791669845581
},
{
"filename": "google/cloud/alloydb/connector/instance.py",
"retrieved_chunk": " to generate client certificate.\n \"\"\"\n def __init__(\n self, instance_uri: str, client: AlloyDBClient, key: rsa.RSAPrivateKey\n ) -> None:\n # validate and parse instance_uri\n instance_uri_split = instance_uri.split(\"/\")\n # should take form \"projects/<PROJECT>/locations/<REGION>/clusters/<CLUSTER>/instances/<INSTANCE>\"\n if len(instance_uri_split) == 8:\n self._instance_uri = instance_uri",
"score": 0.8148385286331177
},
{
"filename": "tests/unit/test_refresh.py",
"retrieved_chunk": " key = rsa.generate_private_key(public_exponent=65537, key_size=2048)\n fake_instance.generate_certs()\n root_cert, intermediate_cert, _ = fake_instance.get_pem_certs()\n csr = _create_certificate_request(key)\n # build client cert\n client_cert = (\n x509.CertificateBuilder()\n .subject_name(csr.subject)\n .issuer_name(fake_instance.intermediate_cert.issuer)\n .public_key(csr.public_key())",
"score": 0.8141523599624634
},
{
"filename": "tests/unit/test_instance.py",
"retrieved_chunk": " instance = Instance(\n \"projects/test-project/locations/test-region/clusters/test-cluster/instances/test-instance\",\n client,\n key,\n )\n # check current refresh is valid\n assert await _is_valid(instance._current) is True\n current_refresh = instance._current\n # set certificate to be expired\n client.instance.cert_before = datetime.now() - timedelta(minutes=20)",
"score": 0.80850750207901
}
] | python | public_bytes(encoding=serialization.Encoding.PEM).decode("utf-8") |
import getpass
import logging
import typing
import uuid
import aioodbc
import pyodbc as ext_pyodbc
from sqlalchemy.dialects.mssql import pyodbc
from sqlalchemy.engine.cursor import CursorResultMetaData
from sqlalchemy.engine.interfaces import Dialect, ExecutionContext
from sqlalchemy.sql import ClauseElement
from sqlalchemy.sql.ddl import DDLElement
from databasez.backends.common.records import Record, Row, create_column_maps
from databasez.core import LOG_EXTRA, DatabaseURL
from databasez.interfaces import ConnectionBackend, DatabaseBackend
from databasez.interfaces import Record as RecordInterface
from databasez.interfaces import TransactionBackend
logger = logging.getLogger("databasez")
class MSSQLBackend(DatabaseBackend):
def __init__(
self, database_url: typing.Union[DatabaseURL, str], **options: typing.Any
) -> None:
self._database_url = DatabaseURL(database_url)
self._options = options
self._dialect = pyodbc.dialect(paramstyle="pyformat")
self._dialect.supports_native_decimal = True
self._pool: aioodbc.Pool = None
def _get_connection_kwargs(self) -> dict:
url_options = self._database_url.options
kwargs = {}
min_size = url_options.get("min_size")
max_size = url_options.get("max_size")
pool_recycle = url_options.get("pool_recycle")
ssl = url_options.get("ssl")
driver = url_options.get("driver")
timeout = url_options.get("connection_timeout", 30)
trusted_connection = url_options.get("trusted_connection", "no")
assert driver is not None, "The driver must be specified"
if min_size is not None:
kwargs["minsize"] = int(min_size)
if max_size is not None:
kwargs["maxsize"] = int(max_size)
if pool_recycle is not None:
kwargs["pool_recycle"] = int(pool_recycle)
if ssl is not None:
kwargs["ssl"] = {"true": True, "false": False}[ssl.lower()]
kwargs.update(
{
"ignore_no_transaction_on_rollback": True,
"trusted_connection": trusted_connection.lower(),
"timeout": timeout,
"autocommit": True,
"driver": driver,
}
)
for key, value in self._options.items():
# Coerce 'min_size' and 'max_size' for consistency.
if key == "min_size":
key = "minsize"
elif key == "max_size":
key = "maxsize"
kwargs[key] = value
return kwargs
async def connect(self) -> None:
assert self._pool is None, "DatabaseBackend is already running"
kwargs = self._get_connection_kwargs()
driver = kwargs["driver"]
database = self._database_url.database
hostname = self._database_url.hostname
port = self._database_url. | port or 1433 |
user = self._database_url.username or getpass.getuser()
password = self._database_url.password
timeout = kwargs.pop("timeout")
if port:
dsn = f"Driver={driver};Database={database};Server={hostname},{port};UID={user};PWD={password};Connection+Timeout={timeout}"
else:
dsn = f"Driver={driver};Database={database};Server={hostname},{port};UID={user};PWD={password};Connection+Timeout={timeout}"
self._pool = await aioodbc.create_pool(
dsn=dsn,
**kwargs,
)
async def disconnect(self) -> None:
assert self._pool is not None, "DatabaseBackend is not running"
self._pool.close()
pool, self._pool = self._pool, None
await pool.wait_closed()
def connection(self) -> "MSSQLConnection":
return MSSQLConnection(self, self._dialect)
class CompilationContext:
def __init__(self, context: ExecutionContext):
self.context = context
class MSSQLConnection(ConnectionBackend):
def __init__(self, database: MSSQLBackend, dialect: Dialect) -> None:
self._database = database
self._dialect = dialect
self._connection: typing.Optional[aioodbc.Connection] = None
async def acquire(self) -> None:
assert self._connection is None, "Connection is already acquired"
assert self._database._pool is not None, "DatabaseBackend is not running"
self._connection = await self._database._pool.acquire()
async def release(self) -> None:
assert self._connection is not None, "Connection is not acquired"
assert self._database._pool is not None, "DatabaseBackend is not running"
await self._database._pool.release(self._connection)
self._connection = None
async def fetch_all(self, query: ClauseElement) -> typing.List["RecordInterface"]:
assert self._connection is not None, "Connection is not acquired"
query_str, args, result_columns, context = self._compile(query)
column_maps = create_column_maps(result_columns)
dialect = self._dialect
cursor = await self._connection.cursor()
try:
await cursor.execute(query_str, args)
rows = await cursor.fetchall()
metadata = CursorResultMetaData(context, cursor.description)
rows = [
Row(
metadata,
metadata._effective_processors,
metadata._key_to_index,
row,
)
for row in rows
]
return [Record(row, result_columns, dialect, column_maps) for row in rows]
finally:
await cursor.close()
async def fetch_one(self, query: ClauseElement) -> typing.Optional[RecordInterface]:
assert self._connection is not None, "Connection is not acquired"
query_str, args, result_columns, context = self._compile(query)
column_maps = create_column_maps(result_columns)
dialect = self._dialect
cursor = await self._connection.cursor()
try:
await cursor.execute(query_str, args)
row = await cursor.fetchone()
if row is None:
return None
metadata = CursorResultMetaData(context, cursor.description)
row = Row(
metadata,
metadata._effective_processors,
metadata._key_to_index,
row,
)
return Record(row, result_columns, dialect, column_maps)
finally:
await cursor.close()
async def execute(self, query: ClauseElement) -> typing.Any:
assert self._connection is not None, "Connection is not acquired"
query_str, args, _, _ = self._compile(query)
cursor = await self._connection.cursor()
try:
values = await cursor.execute(query_str, args)
try:
values = await values.fetchone()
return values[0]
except Exception:
...
finally:
await cursor.close()
async def execute_many(self, queries: typing.List[ClauseElement]) -> None:
assert self._connection is not None, "Connection is not acquired"
cursor = await self._connection.cursor()
try:
for single_query in queries:
single_query, args, _, _ = self._compile(single_query)
await cursor.execute(single_query, args)
finally:
await cursor.close()
async def iterate(self, query: ClauseElement) -> typing.AsyncGenerator[typing.Any, None]:
assert self._connection is not None, "Connection is not acquired"
query_str, args, result_columns, context = self._compile(query)
column_maps = create_column_maps(result_columns)
dialect = self._dialect
cursor = await self._connection.cursor()
try:
await cursor.execute(query_str, args)
metadata = CursorResultMetaData(context, cursor.description)
async for row in cursor:
record = Row(
metadata,
metadata._effective_processors,
metadata._key_to_index,
row,
)
yield Record(record, result_columns, dialect, column_maps)
finally:
await cursor.close()
def transaction(self) -> TransactionBackend:
return MSSQLTransaction(self)
def _compile(self, query: ClauseElement) -> typing.Tuple[str, list, tuple]:
compiled = query.compile(
dialect=self._dialect, compile_kwargs={"render_postcompile": True}
)
execution_context = self._dialect.execution_ctx_cls()
execution_context.dialect = self._dialect
if not isinstance(query, DDLElement):
compiled_params = compiled.params.items()
mapping = {key: "?" for _, (key, _) in enumerate(compiled_params, start=1)}
compiled_query = compiled.string % mapping
processors = compiled._bind_processors
args = [
processors[key](val) if key in processors else val for key, val in compiled_params
]
execution_context.result_column_struct = (
compiled._result_columns,
compiled._ordered_columns,
compiled._textual_ordered_columns,
compiled._ad_hoc_textual,
compiled._loose_column_name_matching,
)
result_map = compiled._result_columns
else:
compiled_query = compiled.string
args = []
result_map = None
query_message = compiled_query.replace(" \n", " ").replace("\n", " ")
logger.debug("Query: %s Args: %s", query_message, repr(tuple(args)), extra=LOG_EXTRA)
return compiled_query, args, result_map, CompilationContext(execution_context)
@property
def raw_connection(self) -> aioodbc.connection.Connection:
assert self._connection is not None, "Connection is not acquired"
return self._connection
class MSSQLTransaction(TransactionBackend):
def __init__(self, connection: MSSQLConnection):
self._connection = connection
self._is_root = False
self._savepoint_name = ""
async def start(
self, is_root: bool, extra_options: typing.Dict[typing.Any, typing.Any]
) -> None:
assert self._connection._connection is not None, "Connection is not acquired"
self._is_root = is_root
cursor = await self._connection._connection.cursor()
if self._is_root:
await cursor.execute("BEGIN TRANSACTION")
else:
id = str(uuid.uuid4()).replace("-", "_")[:12]
self._savepoint_name = f"STARLETTE_SAVEPOINT_{id}"
try:
await cursor.execute(f"SAVE TRANSACTION {self._savepoint_name}")
finally:
cursor.close()
async def commit(self) -> None:
assert self._connection._connection is not None, "Connection is not acquired"
cursor = await self._connection._connection.cursor()
if self._is_root:
await cursor.execute("COMMIT TRANSACTION")
else:
try:
await cursor.execute(f"COMMIT TRANSACTION {self._savepoint_name}")
finally:
cursor.close()
async def rollback(self) -> None:
assert self._connection._connection is not None, "Connection is not acquired"
cursor = await self._connection._connection.cursor()
if self._is_root:
try:
await cursor.execute("ROLLBACK TRANSACTION")
except ext_pyodbc.ProgrammingError:
logger.error("There is no transaction to rollback")
else:
try:
await cursor.execute(f"ROLLBACK TRANSACTION {self._savepoint_name}")
finally:
cursor.close()
| databasez/backends/mssql.py | tarsil-databasez-01b23b0 | [
{
"filename": "databasez/backends/aiopg.py",
"retrieved_chunk": " # Coerce 'min_size' and 'max_size' for consistency.\n if key == \"min_size\":\n key = \"minsize\"\n elif key == \"max_size\":\n key = \"maxsize\"\n kwargs[key] = value\n return kwargs\n async def connect(self) -> None:\n assert self._pool is None, \"DatabaseBackend is already running\"\n kwargs = self._get_connection_kwargs()",
"score": 0.9460983276367188
},
{
"filename": "databasez/backends/asyncmy.py",
"retrieved_chunk": " return kwargs\n async def connect(self) -> None:\n assert self._pool is None, \"DatabaseBackend is already running\"\n kwargs = self._get_connection_kwargs()\n self._pool = await asyncmy.create_pool(\n host=self._database_url.hostname,\n port=self._database_url.port or 3306,\n user=self._database_url.username or getpass.getuser(),\n password=self._database_url.password,\n db=self._database_url.database,",
"score": 0.9422103762626648
},
{
"filename": "databasez/backends/mysql.py",
"retrieved_chunk": " return kwargs\n async def connect(self) -> None:\n assert self._pool is None, \"DatabaseBackend is already running\"\n kwargs = self._get_connection_kwargs()\n self._pool = await aiomysql.create_pool(\n host=self._database_url.hostname,\n port=self._database_url.port or 3306,\n user=self._database_url.username or getpass.getuser(),\n password=self._database_url.password,\n db=self._database_url.database,",
"score": 0.9354265928268433
},
{
"filename": "databasez/backends/postgres.py",
"retrieved_chunk": " kwargs[\"max_size\"] = int(max_size)\n if ssl is not None:\n kwargs[\"ssl\"] = {\"true\": True, \"false\": False}[ssl.lower()]\n kwargs.update(self._options)\n return kwargs\n async def connect(self) -> None:\n assert self._pool is None, \"DatabaseBackend is already running\"\n kwargs = {\n \"host\": self._database_url.hostname,\n \"port\": self._database_url.port,",
"score": 0.9128507375717163
},
{
"filename": "databasez/backends/postgres.py",
"retrieved_chunk": " \"user\": self._database_url.username,\n \"password\": self._database_url.password,\n \"database\": self._database_url.database,\n }\n kwargs.update(self._get_connection_kwargs())\n self._pool = await asyncpg.create_pool(**kwargs)\n async def disconnect(self) -> None:\n assert self._pool is not None, \"DatabaseBackend is not running\"\n await self._pool.close()\n self._pool = None",
"score": 0.9019434452056885
}
] | python | port or 1433 |
'''
Author: Junbong Jang
Date: 2/7/2022
It loads PC, HACKS, and Jellyfish videos, GT labels, pseudo-labels from Mechanical model, predictions from various contour tracking algorithms.
Then, it draws manuscript figures and evaluate models' performance by spatial and contour accuracy.
'''
import os
import cv2
from glob import glob
import matplotlib.pyplot as plt
import pylab
import numpy as np
from tqdm import tqdm
import shutil
from statistics import mean
import matplotlib as mpl
import scipy.io as sio
import ast
from matplotlib.colors import LinearSegmentedColormap
from visualization_utils import plot_tracking_points, display_image_in_actual_size, get_image_name
from contour_tracking_manuscript_figures import rainbow_contour_pred_only, manuscript_figure1_trajectory, manuscript_figure1, manuscript_figure4_for_jelly, manuscript_figure4, manuscript_figure4_no_GT, manuscript_figure5
def get_ordered_contour_points_from_mask(a_mask):
# find contours without approx
cnts = cv2.findContours(a_mask * 255, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[-2]
# get the max-area contour
cnt = sorted(cnts, key=cv2.contourArea)[-1]
ordered_contour_points = cnt[:, 0, :]
return ordered_contour_points
def remove_points_touching_image_boundary(ordered_contour_points, a_image):
remove_point_indices = []
def is_point_touching_boundary(a_point, a_image):
return a_point[0] == 0 or a_point[0] == a_image.shape[1] - 1 or \
a_point[1] == 0 or a_point[1] == a_image.shape[0] - 1
for point_index, a_point in enumerate(ordered_contour_points):
# a_point is x and y coordinates or column and row
if is_point_touching_boundary(a_point, a_image):
remove_point_indices.append(point_index)
elif point_index > 0 and point_index < ordered_contour_points.shape[0]-1:
# special case where the point is not but left and right points are touching the image boundary
left_point = ordered_contour_points[point_index - 1, :]
right_point = ordered_contour_points[point_index + 1, :]
if is_point_touching_boundary(left_point, a_image) and is_point_touching_boundary(right_point, a_image):
remove_point_indices.append(point_index)
processed_ordered_contour_points = np.delete(ordered_contour_points, remove_point_indices, axis=0)
return processed_ordered_contour_points
def reorder_contour_points(processed_ordered_contour_points, height, width):
# get left_anchor_bool
leftmost_x = np.amin(processed_ordered_contour_points[:,0])
rightmost_x = np.amax(processed_ordered_contour_points[:,0])
bottom_y = np.amax(processed_ordered_contour_points[:,1])
top_y = np.amin(processed_ordered_contour_points[:,1])
if leftmost_x == 0:
# print('left anchor')
# find the index with the least x coordinate (left most point)
least_x_index = np.argmin(processed_ordered_contour_points[:,0])
# reorder by the x coordinate in increasing/decreasing order
processed_ordered_contour_points = np.roll(processed_ordered_contour_points, -least_x_index, axis=0)
elif rightmost_x == width-1:
# print('right_anchor')
max_x_index = np.argmax(processed_ordered_contour_points[:,0])
processed_ordered_contour_points = np.roll(processed_ordered_contour_points, -max_x_index, axis=0)
elif top_y == 0:
# print('top anchor')
min_y_index = np.argmin(processed_ordered_contour_points[:,1])
processed_ordered_contour_points = np.roll(processed_ordered_contour_points, -min_y_index, axis=0)
elif bottom_y == height-1:
# print('bottom anchor')
max_y_index = np.argmax(processed_ordered_contour_points[:,1])
processed_ordered_contour_points = np.roll(processed_ordered_contour_points, -max_y_index, axis=0)
return processed_ordered_contour_points
def save_sampled_tracking_points(contour_points, a_image_name, dataset_folder, save_folder):
if not os.path.exists(f"{root_generated_path}{dataset_folder}/{save_folder}"):
os.mkdir(f"{root_generated_path}{dataset_folder}/{save_folder}")
save_string = ""
for a_coordinate in contour_points:
# saved as x & y coordinates
save_string += str(a_coordinate[0]) + ' ' + str(a_coordinate[1]) + '\n'
with open(f'{root_generated_path}{dataset_folder}/{save_folder}/{a_image_name}.txt', 'w') as f:
f.write(save_string)
def sample_contour_points(root_assets_path, dataset_folder, image_folder, processed_mask_folder, image_format):
'''
Given a mask, get ordered contour points along the boundary of the segmentation mask,
'''
def plot_points(a_img, ordered_contour_points, unit_normal_list, dataset_folder, save_folder, filename):
if len(a_img.shape) == 2:
three_channel_img = np.repeat(a_img[:, :, np.newaxis], 3, axis=2)
fig, ax = display_image_in_actual_size(three_channel_img, cm, blank=False)
NUM_COLORS = len(ordered_contour_points)
for a_index, a_coord in enumerate(ordered_contour_points):
# TODO: is it ok to just ignore it?
if a_coord is not None:
ax.scatter(x=a_coord[0], y=a_coord[1], c=np.array([cm(1. * a_index / NUM_COLORS)]), s=1)
if unit_normal_list is not None:
for a_index, (a_coord, a_normal) in enumerate(zip(ordered_contour_points, unit_normal_list)):
ax.scatter(x=a_coord[0], y=a_coord[1], c=np.array([cm(1. * a_index / NUM_COLORS)]), s=1)
ax.quiver(a_coord[0], a_coord[1], a_normal[0], a_normal[1], angles='xy', scale=15, units="width", width=0.005, color=np.array([cm(1. * a_index / NUM_COLORS)]))
if not os.path.exists(f"{root_generated_path}{dataset_folder}/{save_folder}"):
os.mkdir(f"{root_generated_path}{dataset_folder}/{save_folder}")
fig.savefig(f"{root_generated_path}{dataset_folder}/{save_folder}/{filename}.png", bbox_inches="tight",
pad_inches=0)
plt.close()
if not os.path.exists(root_generated_path + dataset_folder):
os.mkdir(root_generated_path + dataset_folder)
mask_path_list = sorted(glob(f"{root_assets_path}/{dataset_folder}/{processed_mask_folder}/*{image_format}"))
img_path_list = sorted(glob(f"{root_assets_path}/{dataset_folder}/{image_folder}/*{image_format}"))
cm = pylab.get_cmap('gist_rainbow')
number_of_edge_pixels_list = []
total_num_points_list = []
for img_index, (mask_path, img_path) in tqdm(enumerate(zip(mask_path_list, img_path_list))):
a_image_name = get_image_name(mask_path, image_format )
a_image_name = a_image_name. | replace('refined_', '') # to make the name of mask the same as the name of image |
# a_image_name = a_image_name[-3:]
assert a_image_name == get_image_name(img_path, image_format )
a_img = plt.imread(img_path)
a_mask = plt.imread(mask_path).astype('uint8')
# sample all points along the contour with order
ordered_contour_points = get_ordered_contour_points_from_mask(a_mask)
ordered_contour_points = reorder_contour_points(ordered_contour_points, height=a_mask.shape[0], width=a_mask.shape[1])
processed_ordered_contour_points = remove_points_touching_image_boundary(ordered_contour_points, a_mask)
total_num_points_list.append(processed_ordered_contour_points.shape[0])
plot_points(a_img, processed_ordered_contour_points, None, dataset_folder, save_folder='contour_points_visualize', filename=f"{a_image_name}")
save_sampled_tracking_points(processed_ordered_contour_points, a_image_name, dataset_folder, save_folder='contour_points')
total_num_points_array = np.asarray(total_num_points_list)
total_num_point_diff_array = total_num_points_array[1:] - total_num_points_array[:-1]
print('max contour points:', np.amax(total_num_points_array))
print('num_point_diff max', np.amax(total_num_point_diff_array), 'min', np.amin(total_num_point_diff_array))
def convert_GT_tracking_points_to_contour_indices(root_generated_path, dataset_folder):
'''
Convert the ground truth tracking points in x and y coordinates to contour indices along the boundary of the segmentation mask
'''
contour_points_path_list = sorted(glob(f"{root_generated_path}{dataset_folder}/contour_points/*.txt"))
# ------------------------------------------------------------------------
# GT_tracking_points_path_list = glob(f"{root_generated_path}{dataset_folder}/MATLAB_tracked_points/*.txt") # MATLAB pseudo-labeled GT points
GT_tracking_points_path_list = sorted(glob(f"{root_generated_path}{dataset_folder}/points/*.txt")) # my manual GT points
# if there is no MATLAB pseudo-labels or manual GT labels, create dummy labels
if len(GT_tracking_points_path_list) == 0:
print('No MATLAB pseudo-labels or manual GT labels. Creating dummy labels.')
os.makedirs(f"{root_generated_path}{dataset_folder}/points/", exist_ok=True)
save_string = ""
for i in range(4):
# reorder row & column coordinate to x & y coordinate
save_string += '1 7\n'
for a_contour_point_path in contour_points_path_list:
a_image_name = get_image_name(a_contour_point_path, '.txt')
GT_tracking_points_path = f'{root_generated_path}{dataset_folder}/points/{a_image_name}.txt'
with open(GT_tracking_points_path, 'w') as f:
f.write(save_string)
GT_tracking_points_path_list.append(GT_tracking_points_path)
# Make dense frames sparse
# GT_tracking_points_path_list = [GT_tracking_points_path_list[0]] + GT_tracking_points_path_list[4::5]
# contour_points_path_list = [contour_points_path_list[0]] + contour_points_path_list[4::5]
# ------------------------------------------------------------------------
assert len(GT_tracking_points_path_list) == len(contour_points_path_list)
for a_index, (a_tracking_points_path, a_contour_points_path) in enumerate(tqdm(zip(GT_tracking_points_path_list, contour_points_path_list))):
a_image_name = get_image_name(a_tracking_points_path, '.txt')
gt_tracking_points = np.loadtxt(a_tracking_points_path)
gt_tracking_points = gt_tracking_points.astype('int32')
contour_points = np.loadtxt(a_contour_points_path)
contour_points = contour_points.astype('int32')
# find index of matching contour point for every gt points
contour_indices = []
for a_gt_point in gt_tracking_points:
min_dist = None
match_index = None
for a_contour_index, a_contour_point in enumerate(contour_points):
a_dist = np.linalg.norm(a_gt_point - a_contour_point)
if min_dist is None or min_dist > a_dist:
min_dist = a_dist
match_index = a_contour_index
contour_indices.append(match_index)
assert gt_tracking_points.shape[0] == len(contour_indices)
sorted_contour_indices = sorted(contour_indices) # !!! sort indices in ascending order
save_path = f"{root_generated_path}{dataset_folder}/tracked_points_in_contour_indices"
if not os.path.exists(save_path):
os.mkdir(save_path)
save_string = ""
for a_contour_index in sorted_contour_indices:
save_string += str(a_contour_index) + '\n'
with open(f'{save_path}/{a_image_name}.txt', 'w') as f:
f.write(save_string)
def copy_paste_images_to_generated_path(root_assets_path, root_generated_path, image_folder, image_format, dataset_folder):
img_path_list = glob(f"{root_assets_path}/{dataset_folder}/{image_folder}/*{image_format}")
dst_root_path = f"{root_generated_path}/{dataset_folder}/images"
os.makedirs(dst_root_path, exist_ok=True)
for src_img_path in img_path_list:
src_img_name = os.path.basename(src_img_path)
shutil.copy(src_img_path, f"{root_generated_path}/{dataset_folder}/images/{src_img_name}")
def evaluate_Matlab_tracking_points_on_my_GT_tracking_points(dataset_folder, image_folder, image_format):
'''
load GT points
load contour points
load Matlab prediction protrusion
:param dataset_folder:
:return:
'''
Matlab_GT_tracking_points_path_list = sorted(glob(f"{root_generated_path}{dataset_folder}/MATLAB_tracked_points/*.txt"))
my_GT_tracking_points_path_list = sorted(glob(f"{root_generated_path}{dataset_folder}/points/*.txt")) # my manual GT points
contour_points_path_list = sorted(glob(f"{root_generated_path}{dataset_folder}/contour_points/*.txt"))
img_path_list = sorted(glob(f"{root_assets_path}/{dataset_folder}/{image_folder}/*{image_format}"))
# Matlab_GT_tracking_points_path_list = Matlab_GT_tracking_points_path_list[:41]
# my_GT_tracking_points_path_list = my_GT_tracking_points_path_list[:41]
# contour_points_path_list = contour_points_path_list[:41]
# img_path_list = img_path_list[:41]
if len(Matlab_GT_tracking_points_path_list) == 41 and len(contour_points_path_list) == 200:
contour_points_path_list = [contour_points_path_list[0]] + contour_points_path_list[4::5]
assert len(Matlab_GT_tracking_points_path_list) == len(contour_points_path_list)
assert len(my_GT_tracking_points_path_list) == 41
sa_list = []
rsa_list = []
ta_list = []
ca_list = []
selected_matlab_GT_tracking_points_indices = []
for a_index, (matlab_GT_tracking_points_path, contour_points_path, image_path) in enumerate(zip(Matlab_GT_tracking_points_path_list, contour_points_path_list, img_path_list)):
if len(Matlab_GT_tracking_points_path_list) == 200:
my_GT_tracking_points_path = my_GT_tracking_points_path_list[(a_index+1)//5]
else:
my_GT_tracking_points_path = my_GT_tracking_points_path_list[a_index]
# if len(Matlab_GT_tracking_points_path_list) == 200 and (a_index == 0 or (a_index+1) % 5 == 0):
matlab_GT_tracking_points = np.loadtxt(matlab_GT_tracking_points_path)
matlab_GT_tracking_points = matlab_GT_tracking_points.astype('int32')
my_gt_tracking_points = np.loadtxt(my_GT_tracking_points_path)
my_gt_tracking_points = my_gt_tracking_points.astype('int32')
contour_points = np.loadtxt(contour_points_path)
contour_points = contour_points.astype('int32')
# -------------------------------------------------------------------------------
# Put my_gt_tracking_points along the contour points
gt_tracking_points_on_contour_indices = []
for my_gt_point in my_gt_tracking_points:
min_dist = None
match_index = None
for index, contour_point in enumerate(contour_points):
a_dist = np.linalg.norm(contour_point - my_gt_point)
if min_dist is None or min_dist > a_dist:
min_dist = a_dist
match_index = index
gt_tracking_points_on_contour_indices.append(match_index)
assert len(gt_tracking_points_on_contour_indices) == len(my_gt_tracking_points)
gt_tracking_points_on_contour = contour_points[gt_tracking_points_on_contour_indices]
# -------------------------------------------------------------------------------
if a_index == 0:
# find corresponding index of Matlab tracking points for every GT tracking points
for gt_point in gt_tracking_points_on_contour:
min_dist = None
match_index = None
for matlab_index, matlab_gt_point in enumerate(matlab_GT_tracking_points):
a_dist = np.linalg.norm(matlab_gt_point - gt_point)
if min_dist is None or min_dist > a_dist:
min_dist = a_dist
match_index = matlab_index
selected_matlab_GT_tracking_points_indices.append(match_index)
assert len(selected_matlab_GT_tracking_points_indices) == len(gt_tracking_points_on_contour)
elif a_index > 0:
a_image = plt.imread(image_path)
image_height = a_image.shape[0]
image_width = a_image.shape[1]
spatial_accuracy_threshold = 0.02
rsa_threshold = 0.01
ca_threshold = 0.01
selected_matlab_GT_tracking_points = matlab_GT_tracking_points[selected_matlab_GT_tracking_points_indices]
absolute_sa = metrics.spatial_accuracy(gt_tracking_points_on_contour, selected_matlab_GT_tracking_points, image_width, image_height, spatial_accuracy_threshold)
sa_list.append( absolute_sa )
# get contour points closest to the selected_matlab_GT_tracking_points
selected_matlab_contour_indices = []
for a_matlab_point in selected_matlab_GT_tracking_points:
min_dist = None
match_index = None
for contour_index, contour_point in enumerate(contour_points):
a_dist = np.linalg.norm(contour_point - a_matlab_point)
if min_dist is None or min_dist > a_dist:
min_dist = a_dist
match_index = contour_index
selected_matlab_contour_indices.append(match_index)
ca_list.append( metrics.contour_accuracy(gt_tracking_points_on_contour_indices, selected_matlab_contour_indices, matlab_GT_tracking_points.shape[0], ca_threshold) )
# ------------------------------------------------------------------------------
# get corresponding matlab indices for prev_gt_tracking_points
prev_overfit_selected_matlab_GT_tracking_points_indices = []
# find corresponding index of Matlab tracking points for every GT tracking points
for gt_point in prev_gt_tracking_points:
min_dist = None
match_index = None
for matlab_index, matlab_gt_point in enumerate(prev_matlab_GT_tracking_points):
a_dist = np.linalg.norm(matlab_gt_point - gt_point)
if min_dist is None or min_dist > a_dist:
min_dist = a_dist
match_index = matlab_index
prev_overfit_selected_matlab_GT_tracking_points_indices.append(match_index)
assert len(prev_overfit_selected_matlab_GT_tracking_points_indices) == len(gt_tracking_points_on_contour)
overfit_selected_matlab_GT_tracking_points = matlab_GT_tracking_points[prev_overfit_selected_matlab_GT_tracking_points_indices]
relative_sa = metrics.relative_spatial_accuracy(gt_tracking_points_on_contour, overfit_selected_matlab_GT_tracking_points, prev_gt_tracking_points, prev_gt_tracking_points, image_width, image_height, rsa_threshold)
rsa_list.append( relative_sa )
prev_selected_matlab_GT_tracking_points = prev_matlab_GT_tracking_points[selected_matlab_GT_tracking_points_indices]
ta = metrics.temporal_accuracy(gt_tracking_points_on_contour, selected_matlab_GT_tracking_points, prev_gt_tracking_points, prev_selected_matlab_GT_tracking_points, image_width, image_height, spatial_accuracy_threshold)
ta_list.append( ta )
#----------------------------------------------------------------------------------
# visualize points
plot_tracking_points(f"{root_generated_path}{dataset_folder}/", 'matlab_gt_my_gt_compare', a_index, gt_tracking_points_on_contour, selected_matlab_GT_tracking_points, a_image)
# save previous results for relative spatial accuracy
prev_matlab_GT_tracking_points = matlab_GT_tracking_points
prev_gt_tracking_points = gt_tracking_points_on_contour
print('SA: ', round(mean(sa_list), 4))
# print('Relative: ', round(mean(rsa_list), 4))
# print('Temporal: ', round(mean(ta_list), 4))
print('CA: ', round(mean(ca_list), 4))
print('sa_list', sa_list)
print('ca_list', ca_list)
return sa_list, rsa_list, ta_list, ca_list
def plot_colar_bar(root_generated_path, dataset_folder, image_path, cmap):
plot_dir = f"{root_generated_path}{dataset_folder}/"
save_name = 'colorbar'
# prepare save folder
if not os.path.exists(f"{plot_dir}/{save_name}/"):
os.makedirs(f"{plot_dir}/{save_name}/")
gt_cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["lightcoral", "red"])
pred_cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["greenyellow", "green"])
matlab_cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["skyblue", "blue"])
contour_cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["dimgrey", "snow"])
tracking_point_cmap = pylab.get_cmap('gist_rainbow')
a_image = plt.imread(image_path)
plt.imshow(a_image, cmap=cmap)
cbar = plt.colorbar()
cbar.set_ticks([])
plt.savefig(f"{plot_dir}/{save_name}/hi.svg", bbox_inches="tight", pad_inches=0, dpi=400)
plt.close()
if __name__ == "__main__":
dataset_name = 'PC' #PC # HACKS # JELLY
image_format = '.png'
# for processing SDC dataset
if dataset_name == 'HACKS':
root_assets_path = "assets/Computer Vision/HACKS_live/"
root_generated_path = "generated/Computer Vision/HACKS_live/"
processed_mask_folder = 'masks_png'
image_folder = 'images_png'
# All folders
# dataset_path_list = glob(f"{root_assets_path}/*")
# dataset_folders = []
# for dataset_path in dataset_path_list:
# dataset_folders.append( dataset_path.split('\\')[-1] )
# folder container top or bottom anchored images
# dataset_folders = ['3_122217_S02_DMSO_09', '3_122217_S02_DMSO_14', '3_122217_S02_DMSO_19', '4_Cell_5', '5_120217_S02_CK689_50uM_03',
# '7_120217_S02_CK689_50uM_14', '8_120217_S02_CK689_50uM_09', '9_TFM-08122012-3']
# Dense frames dataset
# dataset_folders = ['1_050818_DMSO_09', '2_052818_S02_none_08', '3_120217_S02_CK689_50uM_08',
# '4_122217_S02_DMSO_04', '5_120217_S02_CK689_50uM_07', '6_052818_S02_none_02',
# '7_120217_S02_CK689_50uM_13', '8_TFM-08122012-5', '9_052818_S02_none_12']
# Sparse frames dataset (used this for manuscript)
dataset_folders = ['1_050818_DMSO_09_sparse', '2_052818_S02_none_08_sparse', '3_120217_S02_CK689_50uM_08_sparse',
'4_122217_S02_DMSO_04_sparse', '5_120217_S02_CK689_50uM_07_sparse', '6_052818_S02_none_02_sparse',
'7_120217_S02_CK689_50uM_13_sparse', '8_TFM-08122012-5_sparse', '9_052818_S02_none_12_sparse']
# current setting
# dataset_folders = ['2_052818_S02_none_08_sparse']
# ---------------------------------------------------------------
# for processing MARS-Net phase contrast dataset
elif dataset_name == 'PC':
root_assets_path = '/data/junbong/optical_flow/assets/data_processing_pc/'
root_generated_path = "/data/junbong/optical_flow/assets/data_processed_pc/"
processed_mask_folder = 'refined_masks/refined_masks_for_channel_1'
image_folder = 'img'
# dataset_folders = ['040119_PtK1_S01_01_phase', '040119_PtK1_S01_01_phase_ROI2', '040119_PtK1_S01_01_phase_2_DMSO_nd_01', "040119_PtK1_S01_01_phase_3_DMSO_nd_03"]
# image_folder = 'img_all'
# for MATLAB pseudo-label dataset
# dataset_folders = ['matlab_040119_PtK1_S01_01_phase', 'matlab_040119_PtK1_S01_01_phase_ROI2', 'matlab_040119_PtK1_S01_01_phase_2_DMSO_nd_01','matlab_040119_PtK1_S01_01_phase_2_DMSO_nd_02','matlab_040119_PtK1_S01_01_phase_3_DMSO_nd_03']
# image_folder = 'images'
# for Sparse frames dataset (used this for manuscript)
# dataset_folders = ['040119_PtK1_S01_01_phase_sparse', '040119_PtK1_S01_01_phase_ROI2_sparse', '040119_PtK1_S01_01_phase_2_DMSO_nd_01_sparse', '040119_PtK1_S01_01_phase_3_DMSO_nd_03_sparse']
# image_folder = 'img'
# current setting
dataset_folders = ["040119_PtK1_S01_01_phase_sparse"]
# -----------------------------------------------
elif dataset_name == 'JELLY':
root_assets_path = 'generated/Computer Vision/Jellyfish/'
root_generated_path = "generated/Computer Vision/Jellyfish/"
image_folder = 'cropped'
image_folder = 'cropped_color'
processed_mask_folder = 'refined_masks/refined_masks_for_channel_1'
dataset_folders = ["First"]
else:
raise ValueError('Unknown dataset_name', dataset_name)
#------------------------------------------------
# for sampling contour points and converting GT points to contour indices
for dataset_folder in dataset_folders:
print('dataset', dataset_folder)
# --------------------------- Data preprocessing --------------------------------------
copy_paste_images_to_generated_path(root_assets_path, root_generated_path, image_folder, image_format, dataset_folder)
sample_contour_points(root_assets_path, dataset_folder, image_folder, processed_mask_folder, image_format)
convert_GT_tracking_points_to_contour_indices(root_generated_path, dataset_folder)
# --------------------------- Data Loading for manuscript drawing --------------------------------------------
# Matlab_GT_tracking_points_path_list = glob(f"{root_generated_path}{dataset_folder}/MATLAB_tracked_points/*.txt")
# my_GT_tracking_points_path_list = glob(f"{root_generated_path}{dataset_folder}/points/*.txt") # my manual GT points
# pred_tracking_points_np = np.load(f"{root_generated_path}{dataset_folder}/saved_tracking_points.npy", allow_pickle=True)
# pred_tracking_points_contour_indices = np.load(f"{root_generated_path}{dataset_folder}/tracked_contour_points.npy", allow_pickle=True)
# contour_points_path_list = glob(f"{root_generated_path}{dataset_folder}/contour_points/*.txt")
# img_path_list = glob(f"{root_assets_path}/{dataset_folder}/{image_folder}/*{image_format}")
# if len(contour_points_path_list) == 200:
# contour_points_path_list = [contour_points_path_list[0]] + contour_points_path_list[4::5]
# assert pred_tracking_points_contour_indices.shape[0] == 40
# assert pred_tracking_points_np.shape[0] == 40
# assert len(Matlab_GT_tracking_points_path_list) == len(contour_points_path_list)
# assert len(Matlab_GT_tracking_points_path_list) == len(my_GT_tracking_points_path_list)
# assert len(my_GT_tracking_points_path_list) == 41
# if len(contour_points_path_list) == 199:
# contour_points_path_list = [contour_points_path_list[0]] + contour_points_path_list[4::5]
# if len(contour_points_path_list) == 40 and pred_tracking_points_contour_indices.shape[0] == 40:
# pred_tracking_points_contour_indices = pred_tracking_points_contour_indices[:-1]
# assert len(img_path_list) == len(contour_points_path_list)
# assert len(img_path_list) == pred_tracking_points_contour_indices.shape[0] + 1
# ---------------------------- MATLAB ---------------------
# first dimension is column, x
# second dimension is row, y
# loaded_matlab_data = sio.loadmat(f'{root_generated_path}{dataset_folder}/WindowingPackage/protrusion/protrusion_vectors.mat')
# movie_smoothedEdge = loaded_matlab_data['smoothedEdge']
# # read matlab_correspondence dict
# track_id_dict_list = []
# for a_dict_index in range((movie_smoothedEdge.shape[0] - 1)):
# with open(f'{root_generated_path}{dataset_folder}/matlab_correspondence/{a_dict_index}.txt', "r") as f:
# contents = f.read()
# track_id_dict_list.append(ast.literal_eval(contents))
# --------------------------- Data Loading Ends --------------------------------------------
# --------------------------- Draw Manuscript Figures --------------------------------------------
# plot_colar_bar(img_path_list[0])
# manuscript_figure4_for_jelly(root_generated_path, dataset_folder, img_path_list, contour_points_path_list, pred_tracking_points_contour_indices,
# Matlab_GT_tracking_points_path_list, track_id_dict_list, movie_smoothedEdge, my_GT_tracking_points_path_list, arrow_plot=False )
# manuscript_figure4(root_generated_path, dataset_folder, img_path_list, contour_points_path_list, pred_tracking_points_contour_indices, Matlab_GT_tracking_points_path_list, my_GT_tracking_points_path_list, arrow_plot=False )
# manuscript_figure4_no_GT(root_generated_path, dataset_folder, img_path_list, contour_points_path_list, pred_tracking_points_contour_indices, Matlab_GT_tracking_points_path_list)
# manuscript_figure1(root_generated_path, dataset_folder, img_path_list, contour_points_path_list, pred_tracking_points_contour_indices)
# manuscript_figure1_trajectory(root_generated_path, dataset_folder, img_path_list, contour_points_path_list, pred_tracking_points_contour_indices)
# manuscript_figure5(root_generated_path, dataset_folder, img_path_list, contour_points_path_list, pred_tracking_points_contour_indices)
# rainbow_contour_pred_only(root_generated_path, dataset_folder, img_path_list, contour_points_path_list, pred_tracking_points_contour_indices)
# --------------------------- For Rebuttal ---------------------------
# rebuttal_error_study(root_generated_path)
# cmap = mpl.colors.LinearSegmentedColormap.from_list("", [(173/255,255/255,47/255), (0, 50/255,0)], N=6)
# plot_colar_bar(root_generated_path, dataset_folder, img_path_list[0], cmap)
# rebuttal_labeling_figure(root_generated_path, dataset_folder, img_path_list, contour_points_path_list)
# for evaluation of Mechanical model on my GT points (used this for manuscript comparison table)
# all_sa = []
# all_rsa = []
# all_ta = []
# all_ca = []
# for dataset_folder in dataset_folders:
# print('dataset', dataset_folder)
# sa_list, rsa_list, ta_list, ca_list = evaluate_Matlab_tracking_points_on_my_GT_tracking_points(dataset_folder, image_folder, image_format)
# all_sa = all_sa + sa_list
# all_rsa = all_rsa + rsa_list
# all_ta = all_ta + ta_list
# all_ca = all_ca + ca_list
# print('Average SA: ', round(mean(all_sa), 4))
# print('Average RSA: ', round(mean(all_rsa), 4))
# print('Average TA: ', round(mean(all_ta), 4))
# print('Average CA: ', round(mean(all_ca), 4))
| src/preprocessing/main_process_tracking_points.py | JunbongJang-contour-tracking-1219b66 | [
{
"filename": "src/preprocessing/visualization_utils.py",
"retrieved_chunk": " '''\n image_format = '.png'\n all_folders = ['040119_PtK1_S01_01_phase_3_DMSO_nd_03']\n cmap = 'gray'\n for a_folder in all_folders:\n print('-----------------------', a_folder, '-----------------------')\n a_folder = os.path.basename(a_folder)\n save_path = f\"{root_generated_path}/{a_folder}/gt/\"\n points_path = f\"{a_folder}/points/\"\n visualize_points(root_assets_path, points_path, cmap, image_format, a_folder, save_path)",
"score": 0.8573014736175537
},
{
"filename": "src/preprocessing/MATLAB_tracking_points.py",
"retrieved_chunk": " cm = pylab.get_cmap('gist_rainbow')\n for a_folder in dataset_folders:\n print(a_folder)\n image_format = '.png'\n image_path_list = glob(f'{root_path}{a_folder}/{image_folder}/*{image_format}')\n loaded_matlab_data = scipy.io.loadmat(f'{root_path}{a_folder}/WindowingPackage/protrusion/protrusion_vectors.mat')\n # first dimension is column, x\n # second dimension is row, y\n movie_protrusion = loaded_matlab_data['protrusion']\n movie_normals = loaded_matlab_data['normals']",
"score": 0.8537479043006897
},
{
"filename": "src/preprocessing/visualization_utils.py",
"retrieved_chunk": " points_textfiles = glob(f\"{root_path}/{points_path}/*.txt\")\n # keep image paths that have corresponding textfiles (for visualizing PoST)\n image_paths = []\n for textfile_path in points_textfiles:\n image_name = os.path.basename(textfile_path).replace('.txt', image_format)\n corresponding_image_path = f\"assets/Computer Vision/PoST_gt/{a_folder}/images/{image_name}\"\n image_paths.append(corresponding_image_path)\n assert len(image_paths) == len(points_textfiles)\n image_paths = sorted(image_paths)\n points_textfiles = sorted(points_textfiles)",
"score": 0.8398829698562622
},
{
"filename": "src/preprocessing/MATLAB_tracking_points.py",
"retrieved_chunk": " # dataset_folders = ['1_050818_DMSO_09_sparse', '2_052818_S02_none_08_sparse', '3_120217_S02_CK689_50uM_08_sparse',\n # '4_122217_S02_DMSO_04_sparse', '5_120217_S02_CK689_50uM_07_sparse', '6_052818_S02_none_02_sparse',\n # '7_120217_S02_CK689_50uM_13_sparse', '8_TFM-08122012-5_sparse', '9_052818_S02_none_12_sparse']\n # -------------------------\n # for jelly dataset\n root_folder = 'Jellyfish'\n image_folder = 'cropped'\n root_path = f'../../../generated/Computer Vision/{root_folder}/'\n dataset_folders = ['First']\n # -------------------------",
"score": 0.8386251926422119
},
{
"filename": "src/preprocessing/MATLAB_tracking_points.py",
"retrieved_chunk": " # for SDC dataset\n # root_folder = 'HACKS_live'\n # image_folder = 'images_png'\n # root_path = f'../../../assets/Computer Vision/{root_folder}/'\n # dataset_path_list = glob(f\"{root_path}/*\")\n # convert to folder_list\n # dataset_folders = []\n # for dataset_path in dataset_path_list:\n # dataset_folders.append( dataset_path.split('\\\\')[-1] )\n # only GT labeled folders",
"score": 0.8364917039871216
}
] | python | replace('refined_', '') # to make the name of mask the same as the name of image |
import unittest
from cnlp import other_methods
from tests import Configs
import numpy as np
from scipy import sparse
class TestDimensionalityReductionMethods(unittest.TestCase):
def __perform_test(self, fun, params: dict = {}, debug: bool = False):
g = Configs.load_normal_dataset()
g_labels = Configs.load_labels_dataset()
res = None
res_labels = None
with self.subTest('Int Labels'):
res = fun(g, **params)
if debug:
print(res)
print(type(res))
self.assertIsNotNone(res, "None result is returned")
self.assertTrue(
type(res) is sparse.csr_matrix or type(res) is np.ndarray,
"Wrong return type")
with self.subTest('String Labels'):
res_labels = fun(g_labels, **params)
if debug:
print(res_labels)
print(type(res_labels))
self.assertIsNotNone(res_labels, "None result is returned")
self.assertTrue(
type(res_labels) is sparse.csr_matrix
or type(res_labels) is np.ndarray, "Wrong return type")
with self.subTest('CMP Results'):
try:
self.assertTrue(
(res.__round__(4) != res_labels.__round__(4)).nnz == 0,
"Results are different !")
except AssertionError as e:
print(e)
return res
def test_MI(self):
self.__perform_test(other_methods. | information_theory.MI) |
def test_pathentropy(self):
self.__perform_test(other_methods.information_theory.path_entropy)
if __name__ == '__main__':
unittest.main()
| tests/unittests/test_othermethods.py | Typing-Monkeys-complex-network-link-prediction-cf69190 | [
{
"filename": "tests/unittests/similarity_methods/test_global.py",
"retrieved_chunk": " try:\n self.assertTrue(\n (res.__round__(4) != res_labels.__round__(4)).nnz == 0,\n \"Results are different !\")\n except AssertionError as e:\n print(e)\n return res\n def test_katz(self):\n self.__perform_test(global_similarity.katz_index, {'beta': .001})\n def test_randwalk(self):",
"score": 0.8956231474876404
},
{
"filename": "tests/unittests/similarity_methods/test_local.py",
"retrieved_chunk": " try:\n self.assertTrue(\n (res.__round__(4) != res_labels.__round__(4)).nnz == 0,\n \"Results are different !\")\n except AssertionError as e:\n print(e)\n return res\n def test_common_neighbors(self):\n self.__perform_test(local_similarity.common_neighbors)\n def test_adamicadar(self):",
"score": 0.8929297924041748
},
{
"filename": "tests/unittests/test_dimreduction.py",
"retrieved_chunk": " try:\n self.assertTrue(\n (res.__round__(4) != res_labels.__round__(4)).nnz == 0,\n \"Results are different !\")\n except AssertionError as e:\n print(e)\n return res\n def test_SVD(self):\n self.__perform_test(\n dimensionality_reduction_methods.link_prediction_svd, {'k': 40})",
"score": 0.8786035776138306
},
{
"filename": "tests/unittests/similarity_methods/test_quasi_local.py",
"retrieved_chunk": " try:\n self.assertTrue(\n (res.__round__(4) != res_labels.__round__(4)).nnz == 0,\n \"Results are different !\")\n except AssertionError as e:\n print(e)\n return res\n def test_LPI(self):\n self.__perform_test(quasi_local_similarity.local_path_index, {\n 'epsilon': .1,",
"score": 0.8785083293914795
},
{
"filename": "tests/unittests/test_probabilisticmethods.py",
"retrieved_chunk": " or type(res_labels) is np.ndarray, \"Wrong return type\")\n # with self.subTest('CMP Results'):\n # try:\n # self.assertTrue((res.__round__(4)\n # != res_labels.__round__(4)).nnz == 0,\n # \"Results are different !\")\n # except AssertionError as e:\n # print(e)\n return res\n def test_sbm(self):",
"score": 0.8521958589553833
}
] | python | information_theory.MI) |
from autoresearcher.llms.openai import openai_call
from autoresearcher.utils.prompts import keyword_combination_prompt
# Generate keyword combinations for a given research question
def generate_keyword_combinations(research_question):
"""
Generates keyword combinations for a given research question.
Args:
research_question (str): The research question to generate keyword combinations for.
Returns:
list: A list of keyword combinations for the given research question.
Examples:
>>> generate_keyword_combinations("What is the impact of AI on healthcare?")
["AI healthcare", "impact AI healthcare", "AI healthcare impact"]
"""
prompt = keyword_combination_prompt.format(research_question=research_question)
response = openai_call(prompt, use_gpt4=False, temperature=0, max_tokens=200)
combinations = response. | split("\n") |
return [
combination.split(": ")[1]
for combination in combinations
if ": " in combination
]
| autoresearcher/utils/generate_keyword_combinations.py | eimenhmdt-autoresearcher-5235ee7 | [
{
"filename": "autoresearcher/workflows/literature_review/literature_review.py",
"retrieved_chunk": " keyword_combinations = generate_keyword_combinations(research_question)\n print(colored(\"Keyword combinations generated!\", \"green\"))\n # Fetch the top 20 papers for the research question\n search_query = research_question\n print(colored(\"Fetching top 20 papers...\", \"yellow\"))\n top_papers = SemanticScholar.fetch_and_sort_papers(\n search_query, keyword_combinations=keyword_combinations, year_range=\"2000-2023\"\n )\n print(colored(\"Top 20 papers fetched!\", \"green\"))\n # Extract answers and from the top 20 papers",
"score": 0.8303771018981934
},
{
"filename": "autoresearcher/utils/prompts.py",
"retrieved_chunk": "`reset`\n`no quotes`\n`no explanations`\n`no prompt`\n`no self-reference`\n`no apologies`\n`no filler`\n`just answer`\nGenerate several keyword combinations based on the following research question: {research_question}. \nDon't generate more than 5 keyword combinations.",
"score": 0.8060989379882812
},
{
"filename": "autoresearcher/workflows/literature_review/combine_answers.py",
"retrieved_chunk": " answer_list = \"\\n\\n\".join(answers)\n prompt = literature_review_prompt.format(\n research_question=research_question, answer_list=answer_list\n )\n # Calculate the tokens in the input\n input_tokens = count_tokens(prompt)\n # Calculate the remaining tokens for the response\n remaining_tokens = 4080 - input_tokens\n max_tokens = max(remaining_tokens, 0)\n literature_review = openai_call(",
"score": 0.7867860198020935
},
{
"filename": "autoresearcher/workflows/literature_review/combine_answers.py",
"retrieved_chunk": "from autoresearcher.llms.openai import openai_call\nfrom autoresearcher.utils.prompts import literature_review_prompt\nfrom autoresearcher.utils.count_tokens import count_tokens\n# Combine answers into a concise literature review using OpenAI API\ndef combine_answers(answers, research_question, use_gpt4=False, temperature=0.1):\n \"\"\"\n Combines a list of answers into a concise literature review using OpenAI API.\n Args:\n answers (list): A list of answers to combine.\n research_question (str): The research question to use in the literature review.",
"score": 0.7820537686347961
},
{
"filename": "autoresearcher/workflows/literature_review/literature_review.py",
"retrieved_chunk": " \"\"\"\n SemanticScholar = SemanticScholarLoader()\n print(\n colored(\n f\"Research question: {research_question}\", \"yellow\", attrs=[\"bold\", \"blink\"]\n )\n )\n print(colored(\"Auto Researcher initiated!\", \"yellow\"))\n # Generate keyword combinations\n print(colored(\"Generating keyword combinations...\", \"yellow\"))",
"score": 0.7706830501556396
}
] | python | split("\n") |
import glob
import json
import logging
import os
import boto3
from botocore.config import Config
from botocore import UNSIGNED
from e2e_common.util import hassuffix, xrun, firstFromS3Prefix, countblocks, atexitrun
from e2e_conduit.fixtures.importers.importer_plugin import ImporterPlugin
logger = logging.getLogger(__name__)
class FollowerAlgodImporter(ImporterPlugin):
def __init__(self, sourcenet):
self.algoddir = None
self.sourcenet = sourcenet
self.last = None
super().__init__()
@property
def name(self):
return "algod"
@property
def lastblock(self):
if self.last is None:
raise RuntimeError("algod importer has no blockfiles configured")
return self.last
def resolve_config_input(self):
self. | config_input["mode"] = "follower" |
with open(os.path.join(self.algoddir, "algod.net"), "r") as algod_net:
self.config_input["netaddr"] = "http://" + algod_net.read().strip()
with open(os.path.join(self.algoddir, "algod.token"), "r") as algod_token:
self.config_input["token"] = algod_token.read().strip()
def resolve_config_output(self):
self.config_output["algod_token"] = self.config_input["token"]
self.config_output["algod_net"] = self.config_input["netaddr"]
self.config_output["algod_data_dir"] = self.algoddir
def setup(self, accumulated_config):
try:
conduit_dir = accumulated_config["conduit_dir"]
except KeyError as exc:
logger.error(
f"AlgodImporter needs to be provided with the proper config: {exc}"
)
raise
source_is_tar = hassuffix(
self.sourcenet, ".tar", ".tar.gz", ".tar.bz2", ".tar.xz"
)
if not (source_is_tar or (self.sourcenet and os.path.isdir(self.sourcenet))):
# Assuming self.sourcenet is an s3 source net
tarname = f"{self.sourcenet}.tar.bz2"
# fetch test data from S3
bucket = "algorand-testdata"
s3 = boto3.client("s3", config=Config(signature_version=UNSIGNED))
prefix = "indexer/e2e4"
if "/" in tarname:
cmhash_tarnme = tarname.split("/")
cmhash = cmhash_tarnme[0]
tarname = cmhash_tarnme[1]
prefix += "/" + cmhash
tarpath = os.path.join(conduit_dir, tarname)
else:
tarpath = os.path.join(conduit_dir, tarname)
success = firstFromS3Prefix(s3, bucket, prefix, tarname, outpath=tarpath)
if not success:
raise Exception(
f"failed to locate tarname={tarname} from AWS S3 path {bucket}/{prefix}"
)
source_is_tar = True
self.sourcenet = tarpath
tempnet = os.path.join(conduit_dir, "net")
if source_is_tar:
xrun(["tar", "-C", conduit_dir, "-x", "-f", self.sourcenet])
else:
xrun(["rsync", "-a", self.sourcenet + "/", tempnet + "/"])
blockfiles = glob.glob(
os.path.join(conduit_dir, "net", "Primary", "*", "*.block.sqlite")
)
self.last = countblocks(blockfiles[0])
# Reset the secondary node, and enable follow mode.
# This is what conduit will connect to for data access.
for root, _, files in os.walk(os.path.join(tempnet, "Node", "tbd-v1")):
for f in files:
if ".sqlite" in f:
os.remove(os.path.join(root, f))
cf = {}
with open(os.path.join(tempnet, "Node", "config.json"), "r") as config_file:
cf = json.load(config_file)
cf["EnableFollowMode"] = True
with open(os.path.join(tempnet, "Node", "config.json"), "w") as config_file:
config_file.write(json.dumps(cf))
try:
xrun(["goal", "network", "start", "-r", tempnet])
except Exception:
logger.error("failed to start private network, looking for node.log")
for root, dirs, files in os.walk(tempnet):
for f in files:
if f == "node.log":
p = os.path.join(root, f)
logger.error("found node.log: {}".format(p))
with open(p) as nf:
for line in nf:
logger.error(" {}".format(line))
raise
atexitrun(["goal", "network", "stop", "-r", tempnet])
self.algoddir = os.path.join(tempnet, "Node")
| e2e_tests/src/e2e_conduit/fixtures/importers/follower_algod.py | algorand-conduit-bcb54fd | [
{
"filename": "e2e_tests/src/e2e_conduit/fixtures/importers/algod.py",
"retrieved_chunk": " return \"algod\"\n @property\n def lastblock(self):\n if self.last is None:\n raise RuntimeError(\"algod importer has no blockfiles configured\")\n return self.last\n def resolve_config_input(self):\n with open(os.path.join(self.algoddir, \"algod.net\"), \"r\") as algod_net:\n self.config_input[\"netaddr\"] = \"http://\" + algod_net.read().strip()\n with open(os.path.join(self.algoddir, \"algod.token\"), \"r\") as algod_token:",
"score": 0.9359360337257385
},
{
"filename": "e2e_tests/src/e2e_conduit/fixtures/importers/algod.py",
"retrieved_chunk": "from e2e_conduit.fixtures.importers.importer_plugin import ImporterPlugin\nlogger = logging.getLogger(__name__)\nclass AlgodImporter(ImporterPlugin):\n def __init__(self, sourcenet):\n self.algoddir = None\n self.sourcenet = sourcenet\n self.last = None\n super().__init__()\n @property\n def name(self):",
"score": 0.8309584856033325
},
{
"filename": "e2e_tests/src/e2e_conduit/fixtures/importers/importer_plugin.py",
"retrieved_chunk": "from e2e_conduit.fixtures.plugin_fixture import PluginFixture\nclass ImporterPlugin(PluginFixture):\n def __init__(self):\n super().__init__()\n @property\n def lastblock(self):\n raise NotImplementedError",
"score": 0.804194986820221
},
{
"filename": "e2e_tests/src/e2e_conduit/fixtures/importers/algod.py",
"retrieved_chunk": " self.config_input[\"token\"] = algod_token.read().strip()\n def resolve_config_output(self):\n self.config_output[\"algod_token\"] = self.config_input[\"token\"]\n self.config_output[\"algod_net\"] = self.config_input[\"netaddr\"]\n self.config_output[\"algod_data_dir\"] = self.algoddir\n def setup(self, accumulated_config):\n try:\n conduit_dir = accumulated_config[\"conduit_dir\"]\n except KeyError as exc:\n logger.error(",
"score": 0.8025723695755005
},
{
"filename": "e2e_tests/src/e2e_conduit/fixtures/importers/__init__.py",
"retrieved_chunk": "from e2e_conduit.fixtures.importers.algod import AlgodImporter\nfrom e2e_conduit.fixtures.importers.follower_algod import FollowerAlgodImporter",
"score": 0.786695659160614
}
] | python | config_input["mode"] = "follower" |
from autoresearcher.llms.openai import openai_call
from autoresearcher.utils.prompts import keyword_combination_prompt
# Generate keyword combinations for a given research question
def generate_keyword_combinations(research_question):
"""
Generates keyword combinations for a given research question.
Args:
research_question (str): The research question to generate keyword combinations for.
Returns:
list: A list of keyword combinations for the given research question.
Examples:
>>> generate_keyword_combinations("What is the impact of AI on healthcare?")
["AI healthcare", "impact AI healthcare", "AI healthcare impact"]
"""
prompt = keyword_combination_prompt. | format(research_question=research_question) |
response = openai_call(prompt, use_gpt4=False, temperature=0, max_tokens=200)
combinations = response.split("\n")
return [
combination.split(": ")[1]
for combination in combinations
if ": " in combination
]
| autoresearcher/utils/generate_keyword_combinations.py | eimenhmdt-autoresearcher-5235ee7 | [
{
"filename": "autoresearcher/utils/prompts.py",
"retrieved_chunk": "`reset`\n`no quotes`\n`no explanations`\n`no prompt`\n`no self-reference`\n`no apologies`\n`no filler`\n`just answer`\nGenerate several keyword combinations based on the following research question: {research_question}. \nDon't generate more than 5 keyword combinations.",
"score": 0.8000690937042236
},
{
"filename": "autoresearcher/workflows/literature_review/literature_review.py",
"retrieved_chunk": " keyword_combinations = generate_keyword_combinations(research_question)\n print(colored(\"Keyword combinations generated!\", \"green\"))\n # Fetch the top 20 papers for the research question\n search_query = research_question\n print(colored(\"Fetching top 20 papers...\", \"yellow\"))\n top_papers = SemanticScholar.fetch_and_sort_papers(\n search_query, keyword_combinations=keyword_combinations, year_range=\"2000-2023\"\n )\n print(colored(\"Top 20 papers fetched!\", \"green\"))\n # Extract answers and from the top 20 papers",
"score": 0.7986366748809814
},
{
"filename": "autoresearcher/workflows/literature_review/combine_answers.py",
"retrieved_chunk": " answer_list = \"\\n\\n\".join(answers)\n prompt = literature_review_prompt.format(\n research_question=research_question, answer_list=answer_list\n )\n # Calculate the tokens in the input\n input_tokens = count_tokens(prompt)\n # Calculate the remaining tokens for the response\n remaining_tokens = 4080 - input_tokens\n max_tokens = max(remaining_tokens, 0)\n literature_review = openai_call(",
"score": 0.7569888830184937
},
{
"filename": "autoresearcher/workflows/literature_review/literature_review.py",
"retrieved_chunk": " research_question (str): The research question to generate a literature review for.\n output_file (str, optional): The file path to save the literature review to.\n Returns:\n str: The generated literature review.\n Examples:\n >>> literature_review('What is the impact of AI on healthcare?')\n Research question: What is the impact of AI on healthcare?\n Auto Researcher initiated!\n Generating keyword combinations...\n Keyword combinations generated!",
"score": 0.7544744610786438
},
{
"filename": "autoresearcher/workflows/literature_review/literature_review.py",
"retrieved_chunk": " \"\"\"\n SemanticScholar = SemanticScholarLoader()\n print(\n colored(\n f\"Research question: {research_question}\", \"yellow\", attrs=[\"bold\", \"blink\"]\n )\n )\n print(colored(\"Auto Researcher initiated!\", \"yellow\"))\n # Generate keyword combinations\n print(colored(\"Generating keyword combinations...\", \"yellow\"))",
"score": 0.7478989362716675
}
] | python | format(research_question=research_question) |
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: CC-BY-NC-4.0
import os
import jsonlines
import csv
from tqdm import tqdm
from collections import defaultdict
from multiprocessing import Pool
from functools import partial
import argparse
from DecAF.Knowledge.linearize import Relation, convert_relation_to_text
DATA_DIR = os.environ['DATA_DIR']
parser = argparse.ArgumentParser(description='process Freebase')
parser.add_argument('--data_dir', type=str, default=f'{DATA_DIR}/knowledge_source/Freebase')
args = parser.parse_args()
# disambuity for entity name
# if the entity name has appeared in previous ids, we add indicator like "v1" "v2" to the name
name_dir = os.path.join(args.data_dir, "id2name_parts")
output_dir = os.path.join(args.data_dir, "id2name_parts_disamb")
if not os.path.exists(output_dir):
os.makedirs(output_dir)
name_num_dict = defaultdict(int)
file_list = os.listdir(name_dir)
file_list.sort()
for file_name in tqdm(file_list):
print(file_name)
id_name_list = []
with open(os.path.join(name_dir, file_name), 'r') as rf:
data_input = csv.reader(rf, delimiter="\t")
for row in data_input:
if row[2] not in name_num_dict:
id_name_list.append(row)
name_num_dict[row[2]] += 1
else:
new_row = row[:2] + [row[2] + " v" + str(name_num_dict[row[2]])]
id_name_list.append(new_row)
name_num_dict[row[2]] += 1
# save the list of rows to a new tsv file
with open(os.path.join(output_dir, file_name), 'w') as wf:
data_output = csv.writer(wf, delimiter="\t")
for row in id_name_list:
data_output.writerow(row)
# load Freebase entity name
name_dir = os.path.join(args.data_dir, "id2name_parts_disamb")
id2name_dict = {}
for file_name in tqdm(os.listdir(name_dir)):
with open(os.path.join(name_dir, file_name), 'r') as rf:
data_input = csv.reader(rf, delimiter="\t")
for row in data_input:
id2name_dict[row[0]] = row[2]
print("number of entities with names: ", len(id2name_dict))
# load topic and type information from Freebase
topic_dir = os.path.join(args.data_dir, "topic_entities_parts")
id2topic_dict = defaultdict(set)
file_list = os.listdir(topic_dir)
# sort file list
file_list.sort()
for file_name in tqdm(file_list):
with open(os.path.join(topic_dir, file_name), 'r') as rf:
for row in rf:
row = row.strip().split("\t")
if len(row) != 3:
continue
if "web" in row[1] or "type.object.name" in row[1]:
continue
topic = row[1].split(".")[-1].replace('.', ' ').replace('_', ' ')
topic += " : " + row[2].replace('.', ' ').replace('_', ' ')
id2topic_dict[row[0]].add(topic)
print("number of entities with topics: ", len(id2topic_dict))
# transform each entity centric 1-hop subgraph (only out relations) as one passage
def transform_triples_group_woid(process_idx, num_process, triple_dir, save_dir):
# do not keep CVT node id
for file_name in tqdm(os.listdir(triple_dir)):
file_id = int(file_name.split("-")[-1])
if file_id % num_process != process_idx:
continue
file_path = os.path.join(triple_dir, file_name)
grouped_entity_triples = defaultdict(list)
with open(file_path, "r") as rf:
for row in rf:
if len(row.strip().split("\t")) != 3:
continue
triple = Relation(row)
if triple. | should_ignore(id2name_dict): |
continue
if triple.obj.startswith("m") and triple.obj not in id2name_dict:
continue
subj = triple.subj
if triple.subj not in id2name_dict:
triple.subj = ""
grouped_entity_triples[subj].append(convert_relation_to_text(triple, id2name_dict))
with jsonlines.open(os.path.join(save_dir, file_name) + ".jsonl", "w") as wf:
data_id = 0
for key in grouped_entity_triples:
if key in id2name_dict:
name_key = id2name_dict[key]
title = name_key + " " + key
else:
name_key = ""
title = key
contents = " ".join(grouped_entity_triples[key])
# add topic information
if key in id2topic_dict:
topics = id2topic_dict[key]
topics = [name_key + " " + topic + " ." for topic in topics]
topics_contents = " ".join(topics)
contents += " " + topics_contents
contents = contents.replace("\t", " ").replace("\n", " ")
title = title.replace("\t", " ").replace("\n", " ")
# split contents by 100 words each chunk
contents_split = contents.split(" ")
contents_chunks = [" ".join(contents_split[i:i+100]) for i in range(0, len(contents_split), 100)]
for contents_chunk in contents_chunks:
data_output_i = {"id": "freebase-file{}doc{}".format(file_id, data_id),
"contents": contents_chunk,
"title": title}
wf.write(data_output_i)
data_id += 1
# Multi-process data processing
def transform_triples_multip(triple_dir, save_dir):
num_process = 10
pool = Pool(num_process)
sampleData = [x for x in range(num_process)]
transform_triples_part = partial(transform_triples_group_woid,
triple_dir=triple_dir,
num_process=num_process,
save_dir=save_dir)
pool.map(transform_triples_part, sampleData)
pool.close()
pool.join()
triple_dir = os.path.join(args.data_dir, "triple_edges_parts")
save_dir = os.path.join(args.data_dir, "processed/document")
os.makedirs(save_dir, exist_ok=True)
transform_triples_multip(triple_dir, save_dir) | DecAF/Knowledge/process_freebase.py | awslabs-decode-answer-logical-form-08d5790 | [
{
"filename": "DecAF/Knowledge/linearize.py",
"retrieved_chunk": " return dict_name\ndef load_nameid_dict(file_dir, lower):\n print(\"Loading name2id and id2name dict...\")\n name2id_dict = defaultdict(list)\n id2name_dict = {}\n for file in tqdm(os.listdir(file_dir)):\n with open(os.path.join(file_dir, file), 'r') as rf:\n data_input = csv.reader(rf, delimiter=\"\\t\")\n for row in data_input:\n if lower:",
"score": 0.7955780029296875
},
{
"filename": "DecAF/Datasets/QA/disambiguate.py",
"retrieved_chunk": " # load id2name mapping\n logging.info(\"Loading id2name mapping\")\n name_dir = f\"{DATA_DIR}/knowledge_source/Freebase/id2name_parts_disamb\"\n name2id_dict, id2name_dict = load_nameid_dict(name_dir, lower=False)\n # load original QA dataset\n for split in [\"dev\", \"test\", \"train\"]:\n if f\"{split}.json\" not in os.listdir(args.data_dir):\n continue\n org_file_path = os.path.join(args.data_dir, f\"{split}.json\")\n with open(org_file_path, \"r\") as f:",
"score": 0.7789516448974609
},
{
"filename": "DecAF/Datasets/QA/GrailQA/preprocess_SP.py",
"retrieved_chunk": "DATA_DIR = os.environ['DATA_DIR']\nparser = argparse.ArgumentParser(description='process dataset')\nparser.add_argument('--data_dir', type=str, default=f'{DATA_DIR}/tasks/QA/GrailQA')\nargs = parser.parse_args()\nif __name__ == \"__main__\":\n name_dir = f\"{DATA_DIR}/knowledge_source/Freebase/id2name_parts_disamb\"\n name2id_dict, id2name_dict = load_nameid_dict(name_dir, lower=False)\n data_dict = defaultdict(list)\n ID2LFs = defaultdict(list)\n for split in ['train', 'dev']:",
"score": 0.7786654233932495
},
{
"filename": "DecAF/Datasets/QA/disambiguate.py",
"retrieved_chunk": " org_data = json.load(f)\n new_data = []\n for item in tqdm(org_data):\n new_answers = []\n for answer in item[\"Answers\"]:\n if answer[\"freebaseId\"] in id2name_dict:\n new_answers.append({\n \"freebaseId\": answer[\"freebaseId\"],\n \"text\": id2name_dict[answer[\"freebaseId\"]],\n })",
"score": 0.7661199569702148
},
{
"filename": "DecAF/Datasets/QA/GrailQA/preprocess_QA.py",
"retrieved_chunk": "args = parser.parse_args()\nif __name__ == \"__main__\":\n data_dict = defaultdict(list)\n for split in ['train', 'dev']:\n infname = os.path.join(args.input_dir, f\"grailqa_v1.0_{split}.json\")\n data = json.load(open(infname))\n for question in data:\n q_obj = {\n \"QuestionId\": question[\"qid\"],\n \"Question\": question[\"question\"],",
"score": 0.7657351493835449
}
] | python | should_ignore(id2name_dict): |
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: CC-BY-NC-4.0
import os
import jsonlines
import csv
from tqdm import tqdm
from collections import defaultdict
from multiprocessing import Pool
from functools import partial
import argparse
from DecAF.Knowledge.linearize import Relation, convert_relation_to_text
DATA_DIR = os.environ['DATA_DIR']
parser = argparse.ArgumentParser(description='process Freebase')
parser.add_argument('--data_dir', type=str, default=f'{DATA_DIR}/knowledge_source/Freebase')
args = parser.parse_args()
# disambuity for entity name
# if the entity name has appeared in previous ids, we add indicator like "v1" "v2" to the name
name_dir = os.path.join(args.data_dir, "id2name_parts")
output_dir = os.path.join(args.data_dir, "id2name_parts_disamb")
if not os.path.exists(output_dir):
os.makedirs(output_dir)
name_num_dict = defaultdict(int)
file_list = os.listdir(name_dir)
file_list.sort()
for file_name in tqdm(file_list):
print(file_name)
id_name_list = []
with open(os.path.join(name_dir, file_name), 'r') as rf:
data_input = csv.reader(rf, delimiter="\t")
for row in data_input:
if row[2] not in name_num_dict:
id_name_list.append(row)
name_num_dict[row[2]] += 1
else:
new_row = row[:2] + [row[2] + " v" + str(name_num_dict[row[2]])]
id_name_list.append(new_row)
name_num_dict[row[2]] += 1
# save the list of rows to a new tsv file
with open(os.path.join(output_dir, file_name), 'w') as wf:
data_output = csv.writer(wf, delimiter="\t")
for row in id_name_list:
data_output.writerow(row)
# load Freebase entity name
name_dir = os.path.join(args.data_dir, "id2name_parts_disamb")
id2name_dict = {}
for file_name in tqdm(os.listdir(name_dir)):
with open(os.path.join(name_dir, file_name), 'r') as rf:
data_input = csv.reader(rf, delimiter="\t")
for row in data_input:
id2name_dict[row[0]] = row[2]
print("number of entities with names: ", len(id2name_dict))
# load topic and type information from Freebase
topic_dir = os.path.join(args.data_dir, "topic_entities_parts")
id2topic_dict = defaultdict(set)
file_list = os.listdir(topic_dir)
# sort file list
file_list.sort()
for file_name in tqdm(file_list):
with open(os.path.join(topic_dir, file_name), 'r') as rf:
for row in rf:
row = row.strip().split("\t")
if len(row) != 3:
continue
if "web" in row[1] or "type.object.name" in row[1]:
continue
topic = row[1].split(".")[-1].replace('.', ' ').replace('_', ' ')
topic += " : " + row[2].replace('.', ' ').replace('_', ' ')
id2topic_dict[row[0]].add(topic)
print("number of entities with topics: ", len(id2topic_dict))
# transform each entity centric 1-hop subgraph (only out relations) as one passage
def transform_triples_group_woid(process_idx, num_process, triple_dir, save_dir):
# do not keep CVT node id
for file_name in tqdm(os.listdir(triple_dir)):
file_id = int(file_name.split("-")[-1])
if file_id % num_process != process_idx:
continue
file_path = os.path.join(triple_dir, file_name)
grouped_entity_triples = defaultdict(list)
with open(file_path, "r") as rf:
for row in rf:
if len(row.strip().split("\t")) != 3:
continue
triple = Relation(row)
if triple.should_ignore(id2name_dict):
continue
if triple. | obj.startswith("m") and triple.obj not in id2name_dict: |
continue
subj = triple.subj
if triple.subj not in id2name_dict:
triple.subj = ""
grouped_entity_triples[subj].append(convert_relation_to_text(triple, id2name_dict))
with jsonlines.open(os.path.join(save_dir, file_name) + ".jsonl", "w") as wf:
data_id = 0
for key in grouped_entity_triples:
if key in id2name_dict:
name_key = id2name_dict[key]
title = name_key + " " + key
else:
name_key = ""
title = key
contents = " ".join(grouped_entity_triples[key])
# add topic information
if key in id2topic_dict:
topics = id2topic_dict[key]
topics = [name_key + " " + topic + " ." for topic in topics]
topics_contents = " ".join(topics)
contents += " " + topics_contents
contents = contents.replace("\t", " ").replace("\n", " ")
title = title.replace("\t", " ").replace("\n", " ")
# split contents by 100 words each chunk
contents_split = contents.split(" ")
contents_chunks = [" ".join(contents_split[i:i+100]) for i in range(0, len(contents_split), 100)]
for contents_chunk in contents_chunks:
data_output_i = {"id": "freebase-file{}doc{}".format(file_id, data_id),
"contents": contents_chunk,
"title": title}
wf.write(data_output_i)
data_id += 1
# Multi-process data processing
def transform_triples_multip(triple_dir, save_dir):
num_process = 10
pool = Pool(num_process)
sampleData = [x for x in range(num_process)]
transform_triples_part = partial(transform_triples_group_woid,
triple_dir=triple_dir,
num_process=num_process,
save_dir=save_dir)
pool.map(transform_triples_part, sampleData)
pool.close()
pool.join()
triple_dir = os.path.join(args.data_dir, "triple_edges_parts")
save_dir = os.path.join(args.data_dir, "processed/document")
os.makedirs(save_dir, exist_ok=True)
transform_triples_multip(triple_dir, save_dir) | DecAF/Knowledge/process_freebase.py | awslabs-decode-answer-logical-form-08d5790 | [
{
"filename": "DecAF/Datasets/QA/utils.py",
"retrieved_chunk": " return out_file\ndef id_to_name(in_file_path, id2name_dict):\n with open(in_file_path, \"r\") as rf:\n data = json.load(rf)\n # print(\"Data example: \")\n # print(data[list(data.keys())[0]])\n new_data = {}\n for key in tqdm(data):\n new_answer_list = []\n for answer in data[key][\"predicted answers\"]:",
"score": 0.7850281000137329
},
{
"filename": "DecAF/Knowledge/linearize.py",
"retrieved_chunk": " return dict_name\ndef load_nameid_dict(file_dir, lower):\n print(\"Loading name2id and id2name dict...\")\n name2id_dict = defaultdict(list)\n id2name_dict = {}\n for file in tqdm(os.listdir(file_dir)):\n with open(os.path.join(file_dir, file), 'r') as rf:\n data_input = csv.reader(rf, delimiter=\"\\t\")\n for row in data_input:\n if lower:",
"score": 0.7836064100265503
},
{
"filename": "DecAF/Datasets/QA/utils.py",
"retrieved_chunk": " else:\n return list(top_answer), None\ndef Prefix_to_id_all(in_file_path, name2id_dict, SP_early_break=True):\n with open(in_file_path, \"r\") as f:\n data = json.load(f)\n print(len(data))\n print(list(data.keys())[0], data[list(data.keys())[0]])\n new_data = {}\n for key in data:\n task = key.split(\":\")[-1]",
"score": 0.7775951623916626
},
{
"filename": "DecAF/Datasets/QA/utils.py",
"retrieved_chunk": " print(save_file)\n with open(save_file, \"w\") as wf:\n json.dump(result_dict, wf, indent=2)\n return save_file\ndef QA_to_id_all(in_file_path, name2id_dict):\n with open(in_file_path, \"r\") as f:\n data = json.load(f)\n print(len(data))\n print(list(data.keys())[0], data[list(data.keys())[0]])\n new_data = {}",
"score": 0.7771278619766235
},
{
"filename": "DecAF/Datasets/QA/utils.py",
"retrieved_chunk": " return save_file\ndef Prefix_to_name_all(in_file_path, name2id_dict, id2name_dict):\n with open(in_file_path, \"r\") as f:\n data = json.load(f)\n print(len(data))\n print(list(data.keys())[0], data[list(data.keys())[0]])\n new_data = {}\n for key in data:\n task = key.split(\":\")[-1]\n q_key = \":\".join(key.split(\":\")[:-1])",
"score": 0.7764876484870911
}
] | python | obj.startswith("m") and triple.obj not in id2name_dict: |
import tarfile
import wandb
import gradio as gr
import numpy as np
from PIL import Image
import tensorflow as tf
from transformers import ViTFeatureExtractor
PRETRAIN_CHECKPOINT = "google/vit-base-patch16-224-in21k"
feature_extractor = ViTFeatureExtractor.from_pretrained(PRETRAIN_CHECKPOINT)
MODEL = None
RESOLTUION = 224
labels = []
with open(r"labels.txt", "r") as fp:
for line in fp:
labels.append(line[:-1])
def normalize_img(
img, mean=feature_extractor.image_mean, std=feature_extractor.image_std
):
img = img / 255
mean = tf.constant(mean)
std = tf.constant(std)
return (img - mean) / std
def preprocess_input(image):
image = np.array(image)
image = tf.convert_to_tensor(image)
image = tf.image.resize(image, (RESOLTUION, RESOLTUION))
image = normalize_img(image)
image = tf.transpose(
image, (2, 0, 1)
) # Since HF models are channel-first.
return {
"pixel_values": tf.expand_dims(image, 0)
}
def get_predictions(wb_token, image):
global MODEL
if MODEL is None:
wandb.login(key=wb_token)
wandb.init(project="$MODEL_PROJECT", id="$MODEL_RUN", resume=True)
path = wandb.use_artifact('tfx-vit-pipeline/$MODEL_NAME:$MODEL_VERSION', type='model').download()
tar = tarfile.open(f"{path}/$MODEL_FILENAME")
tar.extractall(path=".")
MODEL = tf.keras.models.load_model("./model")
preprocessed_image = preprocess_input(image)
prediction = MODEL.predict(preprocessed_image)
probs = tf.nn.softmax(prediction['logits'], axis=1)
confidences = {labels[i]: float(probs[0][i]) for i in range(3)}
return confidences
with gr.Blocks() as demo:
gr.Markdown("## Simple demo for a Image Classification of the Beans Dataset with HF ViT model")
wb_token_if = gr.Textbox(interactive=True, label="Your Weight & Biases API Key")
with gr.Row():
image_if = gr.Image()
label_if = gr.Label(num_top_classes=3)
classify_if = gr. | Button() |
classify_if.click(
get_predictions,
[wb_token_if, image_if],
label_if
)
demo.launch(debug=True) | training_pipeline/huggingface/apps/gradio/app.py | deep-diver-TFX-WandB-05c63c4 | [
{
"filename": "training_pipeline/modules/common.py",
"retrieved_chunk": "IMAGE_TFREC_KEY = \"image\"\nIMAGE_SHAPE_TFREC_KEY = \"image_shape\"\nLABEL_TFREC_KEY = \"label\"\nMODEL_INPUT_IMAGE_KEY = \"pixel_values\"\nMODEL_INPUT_LABEL_KEY = \"labels\"\nIMAGE_MODEL_KEY = \"pixel_values\"\nLABEL_MODEL_KEY = \"labels\"\nCONCRETE_INPUT = \"pixel_values\"\nPRETRAIN_CHECKPOINT = \"google/vit-base-patch16-224-in21k\"\nLABELS = [\"angular_leaf_spot\", \"bean_rust\", \"healthy\"]",
"score": 0.7536649703979492
},
{
"filename": "training_pipeline/modules/preprocessing.py",
"retrieved_chunk": " \"\"\"\n # print(inputs)\n outputs = {}\n inputs[IMAGE_TFREC_KEY] = tf.image.resize(\n inputs[IMAGE_TFREC_KEY], [INPUT_IMG_SIZE, INPUT_IMG_SIZE]\n )\n inputs[IMAGE_TFREC_KEY] = inputs[IMAGE_TFREC_KEY] / 255.0\n inputs[IMAGE_TFREC_KEY] = tf.transpose(inputs[IMAGE_TFREC_KEY], [0, 3, 1, 2])\n outputs[IMAGE_MODEL_KEY] = inputs[IMAGE_TFREC_KEY]\n outputs[LABEL_MODEL_KEY] = inputs[LABEL_TFREC_KEY]",
"score": 0.749692976474762
},
{
"filename": "training_pipeline/pipeline/configs.py",
"retrieved_chunk": "}\nTUNER_CONFIGS = {\n \"num_trials\": 15\n}\nEVAL_CONFIGS = tfma.EvalConfig(\n model_specs=[\n tfma.ModelSpec(\n signature_name=\"from_examples\",\n preprocessing_function_names=[\"transform_features\"],\n label_key=\"labels\",",
"score": 0.7422865629196167
},
{
"filename": "training_pipeline/modules/preprocessing.py",
"retrieved_chunk": " return outputs",
"score": 0.741509199142456
},
{
"filename": "training_pipeline/pipeline/configs.py",
"retrieved_chunk": " \"min_replica_count\": 1,\n \"max_replica_count\": 1,\n },\n}\nGRADIO_APP_PATH = \"huggingface.apps.gradio\"\nWANDB_PUSHER_ARGS = {\n \"access_token\": \"$WANDB_ACCESS_TOKEN\",\n \"project_name\": PIPELINE_NAME,\n \"run_name\": WANDB_RUN_ID,\n \"model_name\": \"final_model\",",
"score": 0.7409595251083374
}
] | python | Button() |
from urllib.parse import quote
import pytest
from databasez import DatabaseURL
def test_database_url_repr():
u = DatabaseURL("postgresql://localhost/name")
assert repr(u) == "DatabaseURL('postgresql://localhost/name')"
u = DatabaseURL("postgresql://username@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username@localhost/name')"
u = DatabaseURL("postgresql://username:password@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username:********@localhost/name')"
u = DatabaseURL(f"postgresql://username:{quote('[password')}@localhost/name")
assert repr(u) == "DatabaseURL('postgresql://username:********@localhost/name')"
def test_database_url_properties():
u = DatabaseURL("postgresql+asyncpg://username:password@localhost:123/mydatabase")
assert u.dialect == "postgresql"
assert u.driver == "asyncpg"
assert u.username == "username"
assert u.password == "password"
assert u.hostname == "localhost"
assert u.port == 123
assert u.database == "mydatabase"
u = DatabaseURL(
"postgresql://username:password@/mydatabase?host=/var/run/postgresql/.s.PGSQL.5432"
)
assert u.dialect == "postgresql"
assert u.username == "username"
assert u.password == "password"
assert u.hostname == "/var/run/postgresql/.s.PGSQL.5432"
assert u.database == "mydatabase"
u = DatabaseURL(
"postgresql://username:password@/mydatabase?unix_sock=/var/run/postgresql/.s.PGSQL.5432"
)
assert u.hostname == "/var/run/postgresql/.s.PGSQL.5432"
def test_database_url_escape():
u = DatabaseURL(f"postgresql://username:{quote('[password')}@localhost/mydatabase")
assert u.username == "username"
assert u.password == "[password"
assert u.userinfo == f"username:{quote('[password')}".encode("utf-8")
u2 = DatabaseURL(u)
assert u2.password == "[password"
u3 = DatabaseURL(str(u))
assert u3.password == "[password"
def test_database_url_constructor():
with pytest.raises(TypeError):
DatabaseURL(("postgresql", "username", "password", "localhost", "mydatabase"))
u = DatabaseURL("postgresql+asyncpg://username:password@localhost:123/mydatabase")
assert DatabaseURL(u) == u
def test_database_url_options():
u = DatabaseURL("postgresql://localhost/mydatabase?pool_size=20&ssl=true")
assert u.options == {"pool_size": "20", "ssl": "true"}
u = DatabaseURL("mysql+asyncmy://username/testsuite?unix_socket=/tmp/mysqld/mysqld.sock")
assert u.options == {"unix_socket": "/tmp/mysqld/mysqld.sock"}
def test_replace_database_url_components():
u = DatabaseURL("postgresql://localhost/mydatabase")
assert u.database == "mydatabase"
new = u. | replace(database="test_" + u.database) |
assert new.database == "test_mydatabase"
assert str(new) == "postgresql://localhost/test_mydatabase"
assert u.driver == ""
new = u.replace(driver="asyncpg")
assert new.driver == "asyncpg"
assert str(new) == "postgresql+asyncpg://localhost/mydatabase"
assert u.port is None
new = u.replace(port=123)
assert new.port == 123
assert str(new) == "postgresql://localhost:123/mydatabase"
assert u.username is None
assert u.userinfo is None
u = DatabaseURL("sqlite:///mydatabase")
assert u.database == "mydatabase"
new = u.replace(database="test_" + u.database)
assert new.database == "test_mydatabase"
assert str(new) == "sqlite:///test_mydatabase"
u = DatabaseURL("sqlite:////absolute/path")
assert u.database == "/absolute/path"
new = u.replace(database=u.database + "_test")
assert new.database == "/absolute/path_test"
assert str(new) == "sqlite:////absolute/path_test"
| tests/test_database_url.py | tarsil-databasez-01b23b0 | [
{
"filename": "tests/test_connection_options.py",
"retrieved_chunk": "from databasez.core import DatabaseURL\ndef test_postgres_pool_size():\n backend = PostgresBackend(\"postgres://localhost/database?min_size=1&max_size=20\")\n kwargs = backend._get_connection_kwargs()\n assert kwargs == {\"min_size\": 1, \"max_size\": 20}\n@async_adapter\nasync def test_postgres_pool_size_connect():\n for url in DATABASE_URLS:\n if DatabaseURL(url).dialect != \"postgresql\":\n continue",
"score": 0.8359222412109375
},
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " data = {\"config\": database_url}\n async with Database(**data) as database:\n assert isinstance(database.url, DatabaseURL)\n if isinstance(database_url, str):\n assert database.url == database_url\n@pytest.mark.parametrize(\"database_url\", DATABASE_URLS)\n@async_adapter\nasync def test_concurrent_access_on_single_connection(database_url):\n database_url = DatabaseURL(database_url)\n if database_url.dialect != \"postgresql\":",
"score": 0.835466206073761
},
{
"filename": "databasez/core.py",
"retrieved_chunk": " return self._options\n def replace(self, **kwargs: typing.Any) -> \"DatabaseURL\":\n if (\n \"username\" in kwargs\n or \"password\" in kwargs\n or \"hostname\" in kwargs\n or \"port\" in kwargs\n ):\n hostname = kwargs.pop(\"hostname\", self.hostname)\n port = kwargs.pop(\"port\", self.port)",
"score": 0.8353722095489502
},
{
"filename": "tests/test_databases.py",
"retrieved_chunk": " data = {\"config\": database_url}\n database = Database(**data)\n assert not database.is_connected\n await database.connect()\n assert database.is_connected\n await database.disconnect()\n assert not database.is_connected\n # connect and disconnect idempotence\n await database.connect()\n await database.connect()",
"score": 0.8337365388870239
},
{
"filename": "databasez/testclient.py",
"retrieved_chunk": " drop_database: bool = False,\n **options: typing.Any,\n ):\n url = DatabaseURL(url) if isinstance(url, str) else url\n test_database_url = url.replace(database=\"test_\" + url.database)\n self.test_db_url = test_database_url._url\n self.use_existing = use_existing\n asyncio.get_event_loop().run_until_complete(self.setup())\n super().__init__(test_database_url, force_rollback=force_rollback, **options)\n self.drop = drop_database",
"score": 0.832423746585846
}
] | python | replace(database="test_" + u.database) |
import tarfile
import wandb
import gradio as gr
import numpy as np
from PIL import Image
import tensorflow as tf
from transformers import ViTFeatureExtractor
PRETRAIN_CHECKPOINT = "google/vit-base-patch16-224-in21k"
feature_extractor = ViTFeatureExtractor.from_pretrained(PRETRAIN_CHECKPOINT)
MODEL = None
RESOLTUION = 224
labels = []
with open(r"labels.txt", "r") as fp:
for line in fp:
labels.append(line[:-1])
def normalize_img(
img, mean=feature_extractor.image_mean, std=feature_extractor.image_std
):
img = img / 255
mean = tf.constant(mean)
std = tf.constant(std)
return (img - mean) / std
def preprocess_input(image):
image = np.array(image)
image = tf.convert_to_tensor(image)
image = tf.image.resize(image, (RESOLTUION, RESOLTUION))
image = normalize_img(image)
image = tf.transpose(
image, (2, 0, 1)
) # Since HF models are channel-first.
return {
"pixel_values": tf.expand_dims(image, 0)
}
def get_predictions(wb_token, image):
global MODEL
if MODEL is None:
wandb.login(key=wb_token)
wandb.init(project="$MODEL_PROJECT", id="$MODEL_RUN", resume=True)
path = wandb.use_artifact('tfx-vit-pipeline/$MODEL_NAME:$MODEL_VERSION', type='model').download()
tar = tarfile.open(f"{path}/$MODEL_FILENAME")
tar.extractall(path=".")
MODEL = tf.keras.models.load_model("./model")
preprocessed_image = preprocess_input(image)
prediction = MODEL.predict(preprocessed_image)
probs = tf.nn.softmax(prediction['logits'], axis=1)
confidences = {labels[i]: float(probs[0][i]) for i in range(3)}
return confidences
with gr.Blocks() as demo:
gr.Markdown("## Simple demo for a Image Classification of the Beans Dataset with HF ViT model")
wb_token_if = gr.Textbox(interactive=True, label="Your Weight & Biases API Key")
with gr.Row():
image_if = gr.Image()
label_if = gr. | Label(num_top_classes=3) |
classify_if = gr.Button()
classify_if.click(
get_predictions,
[wb_token_if, image_if],
label_if
)
demo.launch(debug=True) | training_pipeline/huggingface/apps/gradio/app.py | deep-diver-TFX-WandB-05c63c4 | [
{
"filename": "training_pipeline/modules/signatures.py",
"retrieved_chunk": " def serve_tf_examples_fn(\n serialized_tf_example: tf.Tensor,\n ) -> Dict[str, tf.Tensor]:\n raw_feature_spec = tf_transform_output.raw_feature_spec()\n raw_features = tf.io.parse_example(serialized_tf_example, raw_feature_spec)\n transformed_features = model.tft_layer(raw_features)\n logits = model(transformed_features).logits\n return {LABEL_MODEL_KEY: logits}\n return serve_tf_examples_fn",
"score": 0.774524450302124
},
{
"filename": "training_pipeline/modules/common.py",
"retrieved_chunk": "IMAGE_TFREC_KEY = \"image\"\nIMAGE_SHAPE_TFREC_KEY = \"image_shape\"\nLABEL_TFREC_KEY = \"label\"\nMODEL_INPUT_IMAGE_KEY = \"pixel_values\"\nMODEL_INPUT_LABEL_KEY = \"labels\"\nIMAGE_MODEL_KEY = \"pixel_values\"\nLABEL_MODEL_KEY = \"labels\"\nCONCRETE_INPUT = \"pixel_values\"\nPRETRAIN_CHECKPOINT = \"google/vit-base-patch16-224-in21k\"\nLABELS = [\"angular_leaf_spot\", \"bean_rust\", \"healthy\"]",
"score": 0.7654123306274414
},
{
"filename": "training_pipeline/modules/signatures.py",
"retrieved_chunk": " pred_source = tf.gather(params=labels, indices=indices)\n probs = tf.nn.softmax(predictions.logits, axis=1)\n pred_confidence = tf.reduce_max(probs, axis=1)\n return {\"label\": pred_source, \"confidence\": pred_confidence}\n return serving_fn\ndef transform_features_signature(\n model: tf.keras.Model, tf_transform_output: tft.TFTransformOutput\n):\n \"\"\"\n transform_features_signature simply returns a function that transforms",
"score": 0.7643142938613892
},
{
"filename": "training_pipeline/pipeline/configs.py",
"retrieved_chunk": " prediction_key=\"labels\",\n )\n ],\n slicing_specs=[tfma.SlicingSpec()],\n metrics_specs=[\n tfma.MetricsSpec(\n metrics=[\n tfma.MetricConfig(\n class_name=\"SparseCategoricalAccuracy\",\n threshold=tfma.MetricThreshold(",
"score": 0.7630734443664551
},
{
"filename": "training_pipeline/modules/preprocessing.py",
"retrieved_chunk": " \"\"\"\n # print(inputs)\n outputs = {}\n inputs[IMAGE_TFREC_KEY] = tf.image.resize(\n inputs[IMAGE_TFREC_KEY], [INPUT_IMG_SIZE, INPUT_IMG_SIZE]\n )\n inputs[IMAGE_TFREC_KEY] = inputs[IMAGE_TFREC_KEY] / 255.0\n inputs[IMAGE_TFREC_KEY] = tf.transpose(inputs[IMAGE_TFREC_KEY], [0, 3, 1, 2])\n outputs[IMAGE_MODEL_KEY] = inputs[IMAGE_TFREC_KEY]\n outputs[LABEL_MODEL_KEY] = inputs[LABEL_TFREC_KEY]",
"score": 0.7594226598739624
}
] | python | Label(num_top_classes=3) |
import tarfile
import wandb
import gradio as gr
import numpy as np
from PIL import Image
import tensorflow as tf
from transformers import ViTFeatureExtractor
PRETRAIN_CHECKPOINT = "google/vit-base-patch16-224-in21k"
feature_extractor = ViTFeatureExtractor.from_pretrained(PRETRAIN_CHECKPOINT)
MODEL = None
RESOLTUION = 224
labels = []
with open(r"labels.txt", "r") as fp:
for line in fp:
labels.append(line[:-1])
def normalize_img(
img, mean=feature_extractor.image_mean, std=feature_extractor.image_std
):
img = img / 255
mean = tf.constant(mean)
std = tf.constant(std)
return (img - mean) / std
def preprocess_input(image):
image = np.array(image)
image = tf.convert_to_tensor(image)
image = tf.image.resize(image, (RESOLTUION, RESOLTUION))
image = normalize_img(image)
image = tf.transpose(
image, (2, 0, 1)
) # Since HF models are channel-first.
return {
"pixel_values": tf.expand_dims(image, 0)
}
def get_predictions(wb_token, image):
global MODEL
if MODEL is None:
wandb.login(key=wb_token)
wandb.init(project="$MODEL_PROJECT", id="$MODEL_RUN", resume=True)
path = wandb.use_artifact('tfx-vit-pipeline/$MODEL_NAME:$MODEL_VERSION', type='model').download()
tar = tarfile.open(f"{path}/$MODEL_FILENAME")
tar.extractall(path=".")
MODEL = tf.keras.models.load_model("./model")
preprocessed_image = preprocess_input(image)
prediction = MODEL.predict(preprocessed_image)
probs = tf.nn.softmax(prediction['logits'], axis=1)
confidences = {labels[i]: float(probs[0][i]) for i in range(3)}
return confidences
with gr.Blocks() as demo:
gr.Markdown("## Simple demo for a Image Classification of the Beans Dataset with HF ViT model")
wb_token_if = gr. | Textbox(interactive=True, label="Your Weight & Biases API Key") |
with gr.Row():
image_if = gr.Image()
label_if = gr.Label(num_top_classes=3)
classify_if = gr.Button()
classify_if.click(
get_predictions,
[wb_token_if, image_if],
label_if
)
demo.launch(debug=True) | training_pipeline/huggingface/apps/gradio/app.py | deep-diver-TFX-WandB-05c63c4 | [
{
"filename": "training_pipeline/modules/common.py",
"retrieved_chunk": "IMAGE_TFREC_KEY = \"image\"\nIMAGE_SHAPE_TFREC_KEY = \"image_shape\"\nLABEL_TFREC_KEY = \"label\"\nMODEL_INPUT_IMAGE_KEY = \"pixel_values\"\nMODEL_INPUT_LABEL_KEY = \"labels\"\nIMAGE_MODEL_KEY = \"pixel_values\"\nLABEL_MODEL_KEY = \"labels\"\nCONCRETE_INPUT = \"pixel_values\"\nPRETRAIN_CHECKPOINT = \"google/vit-base-patch16-224-in21k\"\nLABELS = [\"angular_leaf_spot\", \"bean_rust\", \"healthy\"]",
"score": 0.8012819886207581
},
{
"filename": "training_pipeline/modules/signatures.py",
"retrieved_chunk": " def serve_tf_examples_fn(\n serialized_tf_example: tf.Tensor,\n ) -> Dict[str, tf.Tensor]:\n raw_feature_spec = tf_transform_output.raw_feature_spec()\n raw_features = tf.io.parse_example(serialized_tf_example, raw_feature_spec)\n transformed_features = model.tft_layer(raw_features)\n logits = model(transformed_features).logits\n return {LABEL_MODEL_KEY: logits}\n return serve_tf_examples_fn",
"score": 0.7797093987464905
},
{
"filename": "training_pipeline/modules/ViT.py",
"retrieved_chunk": "import tensorflow as tf\nimport keras_tuner\nfrom transformers import TFViTForImageClassification\nimport wandb\nfrom .common import LABELS\nfrom .common import PRETRAIN_CHECKPOINT\nfrom .utils import INFO\nclass MyHyperModel(keras_tuner.HyperModel):\n def build(self, hp):\n id2label={str(i): c for i, c in enumerate(LABELS)}",
"score": 0.7784905433654785
},
{
"filename": "training_pipeline/modules/preprocessing.py",
"retrieved_chunk": " \"\"\"\n # print(inputs)\n outputs = {}\n inputs[IMAGE_TFREC_KEY] = tf.image.resize(\n inputs[IMAGE_TFREC_KEY], [INPUT_IMG_SIZE, INPUT_IMG_SIZE]\n )\n inputs[IMAGE_TFREC_KEY] = inputs[IMAGE_TFREC_KEY] / 255.0\n inputs[IMAGE_TFREC_KEY] = tf.transpose(inputs[IMAGE_TFREC_KEY], [0, 3, 1, 2])\n outputs[IMAGE_MODEL_KEY] = inputs[IMAGE_TFREC_KEY]\n outputs[LABEL_MODEL_KEY] = inputs[LABEL_TFREC_KEY]",
"score": 0.7784160375595093
},
{
"filename": "training_pipeline/modules/ViT.py",
"retrieved_chunk": " label2id={c: str(i) for i, c in enumerate(LABELS)}\n model = TFViTForImageClassification.from_pretrained(\n PRETRAIN_CHECKPOINT,\n num_labels=len(LABELS),\n label2id=label2id,\n id2label=id2label,\n )\n model.layers[0].trainable=False\n with hp.conditional_scope(\"optimizer_type\", [\"AdamW\"]):\n optimizer = tf.keras.optimizers.experimental.AdamW(",
"score": 0.7757739424705505
}
] | python | Textbox(interactive=True, label="Your Weight & Biases API Key") |
import openai
import os
from dotenv import load_dotenv
from story_development.characters import Characters
load_dotenv()
openai.api_key = os.environ["OPENAI_API_KEY"]
conditioning_info = "target audience is a 5 year old boy.The story should help the reader overcome a fear of butterflies."
premise = '"The Butterfly Keeper": In a small village, a young boy named Juan loves catching and collecting butterflies. However, when he learns about the importance of butterflies in the ecosystem, he must reconcile his love of catching them with the need to protect them.'
outline = """Expanded Story Premise:
Characters:
- Juan, a curious and adventurous 5-year-old boy who loves catching butterflies.
- Abuela, Juan's grandmother, who is wise and caring. She is concerned about the butterflies' welfare and wants to teach Juan about their importance.
- The Butterfly Keeper, an expert on butterflies who lives outside the village. She is empathetic and patient and teaches Juan about the importance of butterflies in the ecosystem.
Setting:
- A small village surrounded by lush green forests and meadows.
- A butterfly garden filled with colorful flowers and plants, where Juan spends most of his time catching butterflies.
- The Butterfly Keeper's home, a cottage in the woods, surrounded by a butterfly sanctuary.
Themes:
- Caring for nature and its creatures.
- Empathy and understanding.
- Overcoming fears.
Outline:
Exposition:
- Juan loves catching and collecting butterflies in his butterfly garden. He doesn't understand why his grandmother, Abuela, is concerned about harming the butterflies.
- Abuela tells Juan about the importance of butterflies in the ecosystem, and how they help pollinate plants and flowers. She shows him how to care for the butterflies, and they release them back into the garden.
Rising Action:
- Juan spots a rare butterfly in his garden, which he wants to catch. Despite Abuela's warning, he chases after it but ends up getting hurt and scaring the butterfly away.
- Feeling guilty, Juan decides to learn more about how to care for butterflies. He asks Abuela for help, and she suggests that they visit the Butterfly Keeper to learn from an expert.
Climax:
- At the Butterfly Keeper's home, Juan learns about the different types of butterflies and how they contribute to the ecosystem. He also helps the Butterfly Keeper care for the butterflies and releases them back into their sanctuary.
- However, when Juan encounters a large butterfly, he becomes scared and runs away, leaving the butterfly in danger. The Butterfly Keeper tells Juan that having a fear of butterflies is okay, but he must learn to empathize with them and respect their place in nature.
Falling Action:
- Juan realizes his fear of butterflies stems from not knowing enough about them. He apologizes to the Butterfly Keeper and asks to learn more.
- The Butterfly Keeper teaches Juan how to gently hold and care for the butterflies, and Juan gains a newfound appreciation and understanding for these beautiful creatures.
Resolution:
- Juan returns home and shows Abuela all that he has learned while caring for the butterflies. He promises to protect and respect them, and never harm them again.
- The story ends with Juan and Abuela sitting in the butterfly garden, watching the beautiful creatures flutter around them, feeling grateful for all that they have learned."""
characters = Characters(conditioning_info, premise, outline)
characters.score(verbose=True, n=1)
recommendation = characters. | make_recommendation(verbose=True) | story_development/test_characters.py | knexer-ai-storyteller-86da1d3 | [
{
"filename": "story_development/test_outline.py",
"retrieved_chunk": "- However, when Juan encounters a large butterfly, he becomes scared and runs away, leaving the butterfly in danger. The Butterfly Keeper tells Juan that having a fear of butterflies is okay, but he must learn to empathize with them and respect their place in nature.\nFalling Action:\n- Juan realizes his fear of butterflies stems from not knowing enough about them. He apologizes to the Butterfly Keeper and asks to learn more.\n- The Butterfly Keeper teaches Juan how to gently hold and care for the butterflies, and Juan gains a newfound appreciation and understanding for these beautiful creatures.\nResolution:\n- Juan returns home and shows Abuela all that he has learned while caring for the butterflies. He promises to protect and respect them, and never harm them again.\n- The story ends with Juan and Abuela sitting in the butterfly garden, watching the beautiful creatures flutter around them, feeling grateful for all that they have learned.\"\"\"\noutline = Outline(conditioning_info, premise, outline)\noutline.score(verbose=True, n=3)\nrecommendations = outline.make_recommendations(1, verbose=True)",
"score": 0.9669548273086548
},
{
"filename": "story_development/test_setting.py",
"retrieved_chunk": "- However, when Juan encounters a large butterfly, he becomes scared and runs away, leaving the butterfly in danger. The Butterfly Keeper tells Juan that having a fear of butterflies is okay, but he must learn to empathize with them and respect their place in nature.\nFalling Action:\n- Juan realizes his fear of butterflies stems from not knowing enough about them. He apologizes to the Butterfly Keeper and asks to learn more.\n- The Butterfly Keeper teaches Juan how to gently hold and care for the butterflies, and Juan gains a newfound appreciation and understanding for these beautiful creatures.\nResolution:\n- Juan returns home and shows Abuela all that he has learned while caring for the butterflies. He promises to protect and respect them, and never harm them again.\n- The story ends with Juan and Abuela sitting in the butterfly garden, watching the beautiful creatures flutter around them, feeling grateful for all that they have learned.\"\"\"\nsetting = Setting(conditioning_info, premise, outline)\nsetting.score(verbose=True, n=3)\nrecommendations = setting.make_recommendations(1, verbose=True)",
"score": 0.965682864189148
},
{
"filename": "story_development/test_apply_recommendation.py",
"retrieved_chunk": "- At the Butterfly Keeper's home, Juan learns about the different types of butterflies and how they contribute to the ecosystem. He also helps the Butterfly Keeper care for the butterflies and releases them back into their sanctuary.\n- However, when Juan encounters a large butterfly, he becomes scared and runs away, leaving the butterfly in danger. The Butterfly Keeper tells Juan that having a fear of butterflies is okay, but he must learn to empathize with them and respect their place in nature.\nFalling Action:\n- Juan realizes his fear of butterflies stems from not knowing enough about them. He apologizes to the Butterfly Keeper and asks to learn more.\n- The Butterfly Keeper teaches Juan how to gently hold and care for the butterflies, and Juan gains a newfound appreciation and understanding for these beautiful creatures.\nResolution:\n- Juan returns home and shows Abuela all that he has learned while caring for the butterflies. He promises to protect and respect them, and never harm them again.\n- The story ends with Juan and Abuela sitting in the butterfly garden, watching the beautiful creatures flutter around them, feeling grateful for all that they have learned.\"\"\"\ncharacters = Characters(conditioning_info, premise, outline)\nindividual = Individual(characters)",
"score": 0.9618179202079773
},
{
"filename": "story_development/test_themes.py",
"retrieved_chunk": "- However, when Juan encounters a large butterfly, he becomes scared and runs away, leaving the butterfly in danger. The Butterfly Keeper tells Juan that having a fear of butterflies is okay, but he must learn to empathize with them and respect their place in nature.\nFalling Action:\n- Juan realizes his fear of butterflies stems from not knowing enough about them. He apologizes to the Butterfly Keeper and asks to learn more.\n- The Butterfly Keeper teaches Juan how to gently hold and care for the butterflies, and Juan gains a newfound appreciation and understanding for these beautiful creatures.\nResolution:\n- Juan returns home and shows Abuela all that he has learned while caring for the butterflies. He promises to protect and respect them, and never harm them again.\n- The story ends with Juan and Abuela sitting in the butterfly garden, watching the beautiful creatures flutter around them, feeling grateful for all that they have learned.\"\"\"\nthemes = Themes(conditioning_info, premise, outline)\nthemes.score(verbose=True, n=3)\nrecommendations = themes.make_recommendations(1, verbose=True)",
"score": 0.9600164890289307
},
{
"filename": "story_development/test_feedback.py",
"retrieved_chunk": "- However, when Juan encounters a large butterfly, he becomes scared and runs away, leaving the butterfly in danger. The Butterfly Keeper tells Juan that having a fear of butterflies is okay, but he must learn to empathize with them and respect their place in nature.\nFalling Action:\n- Juan realizes his fear of butterflies stems from not knowing enough about them. He apologizes to the Butterfly Keeper and asks to learn more.\n- The Butterfly Keeper teaches Juan how to gently hold and care for the butterflies, and Juan gains a newfound appreciation and understanding for these beautiful creatures.\nResolution:\n- Juan returns home and shows Abuela all that he has learned while caring for the butterflies. He promises to protect and respect them, and never harm them again.\n- The story ends with Juan and Abuela sitting in the butterfly garden, watching the beautiful creatures flutter around them, feeling grateful for all that they have learned.\"\"\"\nga = DevelopmentGA(conditioning_info, premise, [outline])\nga.get_feedback(outline, verbose=True)",
"score": 0.9544881582260132
}
] | python | make_recommendation(verbose=True) |
|
import tarfile
import wandb
import gradio as gr
import numpy as np
from PIL import Image
import tensorflow as tf
from transformers import ViTFeatureExtractor
PRETRAIN_CHECKPOINT = "google/vit-base-patch16-224-in21k"
feature_extractor = ViTFeatureExtractor.from_pretrained(PRETRAIN_CHECKPOINT)
MODEL = None
RESOLTUION = 224
labels = []
with open(r"labels.txt", "r") as fp:
for line in fp:
labels.append(line[:-1])
def normalize_img(
img, mean=feature_extractor.image_mean, std=feature_extractor.image_std
):
img = img / 255
mean = tf.constant(mean)
std = tf.constant(std)
return (img - mean) / std
def preprocess_input(image):
image = np.array(image)
image = tf.convert_to_tensor(image)
image = tf.image.resize(image, (RESOLTUION, RESOLTUION))
image = normalize_img(image)
image = tf.transpose(
image, (2, 0, 1)
) # Since HF models are channel-first.
return {
"pixel_values": tf.expand_dims(image, 0)
}
def get_predictions(wb_token, image):
global MODEL
if MODEL is None:
wandb.login(key=wb_token)
wandb.init(project="$MODEL_PROJECT", id="$MODEL_RUN", resume=True)
path = wandb.use_artifact('tfx-vit-pipeline/$MODEL_NAME:$MODEL_VERSION', type='model').download()
tar = tarfile.open(f"{path}/$MODEL_FILENAME")
tar.extractall(path=".")
MODEL = tf.keras.models.load_model("./model")
preprocessed_image = preprocess_input(image)
prediction = MODEL.predict(preprocessed_image)
probs = tf.nn.softmax(prediction['logits'], axis=1)
confidences = {labels[i]: float(probs[0][i]) for i in range(3)}
return confidences
with gr.Blocks() as demo:
gr.Markdown("## Simple demo for a Image Classification of the Beans Dataset with HF ViT model")
wb_token_if = gr.Textbox(interactive=True, label="Your Weight & Biases API Key")
with gr. | Row(): |
image_if = gr.Image()
label_if = gr.Label(num_top_classes=3)
classify_if = gr.Button()
classify_if.click(
get_predictions,
[wb_token_if, image_if],
label_if
)
demo.launch(debug=True) | training_pipeline/huggingface/apps/gradio/app.py | deep-diver-TFX-WandB-05c63c4 | [
{
"filename": "training_pipeline/modules/common.py",
"retrieved_chunk": "IMAGE_TFREC_KEY = \"image\"\nIMAGE_SHAPE_TFREC_KEY = \"image_shape\"\nLABEL_TFREC_KEY = \"label\"\nMODEL_INPUT_IMAGE_KEY = \"pixel_values\"\nMODEL_INPUT_LABEL_KEY = \"labels\"\nIMAGE_MODEL_KEY = \"pixel_values\"\nLABEL_MODEL_KEY = \"labels\"\nCONCRETE_INPUT = \"pixel_values\"\nPRETRAIN_CHECKPOINT = \"google/vit-base-patch16-224-in21k\"\nLABELS = [\"angular_leaf_spot\", \"bean_rust\", \"healthy\"]",
"score": 0.7977112531661987
},
{
"filename": "training_pipeline/modules/preprocessing.py",
"retrieved_chunk": " \"\"\"\n # print(inputs)\n outputs = {}\n inputs[IMAGE_TFREC_KEY] = tf.image.resize(\n inputs[IMAGE_TFREC_KEY], [INPUT_IMG_SIZE, INPUT_IMG_SIZE]\n )\n inputs[IMAGE_TFREC_KEY] = inputs[IMAGE_TFREC_KEY] / 255.0\n inputs[IMAGE_TFREC_KEY] = tf.transpose(inputs[IMAGE_TFREC_KEY], [0, 3, 1, 2])\n outputs[IMAGE_MODEL_KEY] = inputs[IMAGE_TFREC_KEY]\n outputs[LABEL_MODEL_KEY] = inputs[LABEL_TFREC_KEY]",
"score": 0.7645038366317749
},
{
"filename": "training_pipeline/modules/signatures.py",
"retrieved_chunk": " def serve_tf_examples_fn(\n serialized_tf_example: tf.Tensor,\n ) -> Dict[str, tf.Tensor]:\n raw_feature_spec = tf_transform_output.raw_feature_spec()\n raw_features = tf.io.parse_example(serialized_tf_example, raw_feature_spec)\n transformed_features = model.tft_layer(raw_features)\n logits = model(transformed_features).logits\n return {LABEL_MODEL_KEY: logits}\n return serve_tf_examples_fn",
"score": 0.763522744178772
},
{
"filename": "training_pipeline/modules/ViT.py",
"retrieved_chunk": " label2id={c: str(i) for i, c in enumerate(LABELS)}\n model = TFViTForImageClassification.from_pretrained(\n PRETRAIN_CHECKPOINT,\n num_labels=len(LABELS),\n label2id=label2id,\n id2label=id2label,\n )\n model.layers[0].trainable=False\n with hp.conditional_scope(\"optimizer_type\", [\"AdamW\"]):\n optimizer = tf.keras.optimizers.experimental.AdamW(",
"score": 0.7630225419998169
},
{
"filename": "training_pipeline/modules/signatures.py",
"retrieved_chunk": "def model_exporter(model: tf.keras.Model):\n m_call = tf.function(model.call).get_concrete_function(\n tf.TensorSpec(shape=[None, 3, 224, 224], dtype=tf.float32, name=CONCRETE_INPUT)\n )\n @tf.function(input_signature=[tf.TensorSpec([None], tf.string)])\n def serving_fn(string_input):\n labels = tf.constant(list(model.config.id2label.values()), dtype=tf.string)\n images = _preprocess_fn(string_input)\n predictions = m_call(**images)\n indices = tf.argmax(predictions.logits, axis=1)",
"score": 0.7568863034248352
}
] | python | Row(): |
import tarfile
import wandb
import gradio as gr
import numpy as np
from PIL import Image
import tensorflow as tf
from transformers import ViTFeatureExtractor
PRETRAIN_CHECKPOINT = "google/vit-base-patch16-224-in21k"
feature_extractor = ViTFeatureExtractor.from_pretrained(PRETRAIN_CHECKPOINT)
MODEL = None
RESOLTUION = 224
labels = []
with open(r"labels.txt", "r") as fp:
for line in fp:
labels.append(line[:-1])
def normalize_img(
img, mean=feature_extractor.image_mean, std=feature_extractor.image_std
):
img = img / 255
mean = tf.constant(mean)
std = tf.constant(std)
return (img - mean) / std
def preprocess_input(image):
image = np.array(image)
image = tf.convert_to_tensor(image)
image = tf.image.resize(image, (RESOLTUION, RESOLTUION))
image = normalize_img(image)
image = tf.transpose(
image, (2, 0, 1)
) # Since HF models are channel-first.
return {
"pixel_values": tf.expand_dims(image, 0)
}
def get_predictions(wb_token, image):
global MODEL
if MODEL is None:
wandb.login(key=wb_token)
wandb.init(project="$MODEL_PROJECT", id="$MODEL_RUN", resume=True)
path = wandb.use_artifact('tfx-vit-pipeline/$MODEL_NAME:$MODEL_VERSION', type='model').download()
tar = tarfile.open(f"{path}/$MODEL_FILENAME")
tar.extractall(path=".")
MODEL = tf.keras.models.load_model("./model")
preprocessed_image = preprocess_input(image)
prediction = MODEL.predict(preprocessed_image)
probs = tf.nn.softmax(prediction['logits'], axis=1)
confidences = {labels[i]: float(probs[0][i]) for i in range(3)}
return confidences
with gr. | Blocks() as demo: |
gr.Markdown("## Simple demo for a Image Classification of the Beans Dataset with HF ViT model")
wb_token_if = gr.Textbox(interactive=True, label="Your Weight & Biases API Key")
with gr.Row():
image_if = gr.Image()
label_if = gr.Label(num_top_classes=3)
classify_if = gr.Button()
classify_if.click(
get_predictions,
[wb_token_if, image_if],
label_if
)
demo.launch(debug=True) | training_pipeline/huggingface/apps/gradio/app.py | deep-diver-TFX-WandB-05c63c4 | [
{
"filename": "training_pipeline/modules/common.py",
"retrieved_chunk": "IMAGE_TFREC_KEY = \"image\"\nIMAGE_SHAPE_TFREC_KEY = \"image_shape\"\nLABEL_TFREC_KEY = \"label\"\nMODEL_INPUT_IMAGE_KEY = \"pixel_values\"\nMODEL_INPUT_LABEL_KEY = \"labels\"\nIMAGE_MODEL_KEY = \"pixel_values\"\nLABEL_MODEL_KEY = \"labels\"\nCONCRETE_INPUT = \"pixel_values\"\nPRETRAIN_CHECKPOINT = \"google/vit-base-patch16-224-in21k\"\nLABELS = [\"angular_leaf_spot\", \"bean_rust\", \"healthy\"]",
"score": 0.7814769148826599
},
{
"filename": "training_pipeline/modules/signatures.py",
"retrieved_chunk": " def serve_tf_examples_fn(\n serialized_tf_example: tf.Tensor,\n ) -> Dict[str, tf.Tensor]:\n raw_feature_spec = tf_transform_output.raw_feature_spec()\n raw_features = tf.io.parse_example(serialized_tf_example, raw_feature_spec)\n transformed_features = model.tft_layer(raw_features)\n logits = model(transformed_features).logits\n return {LABEL_MODEL_KEY: logits}\n return serve_tf_examples_fn",
"score": 0.775022566318512
},
{
"filename": "training_pipeline/modules/signatures.py",
"retrieved_chunk": "def model_exporter(model: tf.keras.Model):\n m_call = tf.function(model.call).get_concrete_function(\n tf.TensorSpec(shape=[None, 3, 224, 224], dtype=tf.float32, name=CONCRETE_INPUT)\n )\n @tf.function(input_signature=[tf.TensorSpec([None], tf.string)])\n def serving_fn(string_input):\n labels = tf.constant(list(model.config.id2label.values()), dtype=tf.string)\n images = _preprocess_fn(string_input)\n predictions = m_call(**images)\n indices = tf.argmax(predictions.logits, axis=1)",
"score": 0.7725035548210144
},
{
"filename": "training_pipeline/modules/preprocessing.py",
"retrieved_chunk": " \"\"\"\n # print(inputs)\n outputs = {}\n inputs[IMAGE_TFREC_KEY] = tf.image.resize(\n inputs[IMAGE_TFREC_KEY], [INPUT_IMG_SIZE, INPUT_IMG_SIZE]\n )\n inputs[IMAGE_TFREC_KEY] = inputs[IMAGE_TFREC_KEY] / 255.0\n inputs[IMAGE_TFREC_KEY] = tf.transpose(inputs[IMAGE_TFREC_KEY], [0, 3, 1, 2])\n outputs[IMAGE_MODEL_KEY] = inputs[IMAGE_TFREC_KEY]\n outputs[LABEL_MODEL_KEY] = inputs[LABEL_TFREC_KEY]",
"score": 0.7677284479141235
},
{
"filename": "training_pipeline/pipeline/components/WandBPusher/runner.py",
"retrieved_chunk": " dst_content = f\"{tmp_dir}/{content_name}\"\n if tf.io.gfile.isdir(content):\n io_utils.copy_dir(content, dst_content)\n else:\n tf.io.gfile.copy(content, dst_content)\n print(f\"copied SavedModel from {model_path} to the temporary dir({tmp_dir})\")\n compressed_model_file = \"model.tar.gz\"\n tar = tarfile.open(compressed_model_file, \"w:gz\")\n tar.add(tmp_dir)\n tar.close()",
"score": 0.76081383228302
}
] | python | Blocks() as demo: |
import tarfile
import wandb
import gradio as gr
import numpy as np
from PIL import Image
import tensorflow as tf
from transformers import ViTFeatureExtractor
PRETRAIN_CHECKPOINT = "google/vit-base-patch16-224-in21k"
feature_extractor = ViTFeatureExtractor.from_pretrained(PRETRAIN_CHECKPOINT)
MODEL = None
RESOLTUION = 224
labels = []
with open(r"labels.txt", "r") as fp:
for line in fp:
labels.append(line[:-1])
def normalize_img(
img, mean=feature_extractor.image_mean, std=feature_extractor.image_std
):
img = img / 255
mean = tf.constant(mean)
std = tf.constant(std)
return (img - mean) / std
def preprocess_input(image):
image = np.array(image)
image = tf.convert_to_tensor(image)
image = tf.image.resize(image, (RESOLTUION, RESOLTUION))
image = normalize_img(image)
image = tf.transpose(
image, (2, 0, 1)
) # Since HF models are channel-first.
return {
"pixel_values": tf.expand_dims(image, 0)
}
def get_predictions(wb_token, image):
global MODEL
if MODEL is None:
wandb.login(key=wb_token)
wandb.init(project="$MODEL_PROJECT", id="$MODEL_RUN", resume=True)
path = wandb.use_artifact('tfx-vit-pipeline/$MODEL_NAME:$MODEL_VERSION', type='model').download()
tar = tarfile.open(f"{path}/$MODEL_FILENAME")
tar.extractall(path=".")
MODEL = tf.keras.models.load_model("./model")
preprocessed_image = preprocess_input(image)
prediction = MODEL.predict(preprocessed_image)
probs = tf.nn.softmax(prediction['logits'], axis=1)
confidences = {labels[i]: float(probs[0][i]) for i in range(3)}
return confidences
with gr.Blocks() as demo:
gr.Markdown("## Simple demo for a Image Classification of the Beans Dataset with HF ViT model")
wb_token_if = gr.Textbox(interactive=True, label="Your Weight & Biases API Key")
with gr.Row():
image_if = gr. | Image() |
label_if = gr.Label(num_top_classes=3)
classify_if = gr.Button()
classify_if.click(
get_predictions,
[wb_token_if, image_if],
label_if
)
demo.launch(debug=True) | training_pipeline/huggingface/apps/gradio/app.py | deep-diver-TFX-WandB-05c63c4 | [
{
"filename": "training_pipeline/modules/common.py",
"retrieved_chunk": "IMAGE_TFREC_KEY = \"image\"\nIMAGE_SHAPE_TFREC_KEY = \"image_shape\"\nLABEL_TFREC_KEY = \"label\"\nMODEL_INPUT_IMAGE_KEY = \"pixel_values\"\nMODEL_INPUT_LABEL_KEY = \"labels\"\nIMAGE_MODEL_KEY = \"pixel_values\"\nLABEL_MODEL_KEY = \"labels\"\nCONCRETE_INPUT = \"pixel_values\"\nPRETRAIN_CHECKPOINT = \"google/vit-base-patch16-224-in21k\"\nLABELS = [\"angular_leaf_spot\", \"bean_rust\", \"healthy\"]",
"score": 0.802382230758667
},
{
"filename": "training_pipeline/modules/signatures.py",
"retrieved_chunk": " def serve_tf_examples_fn(\n serialized_tf_example: tf.Tensor,\n ) -> Dict[str, tf.Tensor]:\n raw_feature_spec = tf_transform_output.raw_feature_spec()\n raw_features = tf.io.parse_example(serialized_tf_example, raw_feature_spec)\n transformed_features = model.tft_layer(raw_features)\n logits = model(transformed_features).logits\n return {LABEL_MODEL_KEY: logits}\n return serve_tf_examples_fn",
"score": 0.7814124226570129
},
{
"filename": "training_pipeline/modules/preprocessing.py",
"retrieved_chunk": " \"\"\"\n # print(inputs)\n outputs = {}\n inputs[IMAGE_TFREC_KEY] = tf.image.resize(\n inputs[IMAGE_TFREC_KEY], [INPUT_IMG_SIZE, INPUT_IMG_SIZE]\n )\n inputs[IMAGE_TFREC_KEY] = inputs[IMAGE_TFREC_KEY] / 255.0\n inputs[IMAGE_TFREC_KEY] = tf.transpose(inputs[IMAGE_TFREC_KEY], [0, 3, 1, 2])\n outputs[IMAGE_MODEL_KEY] = inputs[IMAGE_TFREC_KEY]\n outputs[LABEL_MODEL_KEY] = inputs[LABEL_TFREC_KEY]",
"score": 0.777604341506958
},
{
"filename": "training_pipeline/modules/ViT.py",
"retrieved_chunk": " label2id={c: str(i) for i, c in enumerate(LABELS)}\n model = TFViTForImageClassification.from_pretrained(\n PRETRAIN_CHECKPOINT,\n num_labels=len(LABELS),\n label2id=label2id,\n id2label=id2label,\n )\n model.layers[0].trainable=False\n with hp.conditional_scope(\"optimizer_type\", [\"AdamW\"]):\n optimizer = tf.keras.optimizers.experimental.AdamW(",
"score": 0.7692323923110962
},
{
"filename": "training_pipeline/modules/ViT.py",
"retrieved_chunk": "import tensorflow as tf\nimport keras_tuner\nfrom transformers import TFViTForImageClassification\nimport wandb\nfrom .common import LABELS\nfrom .common import PRETRAIN_CHECKPOINT\nfrom .utils import INFO\nclass MyHyperModel(keras_tuner.HyperModel):\n def build(self, hp):\n id2label={str(i): c for i, c in enumerate(LABELS)}",
"score": 0.7661297917366028
}
] | python | Image() |
Subsets and Splits