Машинное обучение для создания заголовков с максимальным CTR в поиске

# train.py
import torch
from torch.utils.data import Dataset, DataLoader
from transformers import GPT2Tokenizer, GPT2LMHeadModel, get_linear_schedule_with_warmup
import pytorch_lightning as pl
from pytorch_lightning.callbacks import ModelCheckpoint

# 1. Токенизатор и словарь
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
tokenizer.add_special_tokens({'pad_token': '[PAD]', 'bos_token': '[BOS]', 'eos_token': '[EOS]'})

# 2. Dataset
class HeadlinesDataset(Dataset):
    def __init__(self, texts, tokenizer, max_len=64):
        self.texts = texts
        self.tokenizer = tokenizer
        self.max_len = max_len

    def __len__(self):
        return len(self.texts)

    def __getitem__(self, idx):
        enc = self.tokenizer(self.texts[idx],
                            truncation=True,
                            padding='max_length',
                            max_length=self.max_len,
                            return_tensors='pt')
        input_ids = enc['input_ids'].squeeze()
        attention_mask = enc['attention_mask'].squeeze()
        return {'input_ids': input_ids, 'attention_mask': attention_mask, 'labels': input_ids}

# 3. LightningModule
class GPT2FineTuner(pl.LightningModule):
    def __init__(self, lr=5e-5, epochs=3, batch_size=16):
        super().__init__()
        self.save_hyperparameters()
        self.model = GPT2LMHeadModel.from_pretrained('gpt2')
        self.model.resize_token_embeddings(len(tokenizer))
        self.criterion = torch.nn.CrossEntropyLoss(ignore_index=tokenizer.pad_token_id)

    def forward(self, input_ids, attention_mask, labels):
        return self.model(input_ids=input_ids,
                          attention_mask=attention_mask,
                          labels=labels)

    def training_step(self, batch, batch_idx):
        outputs = self(**batch)
        loss = outputs.loss
        self.log('train_loss', loss, prog_bar=True)
        return loss

    def validation_step(self, batch, batch_idx):
        outputs = self(**batch)
        loss = outputs.loss
        self.log('val_loss', loss, prog_bar=True)

    def configure_optimizers(self):
        optimizer = torch.optim.AdamW(self.parameters(), lr=self.hparams.lr)
        scheduler = get_linear_schedule_with_warmup(optimizer,
                                                     num_warmup_steps=0,
                                                     num_training_steps=self.trainer.estimated_stepping_batches)
        return [optimizer], [{'scheduler': scheduler, 'interval': 'step'}]

# 4. DataLoader
train_texts = ["SEO оптимизация: как увеличить CTR", "Лучшие практики для поисковой выдачи", ...]  # placeholder
val_texts   = ["Как повысить видимость сайта в Google", ...]
train_ds = HeadlinesDataset(train_texts, tokenizer)
val_ds   = HeadlinesDataset(val_texts, tokenizer)

train_loader = DataLoader(train_ds, batch_size=16, shuffle=True, num_workers=4)
val_loader   = DataLoader(val_ds, batch_size=16, shuffle=False, num_workers=4)

# 5. Training
model = GPT2FineTuner()
checkpoint_cb = ModelCheckpoint(dirpath='checkpoints', filename='gpt2-headlines-{epoch}-{val_loss:.2f}')
trainer = pl.Trainer(max_epochs=3,
                     gpus=1 if torch.cuda.is_available() else 0,
                     callbacks=[checkpoint_cb])
trainer.fit(model, train_loader, val_loader)

# inference.py
import argparse
from transformers import GPT2Tokenizer, GPT2LMHeadModel

def generate_headlines(prompt, tokenizer, model, max_len=64, num_return=3):
    input_ids = tokenizer.encode(prompt, return_tensors='pt')
    if torch.cuda.is_available():
        input_ids = input_ids.cuda()
        model = model.cuda()
    outputs = model.generate(input_ids,
                             max_length=max_len,
                             num_return_sequences=num_return,
                             no_repeat_ngram_size=2,
                             top_k=50,
                             top_p=0.95,
                             temperature=0.7,
                             pad_token_id=tokenizer.pad_token_id)
    return [tokenizer.decode(o, skip_special_tokens=True) for o in outputs]

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument('--text', type=str, required=True, help='Тема статьи')
    args = parser.parse_args()

    tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
    tokenizer.add_special_tokens({'pad_token': '[PAD]'})
    model = GPT2LMHeadModel.from_pretrained('checkpoints/gpt2-headlines-epoch=2-val_loss=0.35.pt')
    model.resize_token_embeddings(len(tokenizer))
    if torch.cuda.is_available():
        model = model.cuda()

    headlines = generate_headlines(args.text, tokenizer, model)
    for i, h in enumerate(headlines, 1):
        print(f"{i}. {h}")

import requests, json, os
from google.oauth2 import service_account
from googleapiclient.discovery import build

SCOPES = ['https://www.googleapis.com/auth/analytics.readonly']
KEY_FILE = 'service_account.json'
PROPERTY_ID = '12345678'

def fetch_ctr():
    analytics = build('analyticsreporting', 'v4', credentials=service_account.Credentials.from_service_account_file(KEY_FILE, scopes=SCOPES))
    response = analytics.reports().batchGet(
        body={'reportRequests': [{'viewId': PROPERTY_ID, 'dateRanges': [{'startDate': '7daysAgo', 'endDate': 'today'}],
                                 'metrics': [{'expression': 'ga:clicks'}, {'expression': 'ga:impressions'}]}]}).execute()
    clicks = int(response['reports'][0]['data']['rows'][0]['metrics'][0]['values'][0])
    impressions = int(response['reports'][0]['data']['rows'][0]['metrics'][0]['values'][1])
    return clicks / impressions if impressions else 0

def trigger_retrain():
    ctr = fetch_ctr()
    if ctr