def forward(self, input_ids, attention_mask):
    outputs = self.gpt2(input_ids=input_ids, attention_mask=attention_mask)
    pooled_output = outputs[0].mean(dim=1)  # Average pooling
    pooled_output = self.dropout(pooled_output)
    genre_logits = self.genre_classifier(pooled_output)
    return self.sigmoid(genre_logits)

def _load_genre_labels(self):
    """Load predefined genre labels"""
    # You would typically load these from a file or database
    return [
        "Fiction", "Non-fiction", "Mystery", "Romance", "Science Fiction",
        "Fantasy", "Thriller", "Horror", "Historical Fiction", "Biography",
        "Self-help", "Business", "Science", "Philosophy", "Poetry",
        "Drama", "Adventure", "Literary Fiction", "Young Adult", "Children's"
    ]

def preprocess_text(self, text):
    """Preprocess the book text"""
    # Tokenize and remove stop words
    tokens = word_tokenize(text.lower())
    tokens = [t for t in tokens if t not in self.stop_words]
    
    # Convert to GPT2 tokens
    encodings = self.tokenizer(
        ' '.join(tokens),
        truncation=True,
        max_length=1024,
        padding='max_length',
        return_tensors='pt'
    )
    return encodings

def extract_features(self, text):
    """Extract relevant features from the text"""
    encodings = self.preprocess_text(text)
    with torch.no_grad():
        features = self.model(
            input_ids=encodings['input_ids'],
            attention_mask=encodings['attention_mask']
        )
    return features

def fine_tune_with_gpt3(self, training_data):
    """Fine-tune the model using GPT-3"""
    # Prepare training data in the format expected by OpenAI
    formatted_data = []
    for book_text, genres in training_data:
        formatted_data.append({
            "prompt": f"Book text: {book_text[:1000]}...\nGenres:",
            "completion": f" {', '.join(genres)}"
        })
        
    # Create fine-tuning job
    try:
        response = openai.FineTune.create(
            training_file=self._upload_training_data(formatted_data),
            model="gpt-3",
            n_epochs=3,
            batch_size=4,
            learning_rate_multiplier=0.1
        )
        return response
    except Exception as e:
        print(f"Fine-tuning error: {e}")
        return None

def _upload_training_data(self, formatted_data):
    """Upload training data to OpenAI"""
    import json
    with open('training_data.jsonl', 'w') as f:
        for entry in formatted_data:
            json.dump(entry, f)
            f.write('\n')
            
    with open('training_data.jsonl', 'rb') as f:
        response = openai.File.create(
            file=f,
            purpose='fine-tune'
        )
    return response.id

def analyze_book(self, book_text):
    """Analyze a book and return top 20 genres with confidence scores"""
    # Get base predictions from our model
    features = self.extract_features(book_text)
    predictions = features.numpy()[0]
    
    # Use GPT-3 to enhance predictions
    try:
        response = openai.Completion.create(
            model="gpt-3",  # Use fine-tuned model ID if available
            prompt=f"Book text: {book_text[:1000]}...\nGenres:",
            max_tokens=100,
            temperature=0.3
        )
        gpt3_genres = response.choices[0].text.strip().split(', ')
    except:
        gpt3_genres = []
    
    # Combine both predictions
    genres_with_scores = [
        (genre, float(score))
        for genre, score in zip(self.genre_labels, predictions)
    ]
    
    # Boost scores for genres mentioned by GPT-3
    for genre, score in genres_with_scores:
        if genre in gpt3_genres:
            score *= 1.2
            
    # Sort and return top 20
    return sorted(genres_with_scores, key=lambda x: x[1], reverse=True)[:20]

# Example book text
book_text = """
[Your book text here]
"""

# Get genre predictions
genres = analyzer.analyze_book(book_text)

# Print results
print("\nTop 20 Genres:")
for genre, confidence in genres:
    print(f"{genre}: {confidence:.2%}")
    
# Example of fine-tuning
training_data = [
    ("Book 1 text...", ["Mystery", "Thriller"]),
    ("Book 2 text...", ["Science Fiction", "Adventure"]),
    # Add more training examples
]

fine_tune_response = analyzer.fine_tune_with_gpt3(training_data)
if fine_tune_response:
    print("\nFine-tuning job created successfully!")