import os
import argparse
import json
import numpy as np
from tqdm import tqdm
import nltk
from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction
from rouge import Rouge
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import re
from textstat import flesch_reading_ease
from datasets import load_dataset
import openai
from datetime import datetime
nltk.download('punkt', quiet=True)
nltk.download('averaged_perceptron_tagger', quiet=True)
def preprocess(text):
return nltk.word_tokenize(text.lower())
def calculate_bleu(reference, candidate):
reference_tokens = preprocess(reference)
candidate_tokens = preprocess(candidate)
smoothie = SmoothingFunction().method1
return sentence_bleu([reference_tokens], candidate_tokens, smoothing_function=smoothie)
def calculate_rouge(reference, candidate):
rouge = Rouge()
scores = rouge.get_scores(candidate, reference)
return {
'rouge-1': scores[0]['rouge-1']['f'],
'rouge-2': scores[0]['rouge-2']['f'],
'rouge-l': scores[0]['rouge-l']['f']
}
def calculate_cosine_similarity(reference, candidate):
vectorizer = TfidfVectorizer()
tfidf_matrix = vectorizer.fit_transform([reference, candidate])
return cosine_similarity(tfidf_matrix[0:1], tfidf_matrix[1:2])[0][0]
def extract_sections(readme):
sections = []
current_section = ""
for line in readme.split('\n'):
if line.strip().startswith('#'):
if current_section:
sections.append(current_section.strip())
current_section = line + "\n"
else:
current_section += line + "\n"
if current_section:
sections.append(current_section.strip())
return sections
def calculate_structural_similarity(reference, candidate):
ref_sections = extract_sections(reference)
cand_sections = extract_sections(candidate)
section_diff = abs(len(ref_sections) - len(cand_sections))
ref_titles = [s.split('\n')[0] for s in ref_sections]
cand_titles = [s.split('\n')[0] for s in cand_sections]
title_similarity = len(set(ref_titles) & set(cand_titles)) / max(len(ref_titles), len(cand_titles))
return {
'section_difference': section_diff,
'title_similarity': title_similarity
}
def information_retrieval_score(readme):
key_sections = ['installation', 'usage', 'api', 'example', 'license']
found_sections = sum(1 for section in key_sections if section in readme.lower())
return found_sections / len(key_sections)
def code_readme_consistency(repo_content, readme):
code_elements = set(re.findall(r'def\s+(\w+)', repo_content) +
re.findall(r'class\s+(\w+)', repo_content))
mentioned_elements = sum(1 for element in code_elements if element in readme)
return mentioned_elements / len(code_elements) if code_elements else 0
def calculate_readability(text):
return flesch_reading_ease(text) / 100
def evaluate_readme(reference_readme, generated_readme, repo_content):
bleu_score = calculate_bleu(reference_readme, generated_readme)
rouge_scores = calculate_rouge(reference_readme, generated_readme)
cosine_sim = calculate_cosine_similarity(reference_readme, generated_readme)
structural_sim = calculate_structural_similarity(reference_readme, generated_readme)
info_retrieval = information_retrieval_score(generated_readme)
code_consistency = code_readme_consistency(repo_content, generated_readme)
readability = calculate_readability(generated_readme)
weights = {
'bleu': 0.1,
'rouge-1': 0.1,
'rouge-2': 0.1,
'rouge-l': 0.1,
'cosine_similarity': 0.1,
'structural_similarity': 0.1,
'information_retrieval': 0.15,
'code_consistency': 0.15,
'readability': 0.1
}
weighted_score = (
weights['bleu'] * bleu_score +
weights['rouge-1'] * rouge_scores['rouge-1'] +
weights['rouge-2'] * rouge_scores['rouge-2'] +
weights['rouge-l'] * rouge_scores['rouge-l'] +
weights['cosine_similarity'] * cosine_sim +
weights['structural_similarity'] * structural_sim['title_similarity'] +
weights['information_retrieval'] * info_retrieval +
weights['code_consistency'] * code_consistency +
weights['readability'] * readability
)
return {
'bleu': bleu_score,
'rouge': rouge_scores,
'cosine_similarity': cosine_sim,
'structural_similarity': structural_sim,
'information_retrieval': info_retrieval,
'code_consistency': code_consistency,
'readability': readability,
'weighted_score': weighted_score
}
def generate_readme(repo_content, model, client):
system_prompt = """You are an AI assistant tasked with creating a README.md file for a GitHub repository.
Your response should contain ONLY the content of the README.md file, without any additional explanations or markdown code blocks.
The README should include the following sections:
1. Project Title
2. Description
3. Installation
4. Usage
5. Features
6. Contributing
7. License
Ensure that your response is well-structured, informative, and directly usable as a README.md file."""
user_prompt = f"Here is the content of the repository:\n\n{repo_content}\n\nBased on this content, please generate a README.md file."
response = client.chat.completions.create(
model=model,
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
]
)
return response.choices[0].message.content
def main(args):
openai.api_key = os.getenv("OPENAI_API_KEY")
if not openai.api_key:
raise ValueError("OPENAI_API_KEY environment variable is not set")
client = openai.OpenAI(base_url=args.base_url) if args.base_url else openai.OpenAI()
dataset = load_dataset("patched-codes/generate-readme-eval")
results = []
for item in tqdm(dataset['test'], desc="Processing repos"):
try:
generated_readme = generate_readme(item['repo_content'], args.model, client)
eval_result = evaluate_readme(item['repo_readme'], generated_readme, item['repo_content'])
# Add repo_name to the eval_result
eval_result['repo_name'] = item['repo_name']
results.append(eval_result)
except Exception as e:
print(f"Error processing repo {item['repo_name']}: {e}")
continue
average_scores = {
'bleu': np.mean([r['bleu'] for r in results]),
'rouge-1': np.mean([r['rouge']['rouge-1'] for r in results]),
'rouge-2': np.mean([r['rouge']['rouge-2'] for r in results]),
'rouge-l': np.mean([r['rouge']['rouge-l'] for r in results]),
'cosine_similarity': np.mean([r['cosine_similarity'] for r in results]),
'title_similarity': np.mean([r['structural_similarity']['title_similarity'] for r in results]),
'information_retrieval': np.mean([r['information_retrieval'] for r in results]),
'code_consistency': np.mean([r['code_consistency'] for r in results]),
'readability': np.mean([r['readability'] for r in results]),
'weighted_score': np.mean([r['weighted_score'] for r in results])
}
# Print results to console
print("\nEvaluation Results:")
for metric, score in average_scores.items():
print(f"{metric}: {score:.4f}")
# Save results to log file
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
log_filename = f"{args.model}_results_{timestamp}.log"
with open(log_filename, 'w') as log_file:
log_file.write(f"Evaluation Results for model: {args.model}\n")
log_file.write(f"Timestamp: {timestamp}\n\n")
log_file.write("Average Scores:\n")
for metric, score in average_scores.items():
log_file.write(f"{metric}: {score:.4f}\n")
log_file.write(f"\nDetailed Results:\n")
for result in results:
log_file.write(f"\nRepository: {result['repo_name']}\n")
log_file.write("Scores:\n")
log_file.write(f" BLEU: {result['bleu']:.4f}\n")
log_file.write(f" ROUGE-1: {result['rouge']['rouge-1']:.4f}\n")
log_file.write(f" ROUGE-2: {result['rouge']['rouge-2']:.4f}\n")
log_file.write(f" ROUGE-L: {result['rouge']['rouge-l']:.4f}\n")
log_file.write(f" Cosine Similarity: {result['cosine_similarity']:.4f}\n")
log_file.write(f" Title Similarity: {result['structural_similarity']['title_similarity']:.4f}\n")
log_file.write(f" Information Retrieval: {result['information_retrieval']:.4f}\n")
log_file.write(f" Code Consistency: {result['code_consistency']:.4f}\n")
log_file.write(f" Readability: {result['readability']:.4f}\n")
log_file.write(f" Weighted Score: {result['weighted_score']:.4f}\n")
print(f"\nResults saved to {log_filename}")
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Generate and evaluate README files using OpenAI API")
parser.add_argument("model", help="OpenAI model to use")
parser.add_argument("--base_url", help="Optional base URL for OpenAI API", default=None)
args = parser.parse_args()
main(args)