transformers
/transformers
Pomaga pracować z wstępnie wytrenowanymi modelami transformer w tekście, obrazie, audio i multimodalności, także przy dostrajaniu.
- Autor
- synthetic-sciences ↗
- Repozytorium
- openscience ↗
- Licencja
- Apache-2.0
- Ostatnia zmiana repozytorium
- 25.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 6
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 1
Brak sygnałów. Repozytorium zmienione 25.10.2026, bez odwołań do wycofanych modeli i API.
Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.
Co robi i kiedy
Pomaga pracować z wstępnie wytrenowanymi modelami transformer w tekście, obrazie, audio i multimodalności, także przy dostrajaniu.
Oryginalny opis (EN)
This skill should be used when working with pre-trained transformer models for natural language processing, computer vision, audio, or multimodal tasks. Use for text generation, classification, question answering, translation, summarization, image classification, object detection, speech recognition, and fine-tuning models on custom datasets.
Jak działa
- Overview
- Installation
- Credential Setup
- Quick Start
- Core Capabilities
- Common Patterns
- Reference Documentation
Podgląd SKILL.md
---
name: transformers
description: This skill should be used when working with pre-trained transformer models for natural language processing, computer vision, audio, or multimodal tasks. Use for text generation, classification, question answering, translation, summarization, image classification, object detection, speech recognition, and fine-tuning models on custom datasets.
category: llm-tools
license: Apache-2.0 license
compatibility: Some features require an Huggingface token
metadata:
upstream: K-Dense-AI/scientific-agent-skills
upstream-url: https://github.com/K-Dense-AI/scientific-agent-skills
upstream-path: skills/transformers
upstream-license: MIT
upstream-relationship: derived
adapted-by: Synthetic Sciences
skill-author: K-Dense Inc.
version: 1.0.0
author: K-Dense Inc.
tags: [NLP, Deep Learning, Hugging Face, LLM, Fine-Tuning]
dependencies: ["transformers>=4.45.0", "torch>=2.0.0", "tokenizers>=0.19.0"]
---
# Transformers
## Overview
The Hugging Face Transformers library provides access to thousands of pre-trained models for tasks across NLP, computer vision, audio, and multimodal domains. Use this skill to load models, perform inference, and fine-tune on custom data.
## Installation
Install transformers and core dependencies:
```bash
uv pip install torch transformers datasets evaluate accelerate
```
For vision tasks, add:
```bash
uv pip install timm pillow
```
For audio tasks, add:
```bash
uv pip install librosa soundfile
```
## Credential Setup
HuggingFace token is auto-injected by openscience when connected via the dashboard.
```bash
# Verify credentials
[ -n "$HF_TOKEN" ] && echo "HF_TOKEN set" || echo "NOT SET"
```
If not set: add your Hugging Face token in Customize → Tools or export `HF_TOKEN` locally.
## Quick Start
Use the Pipeline API for fast inference without manual configuration:
```python
from transformers import pipeline
# Text generation
generator = pipeline("text-generation", model="gpt2")
result = generator("The future of AI is", max_length=50)
# Text classification
classifier = pipeline("text-classification")
result = classifier("This movie was excellent!")
# Question answering
qa = pipeline("question-answering")
result = qa(question="What is AI?", context="AI is artificial intelligence...")
```
## Core Capabilities
### 1. Pipelines for Quick Inference
Use for simple, optimized inference across many tasks. Supports text generation, classification, NER, question answering, summarization, translation, image classification, object detection, audio classification, and more.
**When to use**: Quick prototyping, simple inference tasks, no custom preprocessing needed.
See `references/pipelines.md` for comprehensive task coverage and optimization.
### 2. Model Loading and Management
Load pre-trained models with fine-grained control over configuration, device placement, and precision.
**When to use**: Custom model initialization, advanced device management, model inspection.
See `references/models.md` for loading patterns and best practices.
### 3. Text Generation
Generate text with LLMs using various decoding strategies (greedy, beam search, sampling) and control parameters (temperature, top-k, top-p).
**When to use**: Creative text generation, code generation, conversational AI, text completion.
See `references/generation.md` for generation strategies and parameters.
### 4. Training and Fine-Tuning
Fine-tune pre-trained models on custom datasets using the Trainer API with automatic mixed precision, distributed training, and logging.
**When to use**: Task-specific model adaptation, domain adaptation, improving model performance.
See `references/training.md` for training workflows and best practices.
### 5. Tokenization
Convert text to tokens and token IDs for model input, with padding, truncation, and special token handling.
**When to use**: Custom preprocessing pipelines, understanding model inputs, batch processing.
See `references/tokenizers.md` for tokenization details.
## Common Patterns
### Pattern 1: Simple Inference
For straightforward tasks, use pipelines:
```python
pipe = pipeline("task-name", model="model-id")
output = pipe(input_data)
```
### Pattern 2: Custom Model Usage
For advanced control, load model and tokenizer separately:
```python
from transformers import AutoModelForCausalLM, AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("model-id")
model = AutoModelForCausalLM.from_pretrained("model-id", device_map="auto")
inputs = tokenizer("text", return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=100)
result = tokenizer.decode(outputs[0])
```
### Pattern 3: Fine-Tuning
For task adaptation, use Trainer:
```python
from transformers import Trainer, TrainingArguments
training_args = TrainingArguments(
output_dir="./results",
num_train_epochs=3,
per_device_train_batch_size=8,
)
trainer = Trainer(
model=model,
args=training_args,
train_dataset=train_dataset,
)
trainer.train()
```
## Reference Documentation
For detailed information on specific components:
- **Pipelines**: `references/pipelines.md` - All supported tasks and optimization
- **Models**: `references/models.md` - Loading, saving, and configuration
- **Generation**: `references/generation.md` - Text generation strategies and parameters
- **Training**: `references/training.md` - Fine-tuning with Trainer API
- **Tokenizers**: `references/tokenizers.md` - Tokenization and preprocessing
Pliki w paczce (6)
- SKILL.md 5 KB
- references/generation.md 9 KB
- references/models.md 8 KB
- references/pipelines.md 9 KB
- references/tokenizers.md 10 KB
- references/training.md 10 KB
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · synthetic-sciences/openscience | 100 | Apache-2.0 |
| lamm-mit/scienceclaw | 100 | Apache-2.0 |
| bestagentkits/agency-skills | 100 | MIT |
| davila7/claude-code-templates | 95 | MIT |
Migawka bazy z 13.11.2026 · wersja paczki 9acc48cfe71b (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 95transformers-js
Uruchamia modele Hugging Face w JavaScript lub TypeScript przez Transformers.js w przeglądarce lub Node.js, bez backendu Python. - 95huggingface-transformers
Opisuje dobre praktyki pracy z Hugging Face Transformers: ładowanie modeli, tokenizację, dostrajanie, zadania NLP i optymalizację wnioskowania. - 100alterlab-transformers
Ładuje, uruchamia i dostraja wstępnie wytrenowane modele w Hugging Face Transformers v5: pipeline do generowania tekstu, klasyfikacji, NER i rozpoznawania mowy, kwantyzacja i fine-tuning z LoRA. - 100transformers-inference
Uruchamia wnioskowanie modeli Transformers do klasyfikacji, NER, pytań, streszczeń i embeddingów, bez trenowania dużych modeli. - 100processing-computer-vision-tasks
Przetwarza obrazy za pomocą wykrywania obiektów, klasyfikacji i segmentacji, przy analizie obrazu i zadaniach widzenia komputerowego. - 100processing-computer-vision-tasks
Przetwarza obrazy za pomocą wykrywania obiektów, klasyfikacji i segmentacji, przy analizie obrazu i zadaniach widzenia komputerowego.