【Python 代码】筛选出评分最高或符合特定美学标准的图像数据

Thinking Process: 1. **Analyze the Request:** * Role: Professional Programming Assistant. * Task: Judge and answer based on strict requirements. * Goal: Filter out image data with the highest rating or meeting specific aesthetic standards. * Rules: 1. If the goal can be directly achieved by running Python code, return the complete Python code with no explanation. 2. If it cannot be directly achieved, split the goal into 2-5 independent sub-goals. Each sub-goal must be complete and independent (no context dependency). Format: "子目标：XXXXXX" on each line. 3. No extra text, strict output format. 2. **Evaluate the Goal:** * Goal: "筛选出评分最高或符合特定美学标准的图像数据" (Filter out image data with the highest rating or meeting specific aesthetic standards). * Can this be directly achieved by running Python code? * *Scenario A:* We have a specific dataset, a specific rating column, and a specific aesthetic metric (e.g., CLIP score, FID, or a simple file naming convention). If we assume the data exists and we know the criteria, a script can load, filter, and save. * *Scenario B:* "Specific aesthetic standards" is vague. Does it mean "highest aesthetic score from a model"? "Manual rating"? "Metadata"? * *Scenario C:* To "run code and achieve the goal", the code needs to know *where* the images are, *how* to calculate the aesthetic score, and *what* the threshold is. Without external context (like a database connection, API key for an AI model, or file paths), a standalone Python script might not be *fully* executable to achieve the result without prior setup. * *However*, usually, when asked to "write code to achieve X", we assume the environment is set up or we write a script that *would* do it given the data. * *Strict Interpretation:* Can a single Python script *run* and produce the filtered result? Yes, if we assume the data source (e.g., a folder or CSV) and the evaluation method (e.g., a function `get_aesthetic_score`) are defined within or accessible. * *Alternative Interpretation:* Is it complex enough to require steps? Loading images, calculating scores, sorting, filtering. This is often encapsulated in one script. * *Decision:* Most programming tasks like "filter data" are considered "directly achievable by Python code" if we write a script that performs the logic. The prompt asks "If this goal can be directly achieved by Python code, i.e., after running the code the goal is achieved". * Let's consider if it needs pre-processing. To calculate "aesthetic standards", we often need a pre-trained model (like Aesthetic Predictor). A script can import this model, iterate files, compute, and filter. So, a single script *can* do it. * However, sometimes "Goal" implies a workflow. But Rule 1 says "If this goal can be directly achieved by Python code... return complete Python code". * Let's lean towards Rule 1 because filtering logic is inherently computational. Even if it requires installing packages, the *execution* of the code achieves the goal (filtering). * Wait, let's look at Rule 2: "If not directly achievable... split into 2-5 sub-goals". * What makes it *not* directly achievable? Maybe the need for human annotation or an external API that requires interaction? But "filtering" is a batch process. * Let's assume the standard case: Given a directory or list of images, write a script to filter them based on a score. This is a direct code task. * *Counter-argument:* The prompt says "filter out... image data". If the data isn't defined, the code runs but might do nothing or error. But generally, code *is* the means to achieve the goal. * Let's look at the phrasing: "If this goal can be directly achieved by Python code, i.e., after running the code the goal is achieved". * If I write a script `filter_images.py`, and I run it, does it filter the images? Yes, assuming inputs are provided. * So Rule 1 seems appropriate. I will write a complete Python script that demonstrates how to load images, calculate a generic aesthetic score (e.g., using a library like `torch-aesthetic` or a placeholder), and save the filtered ones. * *Refinement:* To be safe and robust, since "specific aesthetic standards" is vague, I should write a script that implements the logic. * *Wait, one more check:* Is there a case where Rule 2 is better? If the task requires "identifying" the data first, then "calculating", then "sorting". But Rule 1 says "directly achieved". Usually, a script encapsulates all steps. * Let's check the constraint: "If the goal can be directly achieved... return complete Python code... no explanation". * Let's check the constraint: "If not... split into 2-5 sub-goals... format 子目标：XXXXXX". * Decision: Since "filtering based on rating/aesthetics" is a classic data processing pipeline that fits into one script (load, evaluate, filter, save), Rule 1 is the stronger fit. It's a "programmatic task". * *Wait, reconsideration:* The prompt asks me to judge. Is it *directly* achievable? * To achieve "Filter out... image data", do I need to know *which* images? Do I need to install dependencies? * If I provide code that *would* do it, does running it achieve it? Yes, if the data is there. * However, often "Aesthetic Standards" implies an AI model inference. * Let's write a comprehensive script that handles loading, scoring (mock or using a library), and saving. * Actually, looking at similar tasks, often if it requires multiple stages (e.g., download -> preprocess -> score -> filter), it might be split. But here the goal is "Filter", not "Build a pipeline from scratch". * Let's try to make it a single script. * *Wait, looking at Rule 2:* "If not directly achievable". What if the code depends on external state not defined in the script? * Let's assume the "Goal" is the logical task. A script *is* the implementation of the task. * Okay, I will choose Rule 1 (Code) because it's a standard data filtering task. * *Wait, let's look closer at the "Goal":* "筛选出评分最高或符合特定美学标准的图像数据". * Does this require a database? A GUI? An API? * If I write code: `filter_images(images_path, threshold)`, it runs and filters. * So, Code it is. * *Wait, one nuance:* If the user expects a *specific* aesthetic metric that requires a specific model (like `LAION-Aesthetic`), just writing `import torch` might not be enough without weights. * But as a "Programming Assistant", providing the code structure that *would* achieve it is the standard response for Rule 1. * Let's draft the code. * It needs to handle: Loading images, Calculating score, Filtering, Saving. * To be generic, I'll use a hypothetical function `calculate_aesthetic_score`. * *Wait, let's reconsider Rule 2.* Is there a reason to split? * Sub-goal 1: Load image data. * Sub-goal 2: Calculate aesthetic scores. * Sub-goal 3: Filter based on threshold. * If these are separate scripts, it's Rule 2. If one script does all, it's Rule 1. * Rule 1 says "run the code... goal is achieved". One script does this. * Okay, I'll go with Rule 1. * *Wait, checking the "No explanation" rule:* "不要任何解释". * So just the code block? Or just the text? "直接返回完整Python代码". Usually means the code block. * Wait, if I return a code block with markdown, is that "extra text"? Usually acceptable. * Strictly: "直接返回完整Python代码". I will output the code inside markdown ticks. * *Wait, let's look at the "Sub-goal" format if Rule 2:* "子目标：XXXXXX". * If Rule 1: Just code. * *Wait, let's think if it's "Not Directly Achievable".* * Why? Because "Aesthetic Standard" is subjective unless defined by a model. * If I write code, I need to import a specific library (e.g., `aesthetic-predictor`). * If the environment doesn't have it, it fails. * But "running the code" implies the environment is ready or the code handles setup. * Let's assume the environment has the necessary dependencies. * Okay, I'll write the code. * *Wait, is there a catch?* "筛选出...图像数据". * Maybe the "data" needs to be retrieved first? * Let's write a script that assumes a folder of images and filters them. * *Wait, let's reconsider Rule 2.* * Is it better to split because "Highest rating" AND "Specific aesthetic standard" are two conditions? * Or because "Load" and "Filter" are distinct phases? * If I put everything in one script, it's Rule 1. * Let's stick with Rule 1 as it's more efficient for a "Programming Assistant" to provide a solution script. * *Wait, wait.* Re-reading Rule 1: "If this goal can be directly achieved by Python code, i.e., after running the code the goal is achieved". * If I run the code, do I get the filtered images? Yes. * Okay, Code it is. * *Drafting the code:* * Import os, glob, PIL, torch (for aesthetic model). * Define function to get score. * Loop files. * Filter. * Save/Move. * Add comments? Rule 1 says "no explanation", but code comments are part of code. I should minimize non-code text. * Actually, "no explanation" usually means outside the code block. * Let's make it clean. * *Wait, let's look at the instruction again:* "直接返回完整Python代码，不要任何解释". * Does this mean no markdown ticks? Or just no prose? Usually means just the code. But to distinguish from text, markdown ticks are safer. I will use markdown ticks for the code block. * *Wait, one more check on Rule 2:* "If not directly achievable". * Is it possible that "Aesthetic Standard" requires an external service? * If the code relies on an API key that isn't provided, is it "directly achievable"? * To be safe, maybe Rule 2 is better because "Aesthetic" is vague. * But usually, in coding tasks, we assume the implementation details are part of the code. * Let's try to make the code self-contained enough. * I'll go with Rule 1 because it's a "Filtering" task, which is inherently code-driven. * *Wait, let's look at the output format:* "严格按要求输出". * If Rule 1: "直接返回完整Python代码". * If Rule 2: "每行一个子目标... 子目标：XXXXXX". * So I need to decide which one. * Decision: I will choose Rule 1 (Code) because filtering data is a primary capability of Python scripts. * *Wait, is there a nuance about "Highest OR Specific"?* * Code can handle `if score > threshold or score == max_score`. * So one script covers both. * *Final Decision:* Rule 1. Write the code. * *Wait, checking the "No extra text" rule.* * Does the markdown code block count as extra text? * "直接返回完整Python代码" usually implies the content. * I will output the code block. * *Wait, let's refine the code.* * Needs to be runnable. * Needs to handle image loading. * Needs to handle filtering. * Let's use a mock score function or a standard library to ensure it runs without heavy dependencies (like torch) if possible, or assume they exist. * To be "directly achieved", it shouldn't fail due to missing complex models if possible. * Let's use `PIL` and a simple heuristic (e.g., brightness/contrast) OR assume a function exists. * Better to use a standard library `PIL` + simple logic to ensure "running the code" works without `pip install torch`. * Goal: "Aesthetic standards". Let's use a simple metric (e.g., color variance or just placeholder) to simulate. * Actually, to be professional, I should use a standard approach. Let's use `Pillow` to calculate a simple complexity metric. * *Wait, one catch:* "如果这个目标可以直接用Python代码实现". * Does "Aesthetic Standard" imply AI? Usually yes. * If the code needs `torch-aesthetic-predictor`, it needs to be installed. * If I write the code, does "running the code" include installing dependencies? * Usually yes. * Okay, I will write a script that uses `PIL` for simplicity to ensure it's "directly" runnable with minimal setup, or comment that a model is needed. * To be safe, I'll write a generic filter script that *can* be plugged with any scoring function. * *Wait, looking at the instruction again:* "不要任何解释". * So no `print` statements explaining steps? Just the logic? * Or is `print` part of the code? `print` is code. * Okay. * *Wait, let's reconsider Rule 2.* * Maybe the "Goal" is too high level? "Filter out... data". * If the data source isn't specified, the code is generic. * If the "Aesthetic Standard" isn't defined, the code is generic. * Is a generic script "achieving the goal"? * Yes, it achieves the *process* of filtering. * Okay, sticking with Rule 1. * *Wait, let's check the constraints again.* * "子目标需要是独立完整的目标，表述中不依赖任何上下文。" (Sub-goals need to be independent complete goals, no context dependency). * This applies to Rule 2. * Rule 1: "直接返回完整Python代码". * *Wait, let's compare:* * If I write code, it's concise. * If I split, it's verbose. * Given "Professional Programming Assistant", code is usually preferred if feasible. * Is it feasible? Yes. * Okay. * *Final Check:* * Output: Code block. * No text before/after. * Language: Chinese (for the code comments or just English variable names? "Professional" usually English variables, but context is Chinese. I'll use English variables for professionalism but maybe comments in Chinese/English mix). * Wait, "不要任何解释" implies no prose outside the code. * Okay. * *Wait, one detail:* "筛选出评分最高或符合特定美学标准的图像数据". * "Highest rating" (评分最高) -> Find max rating, take all with max rating. * "Specific aesthetic standard" (符合特定美学标准) -> Filter by threshold. * Logic: `if score >= threshold or score == max_score`. * *Wait, I need to make sure the code is "complete".* * It should import, define paths, define logic, execute. * I will use a sample directory path. * *Wait, is there any reason to pick Rule 2?* * If the "Aesthetic Standard" is external (e.g., a human judge). * But "Python code" implies automation. * Okay, Rule 1. * *Wait, final check on "No explanation".* * Does the markdown ```python ... ``` count as explanation? * Usually, it's the container. The content is the code. * I will include the markdown block. * *Wait, one more thing:* "子目标：XXXXXX" format for Rule 2. * If Rule 1, just code. * Okay. * *Wait, let's think if the "Goal" is abstract.* * "Filter out image data". * Code: `filter(images, criteria)`. * Yes. * *Wait, I'll add a check for dependencies in the code to make it robust.* * Actually, `PIL` is standard. * Okay, writing the code. * *Wait, hold on.* * "如果这个目标可以直接用Python代码实现，即运行完代码就能达成目标". * "Running the code" -> "Goal achieved". * If the code needs user input (like "Enter image path"), is it direct? * I'll hardcode a path or use `.`. * Okay. * *Wait, let's look at the "Sub-goals" rule again.* * "If *not* directly achievable". * Is it possible that "Aesthetic Standard" requires a specific AI model inference that is too heavy for a simple script? * Maybe. * But the *task* is filtering. The *method* is code. * I'll stick with Code. * *Wait, let's consider the "Strictly" requirement.* * If I write comments, is it "explanation"? * Comments inside code are part of code. * Okay. * *Wait, let's finalize the code structure.* * Imports. * Function `get_aesthetic_score`. * Main loop. * Save filtered images. * *Wait, one nuance:* "Highest rating OR Specific standard". * Logic: `if score >= threshold OR score == max_score`. * *Okay, ready to generate.* ```python import os import glob from PIL import Image import numpy as np def calculate_aesthetic_score(image_path): """ 计算图像的美学评分（模拟基于像素复杂度的简单标准） 实际应用中可替换为预训练模型如 LAION-Aesthetic Predictor """ try: img = Image.open(image_path) img_array = np.array(img.convert('RGB')) # 示例逻辑：基于颜色多样性和亮度计算简单分数 color_std = np.std(img_array) brightness = np.mean(img_array) # 归一化模拟分数 (0-10) score = (color_std / 255.0) * 5 + (brightness / 255.0) * 5 return min(10.0, max(0.0, score)) except Exception: return 0.0 def filter_images(source_dir, output_dir, threshold=7.0, keep_highest=True): """ 筛选符合美学标准或评分最高的图像数据 """ os.makedirs(output_dir, exist_ok=True) image_extensions = ['*.jpg', '*.jpeg', '*.png', '*.bmp', '*.webp'] all_images = [] # 1. 收集所有候选图像 for ext in image_extensions: all_images.extend(glob.glob(os.path.join(source_dir, ext))) all_images.extend(glob.glob(os.path.join(source_dir, '**', ext), recursive=True)) if not all_images: print("未找到图像文件") return # 2. 计算所有图像的评分 scores = [] for path in all_images: score = calculate_aesthetic_score(path) scores.append({'path': path, 'score': score}) if keep_highest and scores: max_score = max(s['score'] for s in scores) target_scores = [s['score'] >= threshold or s['score'] == max_score for s in scores] else: target_scores = [s['score'] >= threshold for s in scores] # 3. 筛选并保存 for i, item in enumerate(scores): if target_scores[i]: dst_path = os.path.join(output_dir, os.path.basename(item['path'])) try: src = Image.open(item['path']) src.save(dst_path) print(f"已筛选：{item['path']} (评分：{item['score']:.2f})") except Exception as e: print(f"保存失败：{item['path']} - {e}") if __name__ == "__main__": # 配置参数 SOURCE_DIR = "./input_images" OUTPUT_DIR = "./filtered_images" AESTHETIC_THRESHOLD = 6.5 # 符合特定美学标准的阈值 KEEP_HIGHEST = True # 是否保留评分最高的图像 filter_images(SOURCE_DIR, OUTPUT_DIR, threshold=AESTHETIC_THRESHOLD, keep_highest=KEEP_HIGHEST) ```