id int64 0 328k | repository_name stringlengths 7 58 | file_path stringlengths 9 302 | class_name stringlengths 5 256 | gold_code stringlengths 16 2.16M | v3_prompt_text stringlengths 90 96.1k | v3_target_text stringlengths 8 2.16M | imports stringlengths 0 54.7k | class_docstring stringclasses 1
value | num_functions int64 0 800 | num_cross_deps int64 0 755 | parallelizable_bodies int64 0 384 | docstring_coverage float64 0 1 | parse_ok bool 1
class | parse_error stringclasses 1
value | source stringclasses 1
value | body_spans_json stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
200 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/commands/chat.py | transformers.commands.chat.ChatArguments | from dataclasses import dataclass, field
from typing import Optional
@dataclass
class ChatArguments:
"""
Arguments for the chat CLI.
See the metadata arg for each argument's description -- the medatata will be printed with
`transformers chat --help`
"""
model_name_or_path: Optional[str] = fiel... | """Arguments for the chat CLI.
See the metadata arg for each argument's description -- the medatata will be printed with
`transformers chat --help`
Required methods (implement on the class; order is not specified):
- `__post_init__(self)`: Only used for BC `torch_dtype` argument."""
from dataclasses import dataclass,... | class ChatArguments:
"""
Arguments for the chat CLI.
See the metadata arg for each argument's description -- the medatata will be printed with
`transformers chat --help`
"""
model_name_or_path: Optional[str] = field(default=None, metadata={'help': 'Name of the pre-trained model. The positional ... | from dataclasses import dataclass, field
from typing import Optional | 1 | 0 | 1 | 1 | true | mrahman2025/OpenClassGen | [] | ||
201 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/commands/chat.py | transformers.commands.chat.ChatCommand | import asyncio
import copy
from transformers import AutoTokenizer, GenerationConfig, PreTrainedTokenizer
import platform
import os
import yaml
from argparse import ArgumentParser, Namespace
from transformers.commands import BaseTransformersCLICommand
from transformers.utils import is_rich_available, is_torch_available
... | """Implement class ChatCommand.
Required methods (implement on the class; order is not specified):
- `register_subcommand(parser: ArgumentParser)`: Register this command to argparse so it's available for the transformer-cli
- `__init__(self, args)`
- `get_username()`: Returns the username of the current user.
- `save_... |
@staticmethod
def register_subcommand(parser: ArgumentParser):
"""
Register this command to argparse so it's available for the transformer-cli
Args:
parser: Root parser to register command-specific arguments
"""
dataclass_types = (ChatArguments,)
cha... | import asyncio
import copy
from transformers import AutoTokenizer, GenerationConfig, PreTrainedTokenizer
import platform
import os
import yaml
from argparse import ArgumentParser, Namespace
from transformers.commands import BaseTransformersCLICommand
from transformers.utils import is_rich_available, is_torch_available
... | 13 | 10 | 8 | 0.615385 | true | mrahman2025/OpenClassGen | [] | ||
202 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/commands/chat.py | transformers.commands.chat.RichInterface | import re
from transformers import AutoTokenizer, GenerationConfig, PreTrainedTokenizer
from typing import Optional
from huggingface_hub import AsyncInferenceClient, ChatCompletionStreamOutput
from collections.abc import AsyncIterator
class RichInterface:
def __init__(self, model_name: Optional[str]=None, user_na... | """Implement class RichInterface.
Required methods (implement on the class; order is not specified):
- `__init__(self, model_name: Optional[str]=None, user_name: Optional[str]=None)`
- `stream_output(self, stream: AsyncIterator[ChatCompletionStreamOutput])`
- `input(self)`: Gets user input from the console.
- `clear(s... |
def __init__(self, model_name: Optional[str]=None, user_name: Optional[str]=None):
self._console = Console()
if model_name is None:
self.model_name = 'assistant'
else:
self.model_name = model_name
if user_name is None:
self.user_name = 'user'
... | import re
from transformers import AutoTokenizer, GenerationConfig, PreTrainedTokenizer
from typing import Optional
from huggingface_hub import AsyncInferenceClient, ChatCompletionStreamOutput
from collections.abc import AsyncIterator | 8 | 0 | 8 | 0.75 | true | mrahman2025/OpenClassGen | [] | ||
203 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/commands/download.py | transformers.commands.download.DownloadCommand | from . import BaseTransformersCLICommand
from argparse import ArgumentParser
class DownloadCommand(BaseTransformersCLICommand):
@staticmethod
def register_subcommand(parser: ArgumentParser):
download_parser = parser.add_parser('download')
download_parser.add_argument('--cache-dir', type=str, d... | """Implement class DownloadCommand.
Required methods (implement on the class; order is not specified):
- `register_subcommand(parser: ArgumentParser)`
- `__init__(self, model: str, cache: str, force: bool, trust_remote_code: bool)`
- `run(self)`"""
from . import BaseTransformersCLICommand
from argparse import Argument... |
@staticmethod
def register_subcommand(parser: ArgumentParser):
download_parser = parser.add_parser('download')
download_parser.add_argument('--cache-dir', type=str, default=None, help='Path to location to store the models')
download_parser.add_argument('--force', action='store_true', he... | from . import BaseTransformersCLICommand
from argparse import ArgumentParser | 3 | 0 | 3 | 0 | true | mrahman2025/OpenClassGen | [] | ||
204 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/commands/env.py | transformers.commands.env.EnvironmentCommand | from .. import __version__ as version
from argparse import ArgumentParser
from . import BaseTransformersCLICommand
import platform
import io
import importlib.util
import os
from ..integrations.deepspeed import is_deepspeed_available
import huggingface_hub
from ..utils import is_accelerate_available, is_safetensors_avai... | """Implement class EnvironmentCommand.
Required methods (implement on the class; order is not specified):
- `register_subcommand(parser: ArgumentParser)`
- `__init__(self, accelerate_config_file, *args)`
- `run(self)`
- `format_dict(d)`"""
from .. import __version__ as version
from argparse import ArgumentParser
from ... |
@staticmethod
def register_subcommand(parser: ArgumentParser):
download_parser = parser.add_parser('env')
download_parser.set_defaults(func=info_command_factory)
download_parser.add_argument('--accelerate-config_file', default=None, help='The accelerate config file to use for the defaul... | from .. import __version__ as version
from argparse import ArgumentParser
from . import BaseTransformersCLICommand
import platform
import io
import importlib.util
import os
from ..integrations.deepspeed import is_deepspeed_available
import huggingface_hub
from ..utils import is_accelerate_available, is_safetensors_avai... | 4 | 1 | 3 | 0 | true | mrahman2025/OpenClassGen | [] | ||
205 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/commands/run.py | transformers.commands.run.RunCommand | from argparse import ArgumentParser
from . import BaseTransformersCLICommand
from ..pipelines import Pipeline, PipelineDataFormat, get_supported_tasks, pipeline
class RunCommand(BaseTransformersCLICommand):
def __init__(self, nlp: Pipeline, reader: PipelineDataFormat):
self._nlp = nlp
self._reader... | """Implement class RunCommand.
Required methods (implement on the class; order is not specified):
- `__init__(self, nlp: Pipeline, reader: PipelineDataFormat)`
- `register_subcommand(parser: ArgumentParser)`
- `run(self)`"""
from argparse import ArgumentParser
from . import BaseTransformersCLICommand
from ..pipelines ... |
def __init__(self, nlp: Pipeline, reader: PipelineDataFormat):
self._nlp = nlp
self._reader = reader
@staticmethod
def register_subcommand(parser: ArgumentParser):
run_parser = parser.add_parser('run', help='Run a pipeline through the CLI')
run_parser.add_argument('--task',... | from argparse import ArgumentParser
from . import BaseTransformersCLICommand
from ..pipelines import Pipeline, PipelineDataFormat, get_supported_tasks, pipeline | 3 | 0 | 3 | 0 | true | mrahman2025/OpenClassGen | [] | ||
206 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/commands/serving.py | transformers.commands.serving.ServeCommand | import functools
import uuid
from transformers.models.auto.modeling_auto import MODEL_FOR_CAUSAL_LM_MAPPING_NAMES, MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES
import base64
from threading import Thread
from io import BytesIO
import asyncio
from tokenizers.decoders import DecodeStream
from typing import Optional, Union
i... | """Implement class ServeCommand.
Required methods (implement on the class; order is not specified):
- `register_subcommand(parser: ArgumentParser)`: Register this command to argparse so it's available for the transformer-cli
- `__init__(self, args: ServeArguments)`
- `_validate_request(self, request: dict, schema: '_T... |
@staticmethod
def register_subcommand(parser: ArgumentParser):
"""
Register this command to argparse so it's available for the transformer-cli
Args:
parser: Root parser to register command-specific arguments
"""
dataclass_types = (ServeArguments,)
se... | import functools
import uuid
from transformers.models.auto.modeling_auto import MODEL_FOR_CAUSAL_LM_MAPPING_NAMES, MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES
import base64
from threading import Thread
from io import BytesIO
import asyncio
from tokenizers.decoders import DecodeStream
from typing import Optional, Union
i... | 22 | 29 | 11 | 0.727273 | true | mrahman2025/OpenClassGen | [] | ||
207 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/configuration_utils.py | transformers.configuration_utils.PretrainedConfig | import os
from .utils.generic import is_timm_config_dict
from .dynamic_module_utils import custom_object_save
import copy
import warnings
from .modeling_gguf_pytorch_utils import load_gguf_checkpoint
import json
from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
from . import __version__
from .utils import... | """Base class for all configuration classes. Handles a few parameters common to all models' configurations as well as
methods for loading/downloading/saving configurations.
<Tip>
A configuration file can be loaded and saved to disk. Loading the configuration file and using this file to
initialize a model does **not**... | """
Base class for all configuration classes. Handles a few parameters common to all models' configurations as well as
methods for loading/downloading/saving configurations.
<Tip>
A configuration file can be loaded and saved to disk. Loading the configuration file and using this file to
initia... | import os
from .utils.generic import is_timm_config_dict
from .dynamic_module_utils import custom_object_save
import copy
import warnings
from .modeling_gguf_pytorch_utils import load_gguf_checkpoint
import json
from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
from . import __version__
from .utils import... | 40 | 19 | 28 | 0.575 | true | mrahman2025/OpenClassGen | [] | ||
208 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.AlbertConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class AlbertConverter(SpmConverter):
def vocab(self, proto):
return [(piece.piece, piece.score) if check_number_comma(piece.piece) else (piece.piece, piece.score - 100) for piece in proto.pieces]
de... | """Implement class AlbertConverter.
Required methods (implement on the class; order is not specified):
- `vocab(self, proto)`
- `normalizer(self, proto)`
- `post_processor(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class AlbertConverter: |
def vocab(self, proto):
return [(piece.piece, piece.score) if check_number_comma(piece.piece) else (piece.piece, piece.score - 100) for piece in proto.pieces]
def normalizer(self, proto):
list_normalizers = [normalizers.Replace('``', '"'), normalizers.Replace("''", '"')]
if not self.or... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 3 | 0 | 3 | 0 | true | mrahman2025/OpenClassGen | [] | ||
209 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.BarthezConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class BarthezConverter(SpmConverter):
def unk_id(self, proto):
unk_id = 3
return unk_id
def post_processor(self):
return processors.TemplateProcessing(single='<s> $A </s>', pair='<s>... | """Implement class BarthezConverter.
Required methods (implement on the class; order is not specified):
- `unk_id(self, proto)`
- `post_processor(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class BarthezConverter: |
def unk_id(self, proto):
unk_id = 3
return unk_id
def post_processor(self):
return processors.TemplateProcessing(single='<s> $A </s>', pair='<s> $A </s> </s> $B </s>', special_tokens=[('<s>', self.original_tokenizer.convert_tokens_to_ids('<s>')), ('</s>', self.original_tokenizer.conver... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 2 | 0 | 2 | 0 | true | mrahman2025/OpenClassGen | [] | ||
210 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.BertConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
class BertConverter(Converter):
def converted(self) -> Tokenizer:
vocab = self.original_tokenizer.vocab
tokenizer = Tokenizer(WordPiece(vocab... | """Implement class BertConverter.
Required methods (implement on the class; order is not specified):
- `converted(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
class BertConverter: |
def converted(self) -> Tokenizer:
vocab = self.original_tokenizer.vocab
tokenizer = Tokenizer(WordPiece(vocab, unk_token=str(self.original_tokenizer.unk_token)))
tokenize_chinese_chars = False
strip_accents = False
do_lower_case = False
if hasattr(self.original_token... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
211 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.BertGenerationConverter | class BertGenerationConverter(SpmConverter):
pass | """Implement class BertGenerationConverter.
Required methods (implement on the class; order is not specified):
"""
class BertGenerationConverter: | pass
| 0 | 0 | 0 | 0 | true | mrahman2025/OpenClassGen | [] | |||
212 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.BigBirdConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class BigBirdConverter(SpmConverter):
def post_processor(self):
return processors.TemplateProcessing(single='[CLS]:0 $A:0 [SEP]:0', pair='[CLS]:0 $A:0 [SEP]:0 $B:1 [SEP]:1', special_tokens=[('[CLS]', sel... | """Implement class BigBirdConverter.
Required methods (implement on the class; order is not specified):
- `post_processor(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class BigBirdConverter: |
def post_processor(self):
return processors.TemplateProcessing(single='[CLS]:0 $A:0 [SEP]:0', pair='[CLS]:0 $A:0 [SEP]:0 $B:1 [SEP]:1', special_tokens=[('[CLS]', self.original_tokenizer.convert_tokens_to_ids('[CLS]')), ('[SEP]', self.original_tokenizer.convert_tokens_to_ids('[SEP]'))])
| from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
213 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.BlenderbotConverter | from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class BlenderbotConverter(Converter):
def converted(self) -> Tokenizer:
ot = self.original_tokenizer
vocab = ot.encoder
merges = list... | """Implement class BlenderbotConverter.
Required methods (implement on the class; order is not specified):
- `converted(self)`"""
from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class BlenderbotConverter: |
def converted(self) -> Tokenizer:
ot = self.original_tokenizer
vocab = ot.encoder
merges = list(ot.bpe_ranks.keys())
tokenizer = Tokenizer(BPE(vocab=vocab, merges=merges, dropout=None, continuing_subword_prefix='', end_of_word_suffix='', fuse_unk=False))
tokenizer.pre_tokeni... | from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
214 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.CLIPConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
class CLIPConverter(Converter):
def converted(self) -> Tokenizer:
vocab = self.original_tokenizer.encoder
merges = list(self.original_tokeniz... | """Implement class CLIPConverter.
Required methods (implement on the class; order is not specified):
- `converted(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
class CLIPConverter: |
def converted(self) -> Tokenizer:
vocab = self.original_tokenizer.encoder
merges = list(self.original_tokenizer.bpe_ranks.keys())
unk_token = self.original_tokenizer.unk_token
tokenizer = Tokenizer(BPE(vocab=vocab, merges=merges, dropout=None, continuing_subword_prefix='', end_of_wo... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
215 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.CamembertConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class CamembertConverter(SpmConverter):
def vocab(self, proto):
vocab = [('<s>NOTUSED', 0.0), ('<pad>', 0.0), ('</s>NOTUSED', 0.0), ('<unk>', 0.0), ('<unk>NOTUSED', -100)]
vocab += [(piece.piece,... | """Implement class CamembertConverter.
Required methods (implement on the class; order is not specified):
- `vocab(self, proto)`
- `unk_id(self, proto)`
- `post_processor(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class CamembertConverter: |
def vocab(self, proto):
vocab = [('<s>NOTUSED', 0.0), ('<pad>', 0.0), ('</s>NOTUSED', 0.0), ('<unk>', 0.0), ('<unk>NOTUSED', -100)]
vocab += [(piece.piece, piece.score) for piece in proto.pieces[1:]]
vocab += [('<mask>', 0.0)]
return vocab
def unk_id(self, proto):
retur... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 3 | 0 | 3 | 0 | true | mrahman2025/OpenClassGen | [] | ||
216 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.Converter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class Converter:
def __init__(self, original_tokenizer):
self.original_tokenizer = original_tokenizer
def converted(self) -> Tokenizer:
raise NotImplementedError() | """Implement class Converter.
Required methods (implement on the class; order is not specified):
- `__init__(self, original_tokenizer)`
- `converted(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class Converter: |
def __init__(self, original_tokenizer):
self.original_tokenizer = original_tokenizer
def converted(self) -> Tokenizer:
raise NotImplementedError()
| from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 2 | 0 | 2 | 0 | true | mrahman2025/OpenClassGen | [] | ||
217 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.DebertaConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
class DebertaConverter(Converter):
def converted(self) -> Tokenizer:
ot = self.original_tokenizer
vocab = ot.encoder
merges = list(ot... | """Implement class DebertaConverter.
Required methods (implement on the class; order is not specified):
- `converted(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
class DebertaConverter: |
def converted(self) -> Tokenizer:
ot = self.original_tokenizer
vocab = ot.encoder
merges = list(ot.bpe_ranks.keys())
tokenizer = Tokenizer(BPE(vocab=vocab, merges=merges, dropout=None, continuing_subword_prefix='', end_of_word_suffix='', fuse_unk=False))
tokenizer.pre_tokeni... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
218 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.DebertaV2Converter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class DebertaV2Converter(SpmConverter):
def pre_tokenizer(self, replacement, add_prefix_space):
list_pretokenizers = []
if self.original_tokenizer.split_by_punct:
list_pretokenizers.a... | """Implement class DebertaV2Converter.
Required methods (implement on the class; order is not specified):
- `pre_tokenizer(self, replacement, add_prefix_space)`
- `normalizer(self, proto)`
- `post_processor(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors... |
def pre_tokenizer(self, replacement, add_prefix_space):
list_pretokenizers = []
if self.original_tokenizer.split_by_punct:
list_pretokenizers.append(pre_tokenizers.Punctuation(behavior='isolated'))
prepend_scheme = _get_prepend_scheme(add_prefix_space, self.original_tokenizer)
... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 3 | 0 | 3 | 0 | true | mrahman2025/OpenClassGen | [] | ||
219 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.FunnelConverter | from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class FunnelConverter(Converter):
def converted(self) -> Tokenizer:
vocab = self.original_tokenizer.vocab
tokenizer = Tokenizer(WordPiece(voc... | """Implement class FunnelConverter.
Required methods (implement on the class; order is not specified):
- `converted(self)`"""
from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class FunnelConverter: |
def converted(self) -> Tokenizer:
vocab = self.original_tokenizer.vocab
tokenizer = Tokenizer(WordPiece(vocab, unk_token=str(self.original_tokenizer.unk_token)))
tokenize_chinese_chars = False
strip_accents = False
do_lower_case = False
if hasattr(self.original_token... | from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
220 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.GPT2Converter | from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from typing import Optional
class GPT2Converter(Converter):
def converted(self, vocab: Optional[dict[str, int]]=None, merges: Optional[list[tuple[str, str]]]... | """Implement class GPT2Converter.
Required methods (implement on the class; order is not specified):
- `converted(self, vocab: Optional[dict[str, int]]=None, merges: Optional[list[tuple[str, str]]]=None)`"""
from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, deco... |
def converted(self, vocab: Optional[dict[str, int]]=None, merges: Optional[list[tuple[str, str]]]=None) -> Tokenizer:
if not vocab:
vocab = self.original_tokenizer.encoder
if not merges:
merges = list(self.original_tokenizer.bpe_ranks)
tokenizer = Tokenizer(BPE(vocab... | from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from typing import Optional | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
221 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.GemmaConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class GemmaConverter(SpmConverter):
handle_byte_fallback = True
SpmExtractor = GemmaSentencePieceExtractor
special_tokens = {'<start_of_turn>', '<end_of_turn>'}
'"\n split_by_unicode_script: true\n... | """Implement class GemmaConverter.
Required methods (implement on the class; order is not specified):
- `normalizer(self, proto)`
- `vocab(self, proto)`
- `pre_tokenizer(self, replacement, add_prefix_space)`
- `unk_id(self, proto)`
- `decoder(self, replacement, add_prefix_space)`"""
from tokenizers import AddedToken, ... | handle_byte_fallback = True
SpmExtractor = GemmaSentencePieceExtractor
special_tokens = {'<start_of_turn>', '<end_of_turn>'}
'"\n split_by_unicode_script: true\n split_by_number: true\n split_by_whitespace: true\n treat_whitespace_as_suffix: false\n allow_whitespace_only_pieces: true\n ... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 5 | 0 | 5 | 0 | true | mrahman2025/OpenClassGen | [] | ||
222 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.GemmaSentencePieceExtractor | class GemmaSentencePieceExtractor(SentencePieceExtractor):
def extract(self, vocab_scores=None) -> tuple[dict[str, int], list[tuple]]:
"""
By default will return vocab and merges with respect to their order, by sending `vocab_scores` we're going to
order the merges with respect to the piece... | """Implement class GemmaSentencePieceExtractor.
Required methods (implement on the class; order is not specified):
- `extract(self, vocab_scores=None)`: By default will return vocab and merges with respect to their order, by sending `vocab_scores` we're going to"""
class GemmaSentencePieceExtractor: |
def extract(self, vocab_scores=None) -> tuple[dict[str, int], list[tuple]]:
"""
By default will return vocab and merges with respect to their order, by sending `vocab_scores` we're going to
order the merges with respect to the piece scores instead.
"""
sp = self.sp
v... | 1 | 0 | 1 | 1 | true | mrahman2025/OpenClassGen | [] | |||
223 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.HeliumConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
from .utils import is_protobuf_available, is_sentencepiece_available, logging, requires_backends
class HeliumConverter(SpmConverter):
handle_byte_fallback = T... | """Implement class HeliumConverter.
Required methods (implement on the class; order is not specified):
- `__init__(self, vocab_file=None, *args)`
- `tokenizer(self, proto)`
- `vocab(self, proto)`
- `unk_id(self, proto)`
- `decoder(self, replacement, add_prefix_space)`
- `normalizer(self, proto)`
- `pre_tokenizer(self,... | handle_byte_fallback = True
def __init__(self, vocab_file=None, *args):
requires_backends(self, 'protobuf')
Converter.__init__(self, vocab_file)
model_pb2 = import_protobuf()
m = model_pb2.ModelProto()
with open(vocab_file, 'rb') as f:
m.ParseFromString(f.rea... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
from .utils import is_protobuf_available, is_sentencepiece_available, logging, requires_backends | 8 | 2 | 7 | 0 | true | mrahman2025/OpenClassGen | [] | ||
224 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.HerbertConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
class HerbertConverter(Converter):
def converted(self) -> Tokenizer:
tokenizer_info_str = '#version:'
token_suffix = '</w>'
vocab = s... | """Implement class HerbertConverter.
Required methods (implement on the class; order is not specified):
- `converted(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
class HerbertConverter: |
def converted(self) -> Tokenizer:
tokenizer_info_str = '#version:'
token_suffix = '</w>'
vocab = self.original_tokenizer.encoder
merges = list(self.original_tokenizer.bpe_ranks.keys())
if tokenizer_info_str in merges[0][0]:
merges = merges[1:]
tokenizer =... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
225 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.LayoutLMv2Converter | from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class LayoutLMv2Converter(Converter):
def converted(self) -> Tokenizer:
vocab = self.original_tokenizer.vocab
tokenizer = Tokenizer(WordPiece... | """Implement class LayoutLMv2Converter.
Required methods (implement on the class; order is not specified):
- `converted(self)`"""
from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class LayoutLMv2Converter: |
def converted(self) -> Tokenizer:
vocab = self.original_tokenizer.vocab
tokenizer = Tokenizer(WordPiece(vocab, unk_token=str(self.original_tokenizer.unk_token)))
tokenize_chinese_chars = False
strip_accents = False
do_lower_case = True
if hasattr(self.original_tokeni... | from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
226 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.LlamaConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class LlamaConverter(SpmConverter):
handle_byte_fallback = True
def vocab(self, proto):
vocab = [(self.original_tokenizer.convert_ids_to_tokens(0), 0.0), (self.original_tokenizer.convert_ids_to_token... | """Implement class LlamaConverter.
Required methods (implement on the class; order is not specified):
- `vocab(self, proto)`
- `unk_id(self, proto)`
- `decoder(self, replacement, add_prefix_space)`
- `normalizer(self, proto)`
- `pre_tokenizer(self, replacement, add_prefix_space)`
- `post_processor(self)`"""
from token... | handle_byte_fallback = True
def vocab(self, proto):
vocab = [(self.original_tokenizer.convert_ids_to_tokens(0), 0.0), (self.original_tokenizer.convert_ids_to_tokens(1), 0.0), (self.original_tokenizer.convert_ids_to_tokens(2), 0.0)]
vocab += [(piece.piece, piece.score) for piece in proto.pieces[... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 6 | 0 | 6 | 0 | true | mrahman2025/OpenClassGen | [] | ||
227 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.MBart50Converter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class MBart50Converter(SpmConverter):
def vocab(self, proto):
vocab = [('<s>', 0.0), ('<pad>', 0.0), ('</s>', 0.0), ('<unk>', 0.0)]
vocab += [(piece.piece, piece.score) for piece in proto.pieces[... | """Implement class MBart50Converter.
Required methods (implement on the class; order is not specified):
- `vocab(self, proto)`
- `unk_id(self, proto)`
- `post_processor(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class MBart50Converter: |
def vocab(self, proto):
vocab = [('<s>', 0.0), ('<pad>', 0.0), ('</s>', 0.0), ('<unk>', 0.0)]
vocab += [(piece.piece, piece.score) for piece in proto.pieces[3:]]
vocab += [('ar_AR', 0.0), ('cs_CZ', 0.0), ('de_DE', 0.0), ('en_XX', 0.0), ('es_XX', 0.0), ('et_EE', 0.0), ('fi_FI', 0.0), ('fr_XX... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 3 | 0 | 3 | 0 | true | mrahman2025/OpenClassGen | [] | ||
228 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.MBartConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class MBartConverter(SpmConverter):
def vocab(self, proto):
vocab = [('<s>', 0.0), ('<pad>', 0.0), ('</s>', 0.0), ('<unk>', 0.0)]
vocab += [(piece.piece, piece.score) for piece in proto.pieces[3:... | """Implement class MBartConverter.
Required methods (implement on the class; order is not specified):
- `vocab(self, proto)`
- `unk_id(self, proto)`
- `post_processor(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class MBartConverter: |
def vocab(self, proto):
vocab = [('<s>', 0.0), ('<pad>', 0.0), ('</s>', 0.0), ('<unk>', 0.0)]
vocab += [(piece.piece, piece.score) for piece in proto.pieces[3:]]
vocab += [('ar_AR', 0.0), ('cs_CZ', 0.0), ('de_DE', 0.0), ('en_XX', 0.0), ('es_XX', 0.0), ('et_EE', 0.0), ('fi_FI', 0.0), ('fr_XX... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 3 | 0 | 3 | 0 | true | mrahman2025/OpenClassGen | [] | ||
229 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.MPNetConverter | from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class MPNetConverter(Converter):
def converted(self) -> Tokenizer:
vocab = self.original_tokenizer.vocab
tokenizer = Tokenizer(WordPiece(voca... | """Implement class MPNetConverter.
Required methods (implement on the class; order is not specified):
- `converted(self)`"""
from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class MPNetConverter: |
def converted(self) -> Tokenizer:
vocab = self.original_tokenizer.vocab
tokenizer = Tokenizer(WordPiece(vocab, unk_token=str(self.original_tokenizer.unk_token)))
tokenize_chinese_chars = False
strip_accents = False
do_lower_case = False
if hasattr(self.original_token... | from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
230 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.MarkupLMConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
class MarkupLMConverter(Converter):
def converted(self) -> Tokenizer:
ot = self.original_tokenizer
vocab = ot.encoder
merges = list(o... | """Implement class MarkupLMConverter.
Required methods (implement on the class; order is not specified):
- `converted(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
class MarkupLMConverter: |
def converted(self) -> Tokenizer:
ot = self.original_tokenizer
vocab = ot.encoder
merges = list(ot.bpe_ranks.keys())
tokenizer = Tokenizer(BPE(vocab=vocab, merges=merges, dropout=None, continuing_subword_prefix='', end_of_word_suffix='', fuse_unk=False, unk_token=self.original_token... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
231 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.MoshiConverter | from .utils import is_protobuf_available, is_sentencepiece_available, logging, requires_backends
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class MoshiConverter(SpmConverter):
handle_byte_fallback = True
def __init__(self, vocab_file, model_max_lengt... | """Implement class MoshiConverter.
Required methods (implement on the class; order is not specified):
- `__init__(self, vocab_file, model_max_length=None, **kwargs)`
- `normalizer(self, proto)`
- `decoder(self, replacement, add_prefix_space)`
- `pre_tokenizer(self, replacement, add_prefix_space)`"""
from .utils import... | handle_byte_fallback = True
def __init__(self, vocab_file, model_max_length=None, **kwargs):
requires_backends(self, 'protobuf')
Converter.__init__(self, vocab_file)
model_pb2 = import_protobuf()
m = model_pb2.ModelProto()
with open(vocab_file, 'rb') as f:
m.... | from .utils import is_protobuf_available, is_sentencepiece_available, logging, requires_backends
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 4 | 0 | 4 | 0 | true | mrahman2025/OpenClassGen | [] | ||
232 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.NllbConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class NllbConverter(SpmConverter):
def vocab(self, proto):
vocab = [('<s>', 0.0), ('<pad>', 0.0), ('</s>', 0.0), ('<unk>', 0.0)]
vocab += [(piece.piece, piece.score) for piece in proto.pieces[3:]... | """Implement class NllbConverter.
Required methods (implement on the class; order is not specified):
- `vocab(self, proto)`
- `unk_id(self, proto)`
- `post_processor(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class NllbConverter: |
def vocab(self, proto):
vocab = [('<s>', 0.0), ('<pad>', 0.0), ('</s>', 0.0), ('<unk>', 0.0)]
vocab += [(piece.piece, piece.score) for piece in proto.pieces[3:]]
return vocab
def unk_id(self, proto):
return 3
def post_processor(self):
return processors.TemplateProc... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 3 | 0 | 3 | 0 | true | mrahman2025/OpenClassGen | [] | ||
233 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.OpenAIGPTConverter | from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class OpenAIGPTConverter(Converter):
def converted(self) -> Tokenizer:
vocab = self.original_tokenizer.encoder
merges = list(self.original_to... | """Implement class OpenAIGPTConverter.
Required methods (implement on the class; order is not specified):
- `converted(self)`"""
from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class OpenAIGPTConverter: |
def converted(self) -> Tokenizer:
vocab = self.original_tokenizer.encoder
merges = list(self.original_tokenizer.bpe_ranks.keys())
unk_token = self.original_tokenizer.unk_token
tokenizer = Tokenizer(BPE(vocab=vocab, merges=merges, dropout=None, unk_token=str(unk_token), end_of_word_s... | from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
234 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.PegasusConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class PegasusConverter(SpmConverter):
def vocab(self, proto):
vocab = [(self.original_tokenizer.pad_token, 0.0), (self.original_tokenizer.eos_token, 0.0)]
if self.original_tokenizer.mask_token_se... | """Implement class PegasusConverter.
Required methods (implement on the class; order is not specified):
- `vocab(self, proto)`
- `unk_id(self, proto)`
- `pre_tokenizer(self, replacement, add_prefix_space)`
- `post_processor(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_token... |
def vocab(self, proto):
vocab = [(self.original_tokenizer.pad_token, 0.0), (self.original_tokenizer.eos_token, 0.0)]
if self.original_tokenizer.mask_token_sent is not None:
vocab += [(self.original_tokenizer.mask_token_sent, 0.0)]
if self.original_tokenizer.mask_token is not Non... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 4 | 0 | 4 | 0 | true | mrahman2025/OpenClassGen | [] | ||
235 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.Qwen2Converter | from typing import Optional
from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class Qwen2Converter(Converter):
def converted(self, vocab: Optional[dict[str, int]]=None, merges: Optional[list[tuple[str, str]]... | """Implement class Qwen2Converter.
Required methods (implement on the class; order is not specified):
- `converted(self, vocab: Optional[dict[str, int]]=None, merges: Optional[list[tuple[str, str]]]=None)`"""
from typing import Optional
from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import Added... |
def converted(self, vocab: Optional[dict[str, int]]=None, merges: Optional[list[tuple[str, str]]]=None) -> Tokenizer:
if not vocab:
vocab = self.original_tokenizer.encoder
if not merges:
merges = list(self.original_tokenizer.bpe_ranks.keys())
tokenizer = Tokenizer(BP... | from typing import Optional
from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
236 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.ReformerConverter | class ReformerConverter(SpmConverter):
pass | """Implement class ReformerConverter.
Required methods (implement on the class; order is not specified):
"""
class ReformerConverter: | pass
| 0 | 0 | 0 | 0 | true | mrahman2025/OpenClassGen | [] | |||
237 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.RemBertConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class RemBertConverter(SpmConverter):
def normalizer(self, proto):
list_normalizers = [normalizers.Replace('``', '"'), normalizers.Replace("''", '"'), normalizers.Replace(Regex(' {2,}'), ' ')]
if... | """Implement class RemBertConverter.
Required methods (implement on the class; order is not specified):
- `normalizer(self, proto)`
- `post_processor(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class RemBertConverter: |
def normalizer(self, proto):
list_normalizers = [normalizers.Replace('``', '"'), normalizers.Replace("''", '"'), normalizers.Replace(Regex(' {2,}'), ' ')]
if not self.original_tokenizer.keep_accents:
list_normalizers.append(normalizers.NFKD())
list_normalizers.append(normali... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 2 | 0 | 2 | 0 | true | mrahman2025/OpenClassGen | [] | ||
238 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.RoFormerConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
class RoFormerConverter(Converter):
def converted(self) -> Tokenizer:
from .models.roformer.tokenization_utils import JiebaPreTokenizer
vocab... | """Implement class RoFormerConverter.
Required methods (implement on the class; order is not specified):
- `converted(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
class RoFormerConverter: |
def converted(self) -> Tokenizer:
from .models.roformer.tokenization_utils import JiebaPreTokenizer
vocab = self.original_tokenizer.vocab
tokenizer = Tokenizer(WordPiece(vocab, unk_token=str(self.original_tokenizer.unk_token)))
strip_accents = False
do_lower_case = False
... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
239 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.RobertaConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
class RobertaConverter(Converter):
def converted(self) -> Tokenizer:
ot = self.original_tokenizer
vocab = ot.encoder
merges = list(ot... | """Implement class RobertaConverter.
Required methods (implement on the class; order is not specified):
- `converted(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
class RobertaConverter: |
def converted(self) -> Tokenizer:
ot = self.original_tokenizer
vocab = ot.encoder
merges = list(ot.bpe_ranks.keys())
tokenizer = Tokenizer(BPE(vocab=vocab, merges=merges, dropout=None, continuing_subword_prefix='', end_of_word_suffix='', fuse_unk=False))
tokenizer.pre_tokeni... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
240 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.SeamlessM4TConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class SeamlessM4TConverter(SpmConverter):
def vocab(self, proto):
vocab = [('<pad>', 0.0), ('<unk>', 0.0), ('<s>', 0.0), ('</s>', 0.0)]
vocab += [(piece.piece, piece.score) for piece in proto.pie... | """Implement class SeamlessM4TConverter.
Required methods (implement on the class; order is not specified):
- `vocab(self, proto)`
- `unk_id(self, proto)`
- `post_processor(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class SeamlessM4TConverter: |
def vocab(self, proto):
vocab = [('<pad>', 0.0), ('<unk>', 0.0), ('<s>', 0.0), ('</s>', 0.0)]
vocab += [(piece.piece, piece.score) for piece in proto.pieces[3:]]
return vocab
def unk_id(self, proto):
return self.original_tokenizer.unk_token_id
def post_processor(self):
... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 3 | 0 | 3 | 0 | true | mrahman2025/OpenClassGen | [] | ||
241 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.SentencePieceExtractor | from .utils import is_protobuf_available, is_sentencepiece_available, logging, requires_backends
class SentencePieceExtractor:
"""
Extractor implementation for SentencePiece trained models. https://github.com/google/sentencepiece
"""
def __init__(self, model: str):
requires_backends(self, 'sen... | """Extractor implementation for SentencePiece trained models. https://github.com/google/sentencepiece
Required methods (implement on the class; order is not specified):
- `__init__(self, model: str)`
- `extract(self, vocab_scores=None)`: By default will return vocab and merges with respect to their order, by sending `... | """
Extractor implementation for SentencePiece trained models. https://github.com/google/sentencepiece
"""
def __init__(self, model: str):
requires_backends(self, 'sentencepiece')
from sentencepiece import SentencePieceProcessor
self.sp = SentencePieceProcessor()
self.sp... | from .utils import is_protobuf_available, is_sentencepiece_available, logging, requires_backends | 2 | 0 | 2 | 0.5 | true | mrahman2025/OpenClassGen | [] | ||
242 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.SplinterConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
class SplinterConverter(Converter):
def converted(self) -> Tokenizer:
vocab = self.original_tokenizer.vocab
tokenizer = Tokenizer(WordPiece(v... | """Implement class SplinterConverter.
Required methods (implement on the class; order is not specified):
- `converted(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
class SplinterConverter: |
def converted(self) -> Tokenizer:
vocab = self.original_tokenizer.vocab
tokenizer = Tokenizer(WordPiece(vocab, unk_token=str(self.original_tokenizer.unk_token)))
tokenize_chinese_chars = False
strip_accents = False
do_lower_case = False
if hasattr(self.original_token... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
243 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.SpmConverter | from .utils import is_protobuf_available, is_sentencepiece_available, logging, requires_backends
import warnings
from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class SpmConverter(Converter):
handle_byte_fa... | """Implement class SpmConverter.
Required methods (implement on the class; order is not specified):
- `__init__(self, *args)`
- `vocab(self, proto)`
- `unk_id(self, proto)`
- `tokenizer(self, proto)`
- `normalizer(self, proto)`
- `pre_tokenizer(self, replacement, add_prefix_space)`
- `post_processor(self)`
- `decoder(... | handle_byte_fallback = False
SpmExtractor = SentencePieceExtractor
special_tokens = {}
def __init__(self, *args):
requires_backends(self, 'protobuf')
super().__init__(*args)
model_pb2 = import_protobuf()
m = model_pb2.ModelProto()
with open(self.original_tokenize... | from .utils import is_protobuf_available, is_sentencepiece_available, logging, requires_backends
import warnings
from tokenizers.models import BPE, Unigram, WordPiece
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 9 | 7 | 7 | 0 | true | mrahman2025/OpenClassGen | [] | ||
244 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.T5Converter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class T5Converter(SpmConverter):
def vocab(self, proto):
num_extra_ids = self.original_tokenizer._extra_ids
vocab = [(piece.piece, piece.score) for piece in proto.pieces]
vocab += [(f'<ex... | """Implement class T5Converter.
Required methods (implement on the class; order is not specified):
- `vocab(self, proto)`
- `post_processor(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class T5Converter: |
def vocab(self, proto):
num_extra_ids = self.original_tokenizer._extra_ids
vocab = [(piece.piece, piece.score) for piece in proto.pieces]
vocab += [(f'<extra_id_{i}>', 0.0) for i in range(num_extra_ids - 1, -1, -1)]
return vocab
def post_processor(self):
return processo... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 2 | 0 | 2 | 0 | true | mrahman2025/OpenClassGen | [] | ||
245 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.TikTokenConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
class TikTokenConverter:
"""
A general tiktoken converter.
"""
def __init__(self, vocab_file=None, pattern="(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\\r\\n... | """A general tiktoken converter.
Required methods (implement on the class; order is not specified):
- `__init__(self, vocab_file=None, pattern="(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\\r\\n\\p{L}\\p{N}]?\\p{L}+|\\p{N}{1,3}| ?[^\\s\\p{L}\\p{N}]+[\\r\\n]*|\\s*[\\r\\n]+|\\s+(?!\\S)|\\s+", add_prefix_space=False, additional_speci... | """
A general tiktoken converter.
"""
def __init__(self, vocab_file=None, pattern="(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\\r\\n\\p{L}\\p{N}]?\\p{L}+|\\p{N}{1,3}| ?[^\\s\\p{L}\\p{N}]+[\\r\\n]*|\\s*[\\r\\n]+|\\s+(?!\\S)|\\s+", add_prefix_space=False, additional_special_tokens=None, *args, **kwargs):
sup... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece | 4 | 2 | 2 | 0 | true | mrahman2025/OpenClassGen | [] | ||
246 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.UdopConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class UdopConverter(SpmConverter):
def post_processor(self):
return processors.TemplateProcessing(single=['$A', '</s>'], pair=['$A', '</s>', '$B', '</s>'], special_tokens=[('</s>', self.original_tokenize... | """Implement class UdopConverter.
Required methods (implement on the class; order is not specified):
- `post_processor(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class UdopConverter: |
def post_processor(self):
return processors.TemplateProcessing(single=['$A', '</s>'], pair=['$A', '</s>', '$B', '</s>'], special_tokens=[('</s>', self.original_tokenizer.convert_tokens_to_ids('</s>'))])
| from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
247 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.WhisperConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
class WhisperConverter(Converter):
def converted(self) -> Tokenizer:
vocab = self.original_tokenizer.encoder
merges = list(self.original_toke... | """Implement class WhisperConverter.
Required methods (implement on the class; order is not specified):
- `converted(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece
class WhisperConverter: |
def converted(self) -> Tokenizer:
vocab = self.original_tokenizer.encoder
merges = list(self.original_tokenizer.bpe_ranks.keys())
tokenizer = Tokenizer(BPE(vocab=vocab, merges=merges, dropout=None, continuing_subword_prefix='', end_of_word_suffix='', fuse_unk=False))
tokenizer.pre_t... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import BPE, Unigram, WordPiece | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
248 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.XGLMConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class XGLMConverter(SpmConverter):
def vocab(self, proto):
vocab = [('<s>', 0.0), ('<pad>', 0.0), ('</s>', 0.0), ('<unk>', 0.0)]
vocab += [(piece.piece, piece.score) for piece in proto.pieces[3:]... | """Implement class XGLMConverter.
Required methods (implement on the class; order is not specified):
- `vocab(self, proto)`
- `unk_id(self, proto)`
- `post_processor(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class XGLMConverter: |
def vocab(self, proto):
vocab = [('<s>', 0.0), ('<pad>', 0.0), ('</s>', 0.0), ('<unk>', 0.0)]
vocab += [(piece.piece, piece.score) for piece in proto.pieces[3:]]
vocab += [('<madeupword0>', 0.0), ('<madeupword1>', 0.0), ('<madeupword2>', 0.0), ('<madeupword3>', 0.0), ('<madeupword4>', 0.0),... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 3 | 0 | 3 | 0 | true | mrahman2025/OpenClassGen | [] | ||
249 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.XLMRobertaConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class XLMRobertaConverter(SpmConverter):
def vocab(self, proto):
vocab = [('<s>', 0.0), ('<pad>', 0.0), ('</s>', 0.0), ('<unk>', 0.0)]
vocab += [(piece.piece, piece.score) for piece in proto.piec... | """Implement class XLMRobertaConverter.
Required methods (implement on the class; order is not specified):
- `vocab(self, proto)`
- `unk_id(self, proto)`
- `post_processor(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class XLMRobertaConverter: |
def vocab(self, proto):
vocab = [('<s>', 0.0), ('<pad>', 0.0), ('</s>', 0.0), ('<unk>', 0.0)]
vocab += [(piece.piece, piece.score) for piece in proto.pieces[3:]]
vocab += [('<mask>', 0.0)]
return vocab
def unk_id(self, proto):
unk_id = 3
return unk_id
def p... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 3 | 0 | 3 | 0 | true | mrahman2025/OpenClassGen | [] | ||
250 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/convert_slow_tokenizer.py | transformers.convert_slow_tokenizer.XLNetConverter | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class XLNetConverter(SpmConverter):
def vocab(self, proto):
return [(piece.piece, piece.score) if check_number_comma(piece.piece) else (piece.piece, piece.score - 100) for piece in proto.pieces]
def... | """Implement class XLNetConverter.
Required methods (implement on the class; order is not specified):
- `vocab(self, proto)`
- `normalizer(self, proto)`
- `post_processor(self)`"""
from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors
class XLNetConverter: |
def vocab(self, proto):
return [(piece.piece, piece.score) if check_number_comma(piece.piece) else (piece.piece, piece.score - 100) for piece in proto.pieces]
def normalizer(self, proto):
list_normalizers = [normalizers.Replace('``', '"'), normalizers.Replace("''", '"')]
if not self.or... | from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, processors | 3 | 0 | 3 | 0 | true | mrahman2025/OpenClassGen | [] | ||
251 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/data_collator.py | transformers.data.data_collator.DataCollatorForLanguageModeling | from typing import Any, Callable, NewType, Optional, Union
import multiprocessing as mp
import numpy as np
from dataclasses import dataclass
from collections.abc import Mapping
from ..tokenization_utils_base import PreTrainedTokenizerBase
@dataclass
class DataCollatorForLanguageModeling(DataCollatorMixin):
"""
... | """Data collator used for language modeling. Inputs are dynamically padded to the maximum length of a batch if they
are not all of the same length.
Args:
tokenizer ([`PreTrainedTokenizer`] or [`PreTrainedTokenizerFast`]):
The tokenizer used for encoding the data.
mlm (`bool`, *optional*, defaults to `T... | class DataCollatorForLanguageModeling(DataCollatorMixin):
"""
Data collator used for language modeling. Inputs are dynamically padded to the maximum length of a batch if they
are not all of the same length.
Args:
tokenizer ([`PreTrainedTokenizer`] or [`PreTrainedTokenizerFast`]):
Th... | from typing import Any, Callable, NewType, Optional, Union
import multiprocessing as mp
import numpy as np
from dataclasses import dataclass
from collections.abc import Mapping
from ..tokenization_utils_base import PreTrainedTokenizerBase | 7 | 5 | 4 | 0.285714 | true | mrahman2025/OpenClassGen | [] | ||
252 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/data_collator.py | transformers.data.data_collator.DataCollatorForPermutationLanguageModeling | from collections.abc import Mapping
from ..tokenization_utils_base import PreTrainedTokenizerBase
from typing import Any, Callable, NewType, Optional, Union
from random import randint
import numpy as np
from dataclasses import dataclass
@dataclass
class DataCollatorForPermutationLanguageModeling(DataCollatorMixin):
... | """Data collator used for permutation language modeling.
- collates batches of tensors, honoring their tokenizer's pad_token
- preprocesses batches for permutation language modeling with procedures specific to XLNet
Required methods (implement on the class; order is not specified):
- `torch_call(self, examples: list[... | class DataCollatorForPermutationLanguageModeling(DataCollatorMixin):
"""
Data collator used for permutation language modeling.
- collates batches of tensors, honoring their tokenizer's pad_token
- preprocesses batches for permutation language modeling with procedures specific to XLNet
"""
token... | from collections.abc import Mapping
from ..tokenization_utils_base import PreTrainedTokenizerBase
from typing import Any, Callable, NewType, Optional, Union
from random import randint
import numpy as np
from dataclasses import dataclass | 4 | 2 | 2 | 0.5 | true | mrahman2025/OpenClassGen | [] | ||
253 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/data_collator.py | transformers.data.data_collator.DataCollatorForSOP | import warnings
from dataclasses import dataclass
from typing import Any, Callable, NewType, Optional, Union
@dataclass
class DataCollatorForSOP(DataCollatorForLanguageModeling):
"""
Data collator used for sentence order prediction task.
- collates batches of tensors, honoring their tokenizer's pad_token
... | """Data collator used for sentence order prediction task.
- collates batches of tensors, honoring their tokenizer's pad_token
- preprocesses batches for both masked language modeling and sentence order prediction
Required methods (implement on the class; order is not specified):
- `__init__(self, *args, **kwargs)`
- ... | class DataCollatorForSOP(DataCollatorForLanguageModeling):
"""
Data collator used for sentence order prediction task.
- collates batches of tensors, honoring their tokenizer's pad_token
- preprocesses batches for both masked language modeling and sentence order prediction
"""
def __init__(self... | import warnings
from dataclasses import dataclass
from typing import Any, Callable, NewType, Optional, Union | 3 | 1 | 2 | 0.333333 | true | mrahman2025/OpenClassGen | [] | ||
254 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/data_collator.py | transformers.data.data_collator.DataCollatorForSeq2Seq | from typing import Any, Callable, NewType, Optional, Union
from ..tokenization_utils_base import PreTrainedTokenizerBase
from dataclasses import dataclass
import numpy as np
from ..utils import PaddingStrategy
@dataclass
class DataCollatorForSeq2Seq:
"""
Data collator that will dynamically pad the inputs recei... | """Data collator that will dynamically pad the inputs received, as well as the labels.
Args:
tokenizer ([`PreTrainedTokenizer`] or [`PreTrainedTokenizerFast`]):
The tokenizer used for encoding the data.
model ([`PreTrainedModel`], *optional*):
The model that is being trained. If set and has the... | class DataCollatorForSeq2Seq:
"""
Data collator that will dynamically pad the inputs received, as well as the labels.
Args:
tokenizer ([`PreTrainedTokenizer`] or [`PreTrainedTokenizerFast`]):
The tokenizer used for encoding the data.
model ([`PreTrainedModel`], *optional*):
... | from typing import Any, Callable, NewType, Optional, Union
from ..tokenization_utils_base import PreTrainedTokenizerBase
from dataclasses import dataclass
import numpy as np
from ..utils import PaddingStrategy | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
255 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/data_collator.py | transformers.data.data_collator.DataCollatorForTokenClassification | from dataclasses import dataclass
import numpy as np
from typing import Any, Callable, NewType, Optional, Union
from ..tokenization_utils_base import PreTrainedTokenizerBase
from ..utils import PaddingStrategy
@dataclass
class DataCollatorForTokenClassification(DataCollatorMixin):
"""
Data collator that will d... | """Data collator that will dynamically pad the inputs received, as well as the labels.
Args:
tokenizer ([`PreTrainedTokenizer`] or [`PreTrainedTokenizerFast`]):
The tokenizer used for encoding the data.
padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `True`):
Selec... | class DataCollatorForTokenClassification(DataCollatorMixin):
"""
Data collator that will dynamically pad the inputs received, as well as the labels.
Args:
tokenizer ([`PreTrainedTokenizer`] or [`PreTrainedTokenizerFast`]):
The tokenizer used for encoding the data.
padding (`bool... | from dataclasses import dataclass
import numpy as np
from typing import Any, Callable, NewType, Optional, Union
from ..tokenization_utils_base import PreTrainedTokenizerBase
from ..utils import PaddingStrategy | 2 | 0 | 2 | 0 | true | mrahman2025/OpenClassGen | [] | ||
256 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/data_collator.py | transformers.data.data_collator.DataCollatorForWholeWordMask | from collections.abc import Mapping
import warnings
import random
from typing import Any, Callable, NewType, Optional, Union
from ..models.bert import BertTokenizer, BertTokenizerFast
import numpy as np
from dataclasses import dataclass
@dataclass
class DataCollatorForWholeWordMask(DataCollatorForLanguageModeling):
... | """Data collator used for language modeling that masks entire words.
- collates batches of tensors, honoring their tokenizer's pad_token
- preprocesses batches for masked language modeling
<Tip>
This collator relies on details of the implementation of subword tokenization by [`BertTokenizer`], specifically
that subw... | class DataCollatorForWholeWordMask(DataCollatorForLanguageModeling):
"""
Data collator used for language modeling that masks entire words.
- collates batches of tensors, honoring their tokenizer's pad_token
- preprocesses batches for masked language modeling
<Tip>
This collator relies on deta... | from collections.abc import Mapping
import warnings
import random
from typing import Any, Callable, NewType, Optional, Union
from ..models.bert import BertTokenizer, BertTokenizerFast
import numpy as np
from dataclasses import dataclass | 6 | 5 | 3 | 0.5 | true | mrahman2025/OpenClassGen | [] | ||
257 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/data_collator.py | transformers.data.data_collator.DataCollatorMixin | class DataCollatorMixin:
def __call__(self, features, return_tensors=None):
if return_tensors is None:
return_tensors = self.return_tensors
if return_tensors == 'pt':
return self.torch_call(features)
elif return_tensors == 'np':
return self.numpy_call(fea... | """Implement class DataCollatorMixin.
Required methods (implement on the class; order is not specified):
- `__call__(self, features, return_tensors=None)`"""
class DataCollatorMixin: |
def __call__(self, features, return_tensors=None):
if return_tensors is None:
return_tensors = self.return_tensors
if return_tensors == 'pt':
return self.torch_call(features)
elif return_tensors == 'np':
return self.numpy_call(features)
else:
... | 1 | 0 | 0 | 0 | true | mrahman2025/OpenClassGen | [] | |||
258 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/data_collator.py | transformers.data.data_collator.DataCollatorWithFlattening | import numpy as np
from dataclasses import dataclass
@dataclass
class DataCollatorWithFlattening(DefaultDataCollator):
"""
Data collator used for padding free approach. Does the following:
- concatenates the entire mini batch into single long sequence of shape [1, total_tokens]
- uses `separator_id` t... | """Data collator used for padding free approach. Does the following:
- concatenates the entire mini batch into single long sequence of shape [1, total_tokens]
- uses `separator_id` to separate sequences within the concatenated `labels`, default value is -100
- no padding will be added, returns `input_ids`, `labels` an... | class DataCollatorWithFlattening(DefaultDataCollator):
"""
Data collator used for padding free approach. Does the following:
- concatenates the entire mini batch into single long sequence of shape [1, total_tokens]
- uses `separator_id` to separate sequences within the concatenated `labels`, default va... | import numpy as np
from dataclasses import dataclass | 2 | 0 | 2 | 0 | true | mrahman2025/OpenClassGen | [] | ||
259 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/data_collator.py | transformers.data.data_collator.DataCollatorWithPadding | from ..tokenization_utils_base import PreTrainedTokenizerBase
from ..utils import PaddingStrategy
from dataclasses import dataclass
from typing import Any, Callable, NewType, Optional, Union
@dataclass
class DataCollatorWithPadding:
"""
Data collator that will dynamically pad the inputs received.
Args:
... | """Data collator that will dynamically pad the inputs received.
Args:
tokenizer ([`PreTrainedTokenizer`] or [`PreTrainedTokenizerFast`]):
The tokenizer used for encoding the data.
padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `True`):
Select a strategy to pad the... | class DataCollatorWithPadding:
"""
Data collator that will dynamically pad the inputs received.
Args:
tokenizer ([`PreTrainedTokenizer`] or [`PreTrainedTokenizerFast`]):
The tokenizer used for encoding the data.
padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, d... | from ..tokenization_utils_base import PreTrainedTokenizerBase
from ..utils import PaddingStrategy
from dataclasses import dataclass
from typing import Any, Callable, NewType, Optional, Union | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
260 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/data_collator.py | transformers.data.data_collator.DefaultDataCollator | from typing import Any, Callable, NewType, Optional, Union
from dataclasses import dataclass
@dataclass
class DefaultDataCollator(DataCollatorMixin):
"""
Very simple data collator that simply collates batches of dict-like objects and performs special handling for
potential keys named:
- `label`: h... | """Very simple data collator that simply collates batches of dict-like objects and performs special handling for
potential keys named:
- `label`: handles a single value (int or float) per object
- `label_ids`: handles a list of values per object
Does not do any additional preprocessing: property names of the ... | class DefaultDataCollator(DataCollatorMixin):
"""
Very simple data collator that simply collates batches of dict-like objects and performs special handling for
potential keys named:
- `label`: handles a single value (int or float) per object
- `label_ids`: handles a list of values per objec... | from typing import Any, Callable, NewType, Optional, Union
from dataclasses import dataclass | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
261 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/datasets/glue.py | transformers.data.datasets.glue.GlueDataTrainingArguments | from ..processors.glue import glue_convert_examples_to_features, glue_output_modes, glue_processors
from dataclasses import dataclass, field
@dataclass
class GlueDataTrainingArguments:
"""
Arguments pertaining to what data we are going to input our model for training and eval.
Using `HfArgumentParser` we ... | """Arguments pertaining to what data we are going to input our model for training and eval.
Using `HfArgumentParser` we can turn this class into argparse arguments to be able to specify them on the command
line.
Required methods (implement on the class; order is not specified):
- `__post_init__(self)`"""
from ..proce... | class GlueDataTrainingArguments:
"""
Arguments pertaining to what data we are going to input our model for training and eval.
Using `HfArgumentParser` we can turn this class into argparse arguments to be able to specify them on the command
line.
"""
task_name: str = field(metadata={'help': 'The... | from ..processors.glue import glue_convert_examples_to_features, glue_output_modes, glue_processors
from dataclasses import dataclass, field | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
262 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/datasets/glue.py | transformers.data.datasets.glue.GlueDataset | from filelock import FileLock
from torch.utils.data import Dataset
import warnings
import torch
from ...utils import check_torch_load_is_safe, logging
from ..processors.glue import glue_convert_examples_to_features, glue_output_modes, glue_processors
from typing import Optional, Union
from ...tokenization_utils_base im... | """Implement class GlueDataset.
Required methods (implement on the class; order is not specified):
- `__init__(self, args: GlueDataTrainingArguments, tokenizer: PreTrainedTokenizerBase, limit_length: Optional[int]=None, mode: Union[str, Split]=Split.train, cache_dir: Optional[str]=None)`
- `__len__(self)`
- `__getitem... | args: GlueDataTrainingArguments
output_mode: str
features: list[InputFeatures]
def __init__(self, args: GlueDataTrainingArguments, tokenizer: PreTrainedTokenizerBase, limit_length: Optional[int]=None, mode: Union[str, Split]=Split.train, cache_dir: Optional[str]=None):
warnings.warn('This datas... | from filelock import FileLock
from torch.utils.data import Dataset
import warnings
import torch
from ...utils import check_torch_load_is_safe, logging
from ..processors.glue import glue_convert_examples_to_features, glue_output_modes, glue_processors
from typing import Optional, Union
from ...tokenization_utils_base im... | 4 | 0 | 4 | 0 | true | mrahman2025/OpenClassGen | [] | ||
263 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/datasets/language_modeling.py | transformers.data.datasets.language_modeling.LineByLineTextDataset | import os
import warnings
import torch
from ...tokenization_utils import PreTrainedTokenizer
from torch.utils.data import Dataset
class LineByLineTextDataset(Dataset):
def __init__(self, tokenizer: PreTrainedTokenizer, file_path: str, block_size: int):
warnings.warn(DEPRECATION_WARNING.format('https://git... | """Implement class LineByLineTextDataset.
Required methods (implement on the class; order is not specified):
- `__init__(self, tokenizer: PreTrainedTokenizer, file_path: str, block_size: int)`
- `__len__(self)`
- `__getitem__(self, i)`"""
import os
import warnings
import torch
from ...tokenization_utils import PreTrai... |
def __init__(self, tokenizer: PreTrainedTokenizer, file_path: str, block_size: int):
warnings.warn(DEPRECATION_WARNING.format('https://github.com/huggingface/transformers/blob/main/examples/pytorch/language-modeling/run_mlm.py'), FutureWarning)
if os.path.isfile(file_path) is False:
rai... | import os
import warnings
import torch
from ...tokenization_utils import PreTrainedTokenizer
from torch.utils.data import Dataset | 3 | 0 | 3 | 0 | true | mrahman2025/OpenClassGen | [] | ||
264 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/datasets/language_modeling.py | transformers.data.datasets.language_modeling.LineByLineWithRefDataset | from torch.utils.data import Dataset
import os
from ...tokenization_utils import PreTrainedTokenizer
import json
import torch
import warnings
class LineByLineWithRefDataset(Dataset):
def __init__(self, tokenizer: PreTrainedTokenizer, file_path: str, block_size: int, ref_path: str):
warnings.warn(DEPRECATI... | """Implement class LineByLineWithRefDataset.
Required methods (implement on the class; order is not specified):
- `__init__(self, tokenizer: PreTrainedTokenizer, file_path: str, block_size: int, ref_path: str)`
- `__len__(self)`
- `__getitem__(self, i)`"""
from torch.utils.data import Dataset
import os
from ...tokeniz... |
def __init__(self, tokenizer: PreTrainedTokenizer, file_path: str, block_size: int, ref_path: str):
warnings.warn(DEPRECATION_WARNING.format('https://github.com/huggingface/transformers/blob/main/examples/pytorch/language-modeling/run_mlm_wwm.py'), FutureWarning)
if os.path.isfile(file_path) is Fal... | from torch.utils.data import Dataset
import os
from ...tokenization_utils import PreTrainedTokenizer
import json
import torch
import warnings | 3 | 0 | 3 | 0 | true | mrahman2025/OpenClassGen | [] | ||
265 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/datasets/language_modeling.py | transformers.data.datasets.language_modeling.LineByLineWithSOPTextDataset | import random
from ...tokenization_utils import PreTrainedTokenizer
from torch.utils.data import Dataset
import os
import torch
import warnings
class LineByLineWithSOPTextDataset(Dataset):
"""
Dataset for sentence order prediction task, prepare sentence pairs for SOP task
"""
def __init__(self, tokeni... | """Dataset for sentence order prediction task, prepare sentence pairs for SOP task
Required methods (implement on the class; order is not specified):
- `__init__(self, tokenizer: PreTrainedTokenizer, file_dir: str, block_size: int)`
- `create_examples_from_document(self, document, block_size, tokenizer, short_seq_prob... | """
Dataset for sentence order prediction task, prepare sentence pairs for SOP task
"""
def __init__(self, tokenizer: PreTrainedTokenizer, file_dir: str, block_size: int):
warnings.warn(DEPRECATION_WARNING.format('https://github.com/huggingface/transformers/blob/main/examples/pytorch/language-m... | import random
from ...tokenization_utils import PreTrainedTokenizer
from torch.utils.data import Dataset
import os
import torch
import warnings | 4 | 1 | 3 | 0.25 | true | mrahman2025/OpenClassGen | [] | ||
266 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/datasets/language_modeling.py | transformers.data.datasets.language_modeling.TextDataset | import torch
import warnings
from filelock import FileLock
import os
from torch.utils.data import Dataset
import time
import pickle
from typing import Optional
from ...tokenization_utils import PreTrainedTokenizer
class TextDataset(Dataset):
def __init__(self, tokenizer: PreTrainedTokenizer, file_path: str, block... | """Implement class TextDataset.
Required methods (implement on the class; order is not specified):
- `__init__(self, tokenizer: PreTrainedTokenizer, file_path: str, block_size: int, overwrite_cache=False, cache_dir: Optional[str]=None)`
- `__len__(self)`
- `__getitem__(self, i)`"""
import torch
import warnings
from fi... |
def __init__(self, tokenizer: PreTrainedTokenizer, file_path: str, block_size: int, overwrite_cache=False, cache_dir: Optional[str]=None):
warnings.warn(DEPRECATION_WARNING.format('https://github.com/huggingface/transformers/blob/main/examples/pytorch/language-modeling/run_mlm.py'), FutureWarning)
... | import torch
import warnings
from filelock import FileLock
import os
from torch.utils.data import Dataset
import time
import pickle
from typing import Optional
from ...tokenization_utils import PreTrainedTokenizer | 3 | 0 | 3 | 0 | true | mrahman2025/OpenClassGen | [] | ||
267 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/datasets/language_modeling.py | transformers.data.datasets.language_modeling.TextDatasetForNextSentencePrediction | from ...tokenization_utils import PreTrainedTokenizer
import pickle
import os
from filelock import FileLock
import warnings
import torch
import time
from torch.utils.data import Dataset
import random
class TextDatasetForNextSentencePrediction(Dataset):
def __init__(self, tokenizer: PreTrainedTokenizer, file_path:... | """Implement class TextDatasetForNextSentencePrediction.
Required methods (implement on the class; order is not specified):
- `__init__(self, tokenizer: PreTrainedTokenizer, file_path: str, block_size: int, overwrite_cache=False, short_seq_probability=0.1, nsp_probability=0.5)`
- `create_examples_from_document(self, d... |
def __init__(self, tokenizer: PreTrainedTokenizer, file_path: str, block_size: int, overwrite_cache=False, short_seq_probability=0.1, nsp_probability=0.5):
warnings.warn(DEPRECATION_WARNING.format('https://github.com/huggingface/transformers/blob/main/examples/pytorch/language-modeling/run_mlm.py'), Future... | from ...tokenization_utils import PreTrainedTokenizer
import pickle
import os
from filelock import FileLock
import warnings
import torch
import time
from torch.utils.data import Dataset
import random | 4 | 1 | 3 | 0.25 | true | mrahman2025/OpenClassGen | [] | ||
268 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/datasets/squad.py | transformers.data.datasets.squad.Split | from enum import Enum
class Split(Enum):
train = 'train'
dev = 'dev' | """Implement class Split.
Required methods (implement on the class; order is not specified):
"""
from enum import Enum
class Split: | train = 'train'
dev = 'dev'
| from enum import Enum | 0 | 0 | 0 | 0 | true | mrahman2025/OpenClassGen | [] | ||
269 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/datasets/squad.py | transformers.data.datasets.squad.SquadDataTrainingArguments | from dataclasses import dataclass, field
@dataclass
class SquadDataTrainingArguments:
"""
Arguments pertaining to what data we are going to input our model for training and eval.
"""
model_type: str = field(default=None, metadata={'help': 'Model type selected in the list: ' + ', '.join(MODEL_TYPES)})
... | """Arguments pertaining to what data we are going to input our model for training and eval.
Required methods (implement on the class; order is not specified):
"""
from dataclasses import dataclass, field
class SquadDataTrainingArguments: | class SquadDataTrainingArguments:
"""
Arguments pertaining to what data we are going to input our model for training and eval.
"""
model_type: str = field(default=None, metadata={'help': 'Model type selected in the list: ' + ', '.join(MODEL_TYPES)})
data_dir: str = field(default=None, metadata={'hel... | from dataclasses import dataclass, field | 0 | 0 | 0 | 0 | true | mrahman2025/OpenClassGen | [] | ||
270 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/datasets/squad.py | transformers.data.datasets.squad.SquadDataset | from ...utils import check_torch_load_is_safe, logging
from filelock import FileLock
import time
from ..processors.squad import SquadFeatures, SquadV1Processor, SquadV2Processor, squad_convert_examples_to_features
import os
import torch
from ...tokenization_utils import PreTrainedTokenizer
from typing import Optional, ... | """Implement class SquadDataset.
Required methods (implement on the class; order is not specified):
- `__init__(self, args: SquadDataTrainingArguments, tokenizer: PreTrainedTokenizer, limit_length: Optional[int]=None, mode: Union[str, Split]=Split.train, is_language_sensitive: Optional[bool]=False, cache_dir: Optional... | args: SquadDataTrainingArguments
features: list[SquadFeatures]
mode: Split
is_language_sensitive: bool
def __init__(self, args: SquadDataTrainingArguments, tokenizer: PreTrainedTokenizer, limit_length: Optional[int]=None, mode: Union[str, Split]=Split.train, is_language_sensitive: Optional[bool]=Fa... | from ...utils import check_torch_load_is_safe, logging
from filelock import FileLock
import time
from ..processors.squad import SquadFeatures, SquadV1Processor, SquadV2Processor, squad_convert_examples_to_features
import os
import torch
from ...tokenization_utils import PreTrainedTokenizer
from typing import Optional, ... | 3 | 0 | 3 | 0 | true | mrahman2025/OpenClassGen | [] | ||
271 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/glue.py | transformers.data.processors.glue.ColaProcessor | import warnings
from .utils import DataProcessor, InputExample, InputFeatures
import os
class ColaProcessor(DataProcessor):
"""Processor for the CoLA data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('pro... | """Processor for the CoLA data set (GLUE version).
Required methods (implement on the class; order is not specified):
- `__init__(self, *args, **kwargs)`
- `get_example_from_tensor_dict(self, tensor_dict)`: See base class.
- `get_train_examples(self, data_dir)`: See base class.
- `get_dev_examples(self, data_dir)`: Se... | """Processor for the CoLA data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('processor'), FutureWarning)
def get_example_from_tensor_dict(self, tensor_dict):
"""See base class."""
retu... | import warnings
from .utils import DataProcessor, InputExample, InputFeatures
import os | 7 | 3 | 4 | 0.857143 | true | mrahman2025/OpenClassGen | [] | ||
272 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/glue.py | transformers.data.processors.glue.MnliMismatchedProcessor | import os
import warnings
class MnliMismatchedProcessor(MnliProcessor):
"""Processor for the MultiNLI Mismatched data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('processor'), FutureWarning)
def get... | """Processor for the MultiNLI Mismatched data set (GLUE version).
Required methods (implement on the class; order is not specified):
- `__init__(self, *args, **kwargs)`
- `get_dev_examples(self, data_dir)`: See base class.
- `get_test_examples(self, data_dir)`: See base class."""
import os
import warnings
class MnliM... | """Processor for the MultiNLI Mismatched data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('processor'), FutureWarning)
def get_dev_examples(self, data_dir):
"""See base class."""
retu... | import os
import warnings | 3 | 0 | 1 | 0.666667 | true | mrahman2025/OpenClassGen | [] | ||
273 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/glue.py | transformers.data.processors.glue.MnliProcessor | import warnings
from .utils import DataProcessor, InputExample, InputFeatures
import os
class MnliProcessor(DataProcessor):
"""Processor for the MultiNLI data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format(... | """Processor for the MultiNLI data set (GLUE version).
Required methods (implement on the class; order is not specified):
- `__init__(self, *args, **kwargs)`
- `get_example_from_tensor_dict(self, tensor_dict)`: See base class.
- `get_train_examples(self, data_dir)`: See base class.
- `get_dev_examples(self, data_dir)`... | """Processor for the MultiNLI data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('processor'), FutureWarning)
def get_example_from_tensor_dict(self, tensor_dict):
"""See base class."""
... | import warnings
from .utils import DataProcessor, InputExample, InputFeatures
import os | 7 | 3 | 4 | 0.857143 | true | mrahman2025/OpenClassGen | [] | ||
274 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/glue.py | transformers.data.processors.glue.MrpcProcessor | import os
import warnings
from .utils import DataProcessor, InputExample, InputFeatures
class MrpcProcessor(DataProcessor):
"""Processor for the MRPC data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('pro... | """Processor for the MRPC data set (GLUE version).
Required methods (implement on the class; order is not specified):
- `__init__(self, *args, **kwargs)`
- `get_example_from_tensor_dict(self, tensor_dict)`: See base class.
- `get_train_examples(self, data_dir)`: See base class.
- `get_dev_examples(self, data_dir)`: Se... | """Processor for the MRPC data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('processor'), FutureWarning)
def get_example_from_tensor_dict(self, tensor_dict):
"""See base class."""
retu... | import os
import warnings
from .utils import DataProcessor, InputExample, InputFeatures | 7 | 3 | 4 | 0.857143 | true | mrahman2025/OpenClassGen | [] | ||
275 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/glue.py | transformers.data.processors.glue.OutputMode | from enum import Enum
class OutputMode(Enum):
classification = 'classification'
regression = 'regression' | """Implement class OutputMode.
Required methods (implement on the class; order is not specified):
"""
from enum import Enum
class OutputMode: | classification = 'classification'
regression = 'regression'
| from enum import Enum | 0 | 0 | 0 | 0 | true | mrahman2025/OpenClassGen | [] | ||
276 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/glue.py | transformers.data.processors.glue.QnliProcessor | import warnings
from .utils import DataProcessor, InputExample, InputFeatures
import os
class QnliProcessor(DataProcessor):
"""Processor for the QNLI data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('pro... | """Processor for the QNLI data set (GLUE version).
Required methods (implement on the class; order is not specified):
- `__init__(self, *args, **kwargs)`
- `get_example_from_tensor_dict(self, tensor_dict)`: See base class.
- `get_train_examples(self, data_dir)`: See base class.
- `get_dev_examples(self, data_dir)`: Se... | """Processor for the QNLI data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('processor'), FutureWarning)
def get_example_from_tensor_dict(self, tensor_dict):
"""See base class."""
retu... | import warnings
from .utils import DataProcessor, InputExample, InputFeatures
import os | 7 | 3 | 4 | 0.857143 | true | mrahman2025/OpenClassGen | [] | ||
277 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/glue.py | transformers.data.processors.glue.QqpProcessor | from .utils import DataProcessor, InputExample, InputFeatures
import os
import warnings
class QqpProcessor(DataProcessor):
"""Processor for the QQP data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('proce... | """Processor for the QQP data set (GLUE version).
Required methods (implement on the class; order is not specified):
- `__init__(self, *args, **kwargs)`
- `get_example_from_tensor_dict(self, tensor_dict)`: See base class.
- `get_train_examples(self, data_dir)`: See base class.
- `get_dev_examples(self, data_dir)`: See... | """Processor for the QQP data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('processor'), FutureWarning)
def get_example_from_tensor_dict(self, tensor_dict):
"""See base class."""
retur... | from .utils import DataProcessor, InputExample, InputFeatures
import os
import warnings | 7 | 3 | 4 | 0.857143 | true | mrahman2025/OpenClassGen | [] | ||
278 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/glue.py | transformers.data.processors.glue.RteProcessor | from .utils import DataProcessor, InputExample, InputFeatures
import warnings
import os
class RteProcessor(DataProcessor):
"""Processor for the RTE data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('proce... | """Processor for the RTE data set (GLUE version).
Required methods (implement on the class; order is not specified):
- `__init__(self, *args, **kwargs)`
- `get_example_from_tensor_dict(self, tensor_dict)`: See base class.
- `get_train_examples(self, data_dir)`: See base class.
- `get_dev_examples(self, data_dir)`: See... | """Processor for the RTE data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('processor'), FutureWarning)
def get_example_from_tensor_dict(self, tensor_dict):
"""See base class."""
retur... | from .utils import DataProcessor, InputExample, InputFeatures
import warnings
import os | 7 | 3 | 4 | 0.857143 | true | mrahman2025/OpenClassGen | [] | ||
279 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/glue.py | transformers.data.processors.glue.Sst2Processor | import warnings
import os
from .utils import DataProcessor, InputExample, InputFeatures
class Sst2Processor(DataProcessor):
"""Processor for the SST-2 data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('pr... | """Processor for the SST-2 data set (GLUE version).
Required methods (implement on the class; order is not specified):
- `__init__(self, *args, **kwargs)`
- `get_example_from_tensor_dict(self, tensor_dict)`: See base class.
- `get_train_examples(self, data_dir)`: See base class.
- `get_dev_examples(self, data_dir)`: S... | """Processor for the SST-2 data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('processor'), FutureWarning)
def get_example_from_tensor_dict(self, tensor_dict):
"""See base class."""
ret... | import warnings
import os
from .utils import DataProcessor, InputExample, InputFeatures | 7 | 3 | 4 | 0.857143 | true | mrahman2025/OpenClassGen | [] | ||
280 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/glue.py | transformers.data.processors.glue.StsbProcessor | from .utils import DataProcessor, InputExample, InputFeatures
import os
import warnings
class StsbProcessor(DataProcessor):
"""Processor for the STS-B data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('pr... | """Processor for the STS-B data set (GLUE version).
Required methods (implement on the class; order is not specified):
- `__init__(self, *args, **kwargs)`
- `get_example_from_tensor_dict(self, tensor_dict)`: See base class.
- `get_train_examples(self, data_dir)`: See base class.
- `get_dev_examples(self, data_dir)`: S... | """Processor for the STS-B data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('processor'), FutureWarning)
def get_example_from_tensor_dict(self, tensor_dict):
"""See base class."""
ret... | from .utils import DataProcessor, InputExample, InputFeatures
import os
import warnings | 7 | 3 | 4 | 0.857143 | true | mrahman2025/OpenClassGen | [] | ||
281 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/glue.py | transformers.data.processors.glue.WnliProcessor | import os
from .utils import DataProcessor, InputExample, InputFeatures
import warnings
class WnliProcessor(DataProcessor):
"""Processor for the WNLI data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('pro... | """Processor for the WNLI data set (GLUE version).
Required methods (implement on the class; order is not specified):
- `__init__(self, *args, **kwargs)`
- `get_example_from_tensor_dict(self, tensor_dict)`: See base class.
- `get_train_examples(self, data_dir)`: See base class.
- `get_dev_examples(self, data_dir)`: Se... | """Processor for the WNLI data set (GLUE version)."""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
warnings.warn(DEPRECATION_WARNING.format('processor'), FutureWarning)
def get_example_from_tensor_dict(self, tensor_dict):
"""See base class."""
retu... | import os
from .utils import DataProcessor, InputExample, InputFeatures
import warnings | 7 | 3 | 4 | 0.857143 | true | mrahman2025/OpenClassGen | [] | ||
282 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/squad.py | transformers.data.processors.squad.SquadExample | class SquadExample:
"""
A single training/test example for the Squad dataset, as loaded from disk.
Args:
qas_id: The example's unique identifier
question_text: The question string
context_text: The context string
answer_text: The answer string
start_position_characte... | """A single training/test example for the Squad dataset, as loaded from disk.
Args:
qas_id: The example's unique identifier
question_text: The question string
context_text: The context string
answer_text: The answer string
start_position_character: The character position of the start of the answer
... | """
A single training/test example for the Squad dataset, as loaded from disk.
Args:
qas_id: The example's unique identifier
question_text: The question string
context_text: The context string
answer_text: The answer string
start_position_character: The character pos... | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | |||
283 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/squad.py | transformers.data.processors.squad.SquadFeatures | from typing import Optional
from ...tokenization_utils_base import BatchEncoding, PreTrainedTokenizerBase, TruncationStrategy
class SquadFeatures:
"""
Single squad example features to be fed to a model. Those features are model-specific and can be crafted from
[`~data.processors.squad.SquadExample`] using ... | """Single squad example features to be fed to a model. Those features are model-specific and can be crafted from
[`~data.processors.squad.SquadExample`] using the
:method:*~transformers.data.processors.squad.squad_convert_examples_to_features* method.
Args:
input_ids: Indices of input sequence tokens in the vocabu... | """
Single squad example features to be fed to a model. Those features are model-specific and can be crafted from
[`~data.processors.squad.SquadExample`] using the
:method:*~transformers.data.processors.squad.squad_convert_examples_to_features* method.
Args:
input_ids: Indices of input sequ... | from typing import Optional
from ...tokenization_utils_base import BatchEncoding, PreTrainedTokenizerBase, TruncationStrategy | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | ||
284 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/squad.py | transformers.data.processors.squad.SquadProcessor | from tqdm import tqdm
import json
import os
from .utils import DataProcessor
class SquadProcessor(DataProcessor):
"""
Processor for the SQuAD data set. overridden by SquadV1Processor and SquadV2Processor, used by the version 1.1 and
version 2.0 of SQuAD, respectively.
"""
train_file = None
dev_... | """Processor for the SQuAD data set. overridden by SquadV1Processor and SquadV2Processor, used by the version 1.1 and
version 2.0 of SQuAD, respectively.
Required methods (implement on the class; order is not specified):
- `_get_example_from_tensor_dict(self, tensor_dict, evaluate=False)`
- `get_examples_from_dataset(... | """
Processor for the SQuAD data set. overridden by SquadV1Processor and SquadV2Processor, used by the version 1.1 and
version 2.0 of SQuAD, respectively.
"""
train_file = None
dev_file = None
def _get_example_from_tensor_dict(self, tensor_dict, evaluate=False):
if not evaluate:
... | from tqdm import tqdm
import json
import os
from .utils import DataProcessor | 5 | 3 | 2 | 0.6 | true | mrahman2025/OpenClassGen | [] | ||
285 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/squad.py | transformers.data.processors.squad.SquadResult | class SquadResult:
"""
Constructs a SquadResult which can be used to evaluate a model's output on the SQuAD dataset.
Args:
unique_id: The unique identifier corresponding to that example.
start_logits: The logits corresponding to the start of the answer
end_logits: The logits corresp... | """Constructs a SquadResult which can be used to evaluate a model's output on the SQuAD dataset.
Args:
unique_id: The unique identifier corresponding to that example.
start_logits: The logits corresponding to the start of the answer
end_logits: The logits corresponding to the end of the answer
Required me... | """
Constructs a SquadResult which can be used to evaluate a model's output on the SQuAD dataset.
Args:
unique_id: The unique identifier corresponding to that example.
start_logits: The logits corresponding to the start of the answer
end_logits: The logits corresponding to the end o... | 1 | 0 | 1 | 0 | true | mrahman2025/OpenClassGen | [] | |||
286 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/squad.py | transformers.data.processors.squad.SquadV1Processor | class SquadV1Processor(SquadProcessor):
train_file = 'train-v1.1.json'
dev_file = 'dev-v1.1.json' | """Implement class SquadV1Processor.
Required methods (implement on the class; order is not specified):
"""
class SquadV1Processor: | train_file = 'train-v1.1.json'
dev_file = 'dev-v1.1.json'
| 0 | 0 | 0 | 0 | true | mrahman2025/OpenClassGen | [] | |||
287 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/squad.py | transformers.data.processors.squad.SquadV2Processor | class SquadV2Processor(SquadProcessor):
train_file = 'train-v2.0.json'
dev_file = 'dev-v2.0.json' | """Implement class SquadV2Processor.
Required methods (implement on the class; order is not specified):
"""
class SquadV2Processor: | train_file = 'train-v2.0.json'
dev_file = 'dev-v2.0.json'
| 0 | 0 | 0 | 0 | true | mrahman2025/OpenClassGen | [] | |||
288 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/utils.py | transformers.data.processors.utils.DataProcessor | import csv
class DataProcessor:
"""Base class for data converters for sequence classification data sets."""
def get_example_from_tensor_dict(self, tensor_dict):
"""
Gets an example from a dict.
Args:
tensor_dict: Keys and values should match the corresponding Glue
... | """Base class for data converters for sequence classification data sets.
Required methods (implement on the class; order is not specified):
- `get_example_from_tensor_dict(self, tensor_dict)`: Gets an example from a dict.
- `get_train_examples(self, data_dir)`: Gets a collection of [`InputExample`] for the train set.
... | """Base class for data converters for sequence classification data sets."""
def get_example_from_tensor_dict(self, tensor_dict):
"""
Gets an example from a dict.
Args:
tensor_dict: Keys and values should match the corresponding Glue
tensorflow_dataset exampl... | import csv | 7 | 1 | 6 | 1 | true | mrahman2025/OpenClassGen | [] | ||
289 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/utils.py | transformers.data.processors.utils.InputExample | from dataclasses import dataclass
import json
from typing import Optional, Union
import dataclasses
@dataclass
class InputExample:
"""
A single training/test example for simple sequence classification.
Args:
guid: Unique id for the example.
text_a: string. The untokenized text of the first... | """A single training/test example for simple sequence classification.
Args:
guid: Unique id for the example.
text_a: string. The untokenized text of the first sequence. For single
sequence tasks, only this sequence must be specified.
text_b: (Optional) string. The untokenized text of the second seq... | class InputExample:
"""
A single training/test example for simple sequence classification.
Args:
guid: Unique id for the example.
text_a: string. The untokenized text of the first sequence. For single
sequence tasks, only this sequence must be specified.
text_b: (Optiona... | from dataclasses import dataclass
import json
from typing import Optional, Union
import dataclasses | 1 | 0 | 1 | 1 | true | mrahman2025/OpenClassGen | [] | ||
290 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/utils.py | transformers.data.processors.utils.InputFeatures | import json
import dataclasses
from typing import Optional, Union
from dataclasses import dataclass
@dataclass(frozen=True)
class InputFeatures:
"""
A single set of features of data. Property names are the same names as the corresponding inputs to a model.
Args:
input_ids: Indices of input sequenc... | """A single set of features of data. Property names are the same names as the corresponding inputs to a model.
Args:
input_ids: Indices of input sequence tokens in the vocabulary.
attention_mask: Mask to avoid performing attention on padding token indices.
Mask values selected in `[0, 1]`: Usually `1` ... | class InputFeatures:
"""
A single set of features of data. Property names are the same names as the corresponding inputs to a model.
Args:
input_ids: Indices of input sequence tokens in the vocabulary.
attention_mask: Mask to avoid performing attention on padding token indices.
... | import json
import dataclasses
from typing import Optional, Union
from dataclasses import dataclass | 1 | 0 | 1 | 1 | true | mrahman2025/OpenClassGen | [] | ||
291 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/utils.py | transformers.data.processors.utils.SingleSentenceClassificationProcessor | from ...utils import is_torch_available, logging
class SingleSentenceClassificationProcessor(DataProcessor):
"""Generic processor for a single sentence classification data set."""
def __init__(self, labels=None, examples=None, mode='classification', verbose=False):
self.labels = [] if labels is None e... | """Generic processor for a single sentence classification data set.
Required methods (implement on the class; order is not specified):
- `__init__(self, labels=None, examples=None, mode='classification', verbose=False)`
- `__len__(self)`
- `__getitem__(self, idx)`
- `create_from_csv(cls, file_name, split_name='', colu... | """Generic processor for a single sentence classification data set."""
def __init__(self, labels=None, examples=None, mode='classification', verbose=False):
self.labels = [] if labels is None else labels
self.examples = [] if examples is None else examples
self.mode = mode
self.... | from ...utils import is_torch_available, logging | 8 | 1 | 7 | 0.125 | true | mrahman2025/OpenClassGen | [] | ||
292 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/data/processors/xnli.py | transformers.data.processors.xnli.XnliProcessor | from .utils import DataProcessor, InputExample
import os
class XnliProcessor(DataProcessor):
"""
Processor for the XNLI dataset. Adapted from
https://github.com/google-research/bert/blob/f39e881b169b9d53bea03d2d341b31707a6c052b/run_classifier.py#L207
"""
def __init__(self, language, train_language... | """Processor for the XNLI dataset. Adapted from
https://github.com/google-research/bert/blob/f39e881b169b9d53bea03d2d341b31707a6c052b/run_classifier.py#L207
Required methods (implement on the class; order is not specified):
- `__init__(self, language, train_language=None)`
- `get_train_examples(self, data_dir)`: See b... | """
Processor for the XNLI dataset. Adapted from
https://github.com/google-research/bert/blob/f39e881b169b9d53bea03d2d341b31707a6c052b/run_classifier.py#L207
"""
def __init__(self, language, train_language=None):
self.language = language
self.train_language = train_language
def... | from .utils import DataProcessor, InputExample
import os | 4 | 0 | 2 | 0.75 | true | mrahman2025/OpenClassGen | [] | ||
293 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/debug_utils.py | transformers.debug_utils.DebugOption | from .utils import ExplicitEnum, is_torch_available, logging
class DebugOption(ExplicitEnum):
UNDERFLOW_OVERFLOW = 'underflow_overflow'
TPU_METRICS_DEBUG = 'tpu_metrics_debug' | """Implement class DebugOption.
Required methods (implement on the class; order is not specified):
"""
from .utils import ExplicitEnum, is_torch_available, logging
class DebugOption: | UNDERFLOW_OVERFLOW = 'underflow_overflow'
TPU_METRICS_DEBUG = 'tpu_metrics_debug'
| from .utils import ExplicitEnum, is_torch_available, logging | 0 | 0 | 0 | 0 | true | mrahman2025/OpenClassGen | [] | ||
294 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/debug_utils.py | transformers.debug_utils.DebugUnderflowOverflow | import collections
class DebugUnderflowOverflow:
"""
This debug class helps detect and understand where the model starts getting very large or very small, and more
importantly `nan` or `inf` weight and activation elements.
There are 2 working modes:
1. Underflow/overflow detection (default)
2... | """This debug class helps detect and understand where the model starts getting very large or very small, and more
importantly `nan` or `inf` weight and activation elements.
There are 2 working modes:
1. Underflow/overflow detection (default)
2. Specific batch absolute min/max tracing without detection
Mode 1: Underf... | """
This debug class helps detect and understand where the model starts getting very large or very small, and more
importantly `nan` or `inf` weight and activation elements.
There are 2 working modes:
1. Underflow/overflow detection (default)
2. Specific batch absolute min/max tracing without ... | import collections | 14 | 14 | 7 | 0 | true | mrahman2025/OpenClassGen | [] | ||
295 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/feature_extraction_sequence_utils.py | transformers.feature_extraction_sequence_utils.SequenceFeatureExtractor | from .utils import PaddingStrategy, TensorType, is_torch_tensor, logging, to_numpy
import numpy as np
from .feature_extraction_utils import BatchFeature, FeatureExtractionMixin
from typing import Optional, Union
class SequenceFeatureExtractor(FeatureExtractionMixin):
"""
This is a general feature extraction cl... | """This is a general feature extraction class for speech recognition.
Args:
feature_size (`int`):
The feature dimension of the extracted features.
sampling_rate (`int`):
The sampling rate at which the audio files should be digitalized expressed in hertz (Hz).
padding_value (`float`):
... | """
This is a general feature extraction class for speech recognition.
Args:
feature_size (`int`):
The feature dimension of the extracted features.
sampling_rate (`int`):
The sampling rate at which the audio files should be digitalized expressed in hertz (Hz).
... | from .utils import PaddingStrategy, TensorType, is_torch_tensor, logging, to_numpy
import numpy as np
from .feature_extraction_utils import BatchFeature, FeatureExtractionMixin
from typing import Optional, Union | 5 | 3 | 4 | 0.8 | true | mrahman2025/OpenClassGen | [] | ||
296 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/feature_extraction_utils.py | transformers.feature_extraction_utils.BatchFeature | import numpy as np
from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
from collections import UserDict
from .utils import FEATURE_EXTRACTOR_NAME, PROCESSOR_NAME, PushToHubMixin, TensorType, copy_func, download_url, is_numpy_array, is_offline_mode, is_remote_url, is_torch_available, is_torch_device, is_torc... | """Holds the output of the [`~SequenceFeatureExtractor.pad`] and feature extractor specific `__call__` methods.
This class is derived from a python dictionary and can be used as a dictionary.
Args:
data (`dict`, *optional*):
Dictionary of lists/arrays/tensors returned by the __call__/pad methods ('input_v... | """
Holds the output of the [`~SequenceFeatureExtractor.pad`] and feature extractor specific `__call__` methods.
This class is derived from a python dictionary and can be used as a dictionary.
Args:
data (`dict`, *optional*):
Dictionary of lists/arrays/tensors returned by the __cal... | import numpy as np
from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
from collections import UserDict
from .utils import FEATURE_EXTRACTOR_NAME, PROCESSOR_NAME, PushToHubMixin, TensorType, copy_func, download_url, is_numpy_array, is_offline_mode, is_remote_url, is_torch_available, is_torch_device, is_torc... | 8 | 2 | 5 | 0.375 | true | mrahman2025/OpenClassGen | [] | ||
297 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/feature_extraction_utils.py | transformers.feature_extraction_utils.FeatureExtractionMixin | from .dynamic_module_utils import custom_object_save
from .utils.hub import cached_file
from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
import os
import copy
import json
import warnings
from .utils import FEATURE_EXTRACTOR_NAME, PROCESSOR_NAME, PushToHubMixin, TensorType, copy_func, download_url, is_num... | """This is a feature extraction mixin used to provide saving/loading functionality for sequential and image feature
extractors.
Required methods (implement on the class; order is not specified):
- `__init__(self, **kwargs)`: Set elements of `kwargs` as attributes.
- `_set_processor_class(self, processor_class: str)`: ... | """
This is a feature extraction mixin used to provide saving/loading functionality for sequential and image feature
extractors.
"""
_auto_class = None
def __init__(self, **kwargs):
"""Set elements of `kwargs` as attributes."""
self._processor_class = kwargs.pop('processor_class... | from .dynamic_module_utils import custom_object_save
from .utils.hub import cached_file
from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
import os
import copy
import json
import warnings
from .utils import FEATURE_EXTRACTOR_NAME, PROCESSOR_NAME, PushToHubMixin, TensorType, copy_func, download_url, is_num... | 12 | 4 | 8 | 0.916667 | true | mrahman2025/OpenClassGen | [] | ||
298 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/generation/beam_constraints.py | transformers.generation.beam_constraints.Constraint | from abc import ABC, abstractmethod
class Constraint(ABC):
"""Abstract base class for all constraints that can be applied during generation.
It must define how the constraint can be satisfied.
All classes that inherit Constraint must follow the requirement that
```py
completed = False
while n... | """Abstract base class for all constraints that can be applied during generation.
It must define how the constraint can be satisfied.
All classes that inherit Constraint must follow the requirement that
```py
completed = False
while not completed:
_, completed = constraint.update(constraint.advance())
```
will a... | """Abstract base class for all constraints that can be applied during generation.
It must define how the constraint can be satisfied.
All classes that inherit Constraint must follow the requirement that
```py
completed = False
while not completed:
_, completed = constraint.update(const... | from abc import ABC, abstractmethod | 8 | 6 | 6 | 0.875 | true | mrahman2025/OpenClassGen | [] | ||
299 | huggingface/pytorch-pretrained-BERT | huggingface_pytorch-pretrained-BERT/src/transformers/generation/beam_constraints.py | transformers.generation.beam_constraints.ConstraintListState | from typing import Optional
class ConstraintListState:
"""
A class for beam scorers to track its progress through a list of constraints.
Args:
constraints (`list[Constraint]`):
A list of [`Constraint`] objects that must be fulfilled by the beam scorer.
"""
def __init__(self, c... | """A class for beam scorers to track its progress through a list of constraints.
Args:
constraints (`list[Constraint]`):
A list of [`Constraint`] objects that must be fulfilled by the beam scorer.
Required methods (implement on the class; order is not specified):
- `__init__(self, constraints: list[Constr... | """
A class for beam scorers to track its progress through a list of constraints.
Args:
constraints (`list[Constraint]`):
A list of [`Constraint`] objects that must be fulfilled by the beam scorer.
"""
def __init__(self, constraints: list[Constraint]):
self.constraints ... | from typing import Optional | 7 | 3 | 5 | 0.285714 | true | mrahman2025/OpenClassGen | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.