FAKEWHALE STUDIO

about
video
outputs
texts
network
-
contact
Instagram

Installation view: Fakewhale STUDIO: Hide and Seek, ai video, 2025

Fakewhale STUDIO: Don't Blink, 2025 , ai video, 2025
Fakewhale Studio is an experimental research platform exploring the intersections of artificial intelligence, photography, and digital documentation.
By pushing the boundaries of AI-generated imagery, the project examines how machine learning reshapes visual representation, redefines authorship, and expands the possibilities of contemporary image-making.
At its core, Fakewhale Studio investigates the creative potential of AI in photographic and video-based work. Through computational vision and generative models, the project engages with the evolving language of digital imagery, where algorithms reconstruct, reinterpret, and synthesize visual narratives. These technologies do not merely replicate human creativity but introduce new modes of composition, challenging conventional understandings of authenticity and artistic intent.
AI-generated photography and video become a field of inquiry, where documentation is no longer a passive recording of reality but an active transformation of it.
Unlike traditional photography, where light and optics define the image, AI-driven visuals emerge through data-driven synthesis, shaping perspectives that blend realism with computational abstraction.
This shift marks a turning point in the history of visual media, mirroring past technological revolutions that expanded artistic expression. As generative AI integrates into creative workflows, it raises fundamental questions about the nature of imagery:
What does it mean to document a moment when the image itself is generated rather than captured? How does AI influence our perception of authenticity in photography and video?
From industrial design to contemporary art, these technologies are already redefining creative production, offering unprecedented control over image generation and customization.
As platforms and tools evolve, the boundaries between recorded reality and AI-constructed visuals continue to blur, transforming the way we document, interpret, and experience images in the digital age.

Installation view: Fakewhale STUDIO: ac2, ac17, 2025
A - Inside the Generative Productions

In his seminal essay “The Work of Art in the Age of Mechanical Reproduction,” Walter Benjamin discusses how technological advancements, such as photography and cinema, have transformed the aura and authenticity of artworks. His insights are incredibly relevant today, where the concept of originality in producing a visual image related to a given reality is once again challenged by generative technologies.
Benjamin observes that “what withers in the age of mechanical reproduction is the aura of the work of art” (Benjamin, 1936). With the advent of mechanical reproduction, the authenticity of the artwork is lost as it is separated from its original historical and cultural context, yet it assumes a new kind of originality inherent in the derived multiple. This phenomenon is similarly observable in generative images created by artificial intelligence, where reproduction not only copies but also transforms and reinterprets reality.
Similarly, another philosopher, Gilles Deleuze, with his work on simulacra and simulation, offers a complex perspective on the nature of reality and representation in the digital media age. Deleuze helps us understand how AI-generated images not only reproduce but also transfigure reality based on extensive databases, creating new layers of meaning and reinterpretation. His idea of “folds” and “flows” of information applies perfectly to the dynamic and fluid nature of AI-generated images, which are not fixed but resemble a flexible material, constantly changing and being reinterpreted.
Some programmers and prominent figures in Silicon Valley, such as Ian Goodfellow, the creator of GANs, and Fei-Fei Li, a pioneer in computer vision, have indirectly made significant conceptual contributions to the production of generative images through their work. In particular, they utilize deep neural networks to process large amounts of visual data. Machine learning algorithms, such as generative adversarial networks (GANs), create images that another network attempts to distinguish from real ones. This process leads to the generation of increasingly realistic and detailed images.
Large datasets, such as ImageNet, offer a vast array of labeled images covering countless categories. These datasets serve as the foundation for training deep neural networks, allowing models to learn from the visual variables present in the images. In a sense, these databases act as a giant “cauldron” where the different characteristics of images are mixed and combined according to a specific logic determined by machine learning algorithms.
As we move forward, our focus remains on the intellectual and aesthetic implications of AI in art, examining how these technologies are redefining creativity and challenging traditional notions of authorship and originality.

Installation view: Fakewhale STUDIO: y45, oq2, y44, 2025

Fakewhale STUDIO: selected outputs, 2025 NLP analysis./ logging.info("Step 1: Generating Text Embeddings and performing NLP Analysis...") time.sleep(1) # Simulate embeddings as a 512-dimensional vector self.embeddings = np.random.rand(512) # Simulated NLP analysis: extract unique keywords keywords = list(set(re.findall(r'\w+', self.prompt.lower()))) self.context = f"Extracted keywords: {', '.join(keywords)}" logging.info("→ Text Embeddings Created.") logging.info("→ NLP Context: %s", self.context).

B - A New Imaginary

Every work, every action, and every word we express are the products of accumulated knowledge and past experiences. This seemingly simple principle reveals a fundamental truth: nothing we consider new is truly devoid of roots in the past.
Every idea, every concept, every creative form that emerges is the result of a complex interaction between what we already know and what we are able to synthesize from this knowledge.
Analyzing this phenomenon in more rational terms, we can observe that innovation is not an isolated act but rather a process of evolution. Every new creation is intrinsically linked to existing patterns, models, and structures.
These preexisting elements form a sort of matrix that conditions and guides our ability to create something new. Therefore, there is no real discontinuity between the past and the present; instead, there is a continuity that manifests through the transformation and adaptation of existing knowledge.
In this context, art, writing, and every other human practice can be understood as expressions of a progressive synthesis. Every creative act is, in effect, a process of reworking, where known elements are combined in new ways to generate seemingly original results.
This process is driven by a constant interaction between past experience and the human ability to imagine new possibilities.
From a theoretical standpoint, one might argue that the idea of a completely original creation is, in a sense, an illusion. What we perceive as new is actually a new configuration of preexisting elements. Thus, every innovation is the result of a complex network of influences, knowledge, and patterns that intersect, creating a continuum between the old and the new.
Generative artificial intelligence, especially in the realm of image creation, represents a technology that replicates, in an essentially technical manner, the human creative process. The algorithms that generate new images operate by processing vast amounts of pre-existing data (images, styles, models), which are used to train the underlying algorithms responsible for creation. This process is not unlike the mechanism described earlier: nothing is created ex nihilo, but rather, it is the result of a synthesis of already existing information and patterns.

Fakewhale STUDIO: av3, ai video, 2025

Fakewhale STUDIO: bh2, ai video, 2025
(User Input: Text Prompt)
→ {Pretrained Language Model → Text Embeddings}
→ {Semantic Understanding → Context Extraction}
→ {Diffusion Model Initialization (Noise) → Iterative Denoising → Classifier-Free Guidance}
→ {Low-Resolution Image (64×64) → Super-Resolution Step 1 (256×256) → Super-Resolution Step 2 (1024×1024)}
→ {Noise Conditioning Augmentation → Artifact Removal}
→ {Efficient U-Net Optimization → Memory & Speed Optimization}
→ {Visual & Semantic Coherence Check → Final Render & Output}
→ {Benchmarking (FID, CLIP) → Human Evaluation}
→ {Bias & Fairness Analysis → Model Fine-Tuning → Improved Generation}

(...)The process starts with a random noise image that is iteratively refined to match the textual description, leveraging classifier-free guidance to enhance semantic accuracy.
Once a low-resolution image is generated, it undergoes a multi-step super-resolution process, progressively improving detail and clarity.
Noise conditioning augmentation ensures robustness by removing artifacts, while Efficient U-Net architectures optimize memory usage and speed.
The final output is evaluated using benchmarking metrics (FID, CLIP score) and human validation, identifying areas for bias correction and fine-tuning.
This approach enables the generation of high-fidelity, text-aligned images, but also introduces challenges related to representation fairness, ethical concerns, and computational efficiency,
requiring continuous refinement for responsible deployment.

Installation view: Fakewhale STUDIO: y30,y4, 2025

w Installation view: Fakewhale STUDIO: mz4, 2025

work view: Fakewhale STUDIO: y46, 2025
import time
import numpy as np
import matplotlib.pyplot as plt
import logging
import os
import threading
import json
import re
import argparse

# Configure logging to file and console
LOG_FILE = "simulation.log"
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s',
handlers=[logging.FileHandler(LOG_FILE),
logging.StreamHandler()])

class ImageGenerationSimulator:
"""
This class simulates an advanced and comprehensive pipeline for generating images from a textual prompt.
The pipeline includes:
- Prompt validation and preprocessing
- Text embeddings generation and basic NLP analysis (e.g., keyword extraction)
- Diffusion model initialization with noise generation
- Iterative denoising with multiple iterations and enhanced noise reduction
- Super-resolution using Kronecker product expansion
- Post-processing for artifact removal and image cleanup
- Optimization routines for memory and speed improvements
- Visual and semantic coherence checks
- Benchmarking (e.g., FID, CLIP similarity) and bias analysis for fairness
- Additional image enhancements: contrast adjustment, color correction, detail enhancement, and edge sharpening
- Saving of intermediate images and comprehensive JSON reports
- Asynchronous image saving and simulated GPU memory usage tracking
- Final review and watermarking for image authentication
"""

def __init__(self, prompt: str):
"""
Initializes the simulator state and validates the input prompt.

Args:
prompt (str): A textual description used to generate the image.
"""
self.original_prompt = prompt
self.prompt = self._validate_and_preprocess_prompt(prompt)
self.embeddings = None
self.context = None
self.noise = None
self.low_res_image = None
self.final_image = None
self.intermediate_images = {}

# Additional quality control and optimization flags
self.optimizations_applied = False
self.coherence_verified = False
self.benchmark_scores = {}
self.bias_analysis_report = None
self.contrast_adjusted = False
self.color_corrected = False
self.detail_enhancement_done = False
self.edge_sharpened = False
self.watermark_added = False
self.gpu_memory_usage = 0

# Report dictionary to store simulation data
self.report = {}

# Directory for saving results and reports
self.output_dir = "output_images"
self.report_file = os.path.join(self.output_dir, "simulation_report.json")
if not os.path.exists(self.output_dir):
os.makedirs(self.output_dir)
logging.info("Simulator initialized with prompt: '%s'", self.prompt)

def _validate_and_preprocess_prompt(self, prompt: str) -> str:
"""
Validates the prompt and cleans unwanted characters.

Args:
prompt (str): The original prompt.

Returns:
str: The processed and validated prompt.
"""
if not prompt or not isinstance(prompt, str):
raise ValueError("The prompt must be a non-empty string.")
# Remove any characters not alphanumeric or basic punctuation
processed = re.sub(r"[^a-zA-Z0-9\s,.;:!?'-]", "", prompt)
logging.info("Preprocessed prompt: '%s'", processed)
return processed

def text_embedding(self):
"""
Step 1: Generate text embeddings from the prompt and perform basic NLP analysis.
"""
logging.info("Step 1: Generating Text Embeddings and performing NLP Analysis...")
time.sleep(1)
# Simulate embeddings as a 512-dimensional vector
self.embeddings = np.random.rand(512)
# Simulated NLP analysis: extract unique keywords
keywords = list(set(re.findall(r'\w+', self.prompt.lower())))
self.context = f"Extracted keywords: {', '.join(keywords)}"
logging.info("→ Text Embeddings Created.")
logging.info("→ NLP Context: %s", self.context)
self.report['text_embedding'] = {
'embedding_sample': self.embeddings[:5].tolist(),
'context': self.context
}

def diffusion_initialization(self):
"""
Step 2: Initialize the diffusion model by generating a noise matrix.
A fixed random seed is used for reproducibility.
"""
logging.info("Step 2: Initializing Diffusion Model with Noise Generation...")
time.sleep(1)
np.random.seed(42) # Fixed seed for reproducible simulation
self.noise = np.random.randn(64, 64)
logging.info("→ Diffusion Noise Initialized.")
self.intermediate_images['noise'] = self.noise.copy()

def iterative_denoising(self, iterations: int = 8):
"""
Step 3: Run an iterative denoising process on the generated noise.
Each iteration simulates a progressive reduction of noise artifacts.

Args:
iterations (int): Number of denoising iterations.
"""
logging.info("Step 3: Running Iterative Denoising for %d iterations...", iterations)
denoised = self.noise.copy()
for i in range(iterations):
time.sleep(0.5)
denoised = np.clip(denoised + 0.1 * np.random.randn(64, 64), -1, 1)
logging.info(" Iteration %d: Noise reduction step completed.", i + 1)
self.low_res_image = np.clip(denoised + 0.5, 0, 1)
logging.info("→ Iterative Denoising Completed.")
self.intermediate_images['low_res'] = self.low_res_image.copy()

def super_resolution(self):
"""
Step 4: Apply a super-resolution technique to upscale the low resolution image.
The transformation scales the image from 64x64 to 1024x1024 using a Kronecker product.
"""
logging.info("Step 4: Applying Super-Resolution (64x64 → 1024x1024)...")
time.sleep(2)
self.final_image = np.kron(self.low_res_image, np.ones((16, 16)))
logging.info("→ Super-Resolution Completed.")
self.intermediate_images['super_res'] = self.final_image.copy()

def post_processing(self):
"""
Step 5: Post-process the image to remove artifacts and clean up visual quality.
"""
logging.info("Step 5: Performing Post-Processing...")
time.sleep(1)
self.final_image = np.clip(self.final_image, 0, 1)
logging.info("→ Post-Processing Completed. Image cleaned.")

def optimization(self):
"""
Step 6: Apply memory and speed optimizations.
Also simulates GPU memory usage tracking.
"""
logging.info("Step 6: Applying Memory & Speed Optimization...")
time.sleep(1)
self.optimizations_applied = True
# Simulate GPU memory usage (in MB)
self.gpu_memory_usage = np.random.randint(1000, 2000)
logging.info("→ Optimizations Applied. Simulated GPU memory usage: %d MB", self.gpu_memory_usage)

def coherence_check(self):
"""
Step 7: Check the visual and semantic coherence of the generated image.
"""
logging.info("Step 7: Performing Visual & Semantic Coherence Check...")
time.sleep(1)
self.coherence_verified = True
logging.info("→ Coherence Verified.")

def benchmarking(self):
"""
Step 8: Run benchmarking to evaluate image quality (e.g., FID, CLIP similarity).
"""
logging.info("Step 8: Running Benchmarking (FID, CLIP)...")
time.sleep(1)
self.benchmark_scores = {"FID": 15.4, "CLIP": 0.78}
logging.info("→ Benchmark Score: FID ~%s, CLIP Similarity ~%s",
self.benchmark_scores["FID"], self.benchmark_scores["CLIP"])
self.report['benchmark'] = self.benchmark_scores

def bias_analysis(self):
"""
Step 9: Conduct bias and fairness analysis to ensure no significant biases are present.
"""
logging.info("Step 9: Conducting Bias & Fairness Analysis...")
time.sleep(1)
self.bias_analysis_report = "Bias Analysis Completed. No significant biases detected."
logging.info("→ %s", self.bias_analysis_report)
self.report['bias_analysis'] = self.bias_analysis_report

def contrast_adjustment(self):
"""
Step 10: Adjust the image contrast to enhance definition.
"""
logging.info("Step 10: Adjusting Contrast...")
time.sleep(1)
self.final_image = np.clip(self.final_image * 1.2, 0, 1)
self.contrast_adjusted = True
logging.info("→ Contrast Adjustment Completed.")

def color_correction(self):
"""
Step 11: Correct image colors to balance tone and saturation.
"""
logging.info("Step 11: Performing Color Correction...")
time.sleep(1)
self.final_image = (self.final_image - np.min(self.final_image)) / (np.max(self.final_image) - np.min(self.final_image) + 1e-5)
self.color_corrected = True
logging.info("→ Color Correction Completed.")

def detail_enhancement(self):
"""
Step 12: Enhance image details to improve overall sharpness.
"""
logging.info("Step 12: Enhancing Details...")
time.sleep(1)
# Simulate detail enhancement by a slight increase in pixel intensity
self.final_image = np.clip(self.final_image + 0.05, 0, 1)
self.detail_enhancement_done = True
logging.info("→ Detail Enhancement Completed.")

def edge_sharpening(self):
"""
Step 13: Apply an edge sharpening filter to enhance image outlines.
"""
logging.info("Step 13: Sharpening Edges...")
time.sleep(1)
# Simulated edge sharpening (in a real scenario, a convolution filter might be applied)
self.final_image = np.clip(self.final_image + 0.03, 0, 1)
self.edge_sharpened = True
logging.info("→ Edge Sharpening Completed.")

def add_watermark(self):
"""
Step 14: Add a watermark to the final image for authentication.
"""
logging.info("Step 14: Adding Watermark to the Image...")
time.sleep(1)
# Simulated watermark: overlay a faint text pattern by modifying pixel values slightly
watermark_pattern = np.linspace(0, 0.05, self.final_image.shape[0]).reshape(-1, 1)
self.final_image = np.clip(self.final_image + watermark_pattern, 0, 1)
self.watermark_added = True
logging.info("→ Watermark Added.")

def save_intermediate_images(self):
"""
Save all intermediate images generated during the pipeline for debugging and documentation.
"""
logging.info("Saving intermediate images...")
for key, image in self.intermediate_images.items():
path = os.path.join(self.output_dir, f"{key}.png")
plt.imsave(path, image, cmap='gray')
logging.info("→ Saved '%s' image at %s", key, path)

def generate_report(self):
"""
Generate and save a comprehensive simulation report in JSON format.
"""
logging.info("Generating simulation report...")
self.report['prompt'] = self.prompt
self.report['optimizations_applied'] = self.optimizations_applied
self.report['coherence_verified'] = self.coherence_verified
self.report['contrast_adjusted'] = self.contrast_adjusted
self.report['color_corrected'] = self.color_corrected
self.report['detail_enhancement_done'] = self.detail_enhancement_done
self.report['edge_sharpened'] = self.edge_sharpened
self.report['watermark_added'] = self.watermark_added
self.report['gpu_memory_usage_MB'] = self.gpu_memory_usage
self.report['final_image_shape'] = self.final_image.shape if self.final_image is not None else None
with open(self.report_file, "w") as f:
json.dump(self.report, f, indent=4)
logging.info("→ Report saved to %s", self.report_file)

def async_save_image(self, image, filename):
"""
Save the image asynchronously in a separate thread.

Args:
image (numpy.ndarray): The image to save.
filename (str): Output file name.
"""
def save():
path = os.path.join(self.output_dir, filename)
plt.imsave(path, image, cmap='gray')
logging.info("Asynchronously saved image: %s", path)
thread = threading.Thread(target=save)
thread.start()

def render_image(self):
"""
Display the final image using matplotlib and save it to disk.
"""
logging.info("Final Step: Rendering Image...")
if self.final_image is not None:
plt.figure(figsize=(8, 8))
plt.imshow(self.final_image, cmap='gray')
plt.title("Simulated Generated Image")
plt.axis('off')
plt.show()
# Synchronous save of the final image
final_path = os.path.join(self.output_dir, "final_image.png")
plt.imsave(final_path, self.final_image, cmap='gray')
logging.info("→ Final image saved to %s", final_path)
# Asynchronous save for demonstration purposes
self.async_save_image(self.final_image, "final_image_async.png")
else:
logging.error("Error: Final image not available.")

def simulate_gpu_usage(self):
"""
Simulate monitoring of GPU memory usage during processing.
"""
logging.info("Simulating GPU usage monitoring...")
time.sleep(0.5)
# Increment the simulated GPU memory usage by a random amount
self.gpu_memory_usage += np.random.randint(50, 100)
logging.info("→ Updated GPU memory usage: %d MB", self.gpu_memory_usage)

def final_review(self):
"""
Final review step: perform a final check and annotate the image if all processing is complete.
"""
logging.info("Final Step: Performing Final Review and Annotation...")
time.sleep(1)
if all([self.optimizations_applied, self.coherence_verified, self.contrast_adjusted,
self.color_corrected, self.detail_enhancement_done, self.edge_sharpened, self.watermark_added]):
logging.info("→ All processing steps confirmed. Image passes final review.")
else:
logging.warning("→ Final review warning: Some processing steps were not fully completed.")

def generate(self):
"""
Execute the entire image generation pipeline, sequencing each step and recording outputs.
"""
logging.info("\nStarting Advanced Image Generation Pipeline")
logging.info("-" * 70)
try:
self.text_embedding()
self.diffusion_initialization()
self.iterative_denoising(iterations=8)
self.simulate_gpu_usage()
self.super_resolution()
self.post_processing()
self.optimization()
self.simulate_gpu_usage()
self.coherence_check()
self.benchmarking()
self.bias_analysis()
self.contrast_adjustment()
self.color_correction()
self.detail_enhancement()
self.edge_sharpening()
self.add_watermark()
self.save_intermediate_images()
self.generate_report()
self.final_review()
logging.info("Final Step: Rendering Image...")
self.render_image()
except Exception as e:
logging.error("An error occurred during image generation: %s", e)
self.report['error'] = str(e)
with open(self.report_file, "w") as f:
json.dump(self.report, f, indent=4)

def main():
"""
Main function to run the simulation. Supports command-line arguments for custom prompts
and batch processing multiple simulations.
"""
parser = argparse.ArgumentParser(description="Advanced Simulation of Image Generation from a Text Prompt")
parser.add_argument("--prompt", type=str,
default="A futuristic city at sunset with flying cars, neon lights, reflective skyscrapers, and digital billboards.",
help="Text description to generate the image.")
parser.add_argument("--batch", type=int, default=1,
help="Number of simulations to run in batch mode.")
args = parser.parse_args()

simulations = []
for i in range(args.batch):
logging.info("Initializing simulation %d", i + 1)
sim = ImageGenerationSimulator(args.prompt)
sim.generate()
simulations.append(sim)
logging.info("Simulation %d completed.\n%s", i + 1, "-" * 70)
time.sleep(2)

logging.info("All simulations completed. Generating aggregated batch report...")
final_report = {
"total_simulations": args.batch,
"simulations": [sim.report for sim in simulations]
}
final_report_file = os.path.join("output_images", "batch_report.json")
with open(final_report_file, "w") as f:
json.dump(final_report, f, indent=4)
logging.info("Batch report saved to %s", final_report_file)

if __name__ == "__main__":
main()

Fakewhale STUDIO © 2025