notebooks

ganspace_unsupervised_disentanglement.ipynb

@@ -0,0 +1,174 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3722712c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline  \n",
+    "\n",
+    "import pandas as pd\n",
+    "import pickle\n",
+    "import random\n",
+    "\n",
+    "from PIL import Image, ImageColor\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "\n",
+    "from backend.disentangle_concepts import *\n",
+    "import dnnlib \n",
+    "import legacy\n",
+    "from backend.color_annotations import *\n",
+    "\n",
+    "import random\n",
+    "\n",
+    "from sklearn.linear_model import LinearRegression, LogisticRegression\n",
+    "\n",
+    "\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fe7acfaf-dc61-4211-9c78-8e4433bc9deb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "annotations_file = './data/textile_annotated_files/seeds0000-100000.pkl'\n",
+    "with open(annotations_file, 'rb') as f:\n",
+    "    annotations = pickle.load(f)\n",
+    "\n",
+    "ann_df = pd.read_csv('./data/textile_annotated_files/top_three_colours.csv').fillna('#000000')\n",
+    "\n",
+    "with dnnlib.util.open_url('./data/textile_model_files/network-snapshot-005000.pkl') as f:\n",
+    "    model = legacy.load_network_pkl(f)['G_ema'].to('cpu') # type: ignore\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cd114cb1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ann_df = tohsv(ann_df)\n",
+    "ann_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "feb64168",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = np.array(annotations['w_vectors']).reshape((len(annotations['w_vectors']), 512))\n",
+    "print(X.shape)\n",
+    "y_h = np.array(ann_df['H1'].values)\n",
+    "y_s = np.array(ann_df['S1'].values)\n",
+    "y_v = np.array(ann_df['S1'].values)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e814959",
+   "metadata": {},
+   "source": [
+    "### Unsupervised approaches"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c9493f54",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.decomposition import PCA"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "93596853",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pca = PCA(n_components=20)\n",
+    "\n",
+    "dims_pca = pca.fit_transform(x_trainhc.T)\n",
+    "dims_pca /= np.linalg.norm(dims_pca, axis=0)\n",
+    "print(dims_pca.shape, np.linalg.norm(dims_pca, axis=0).shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dd0b1501",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "method = 'PCA dimension'\n",
+    "for sep, num in zip(dims_pca.T, range(10)):\n",
+    "    images, lambdas = regenerate_images(model, original_image_vec, sep, min_epsilon=-(int(4)), max_epsilon=int(4), count=5, latent_space='W')\n",
+    "    fig, axs = plt.subplots(1, len(images), figsize=(50,10))\n",
+    "    fig.suptitle(method +': ' + str(num), fontsize=20)\n",
+    "    for i,im in enumerate(images):\n",
+    "        axs[i].imshow(im)\n",
+    "        axs[i].set_title(np.round(lambdas[i], 2))\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e0c7808",
+   "metadata": {},
+   "source": [
+    "## dimensionality reduction e vediamo dove finiscono i vari colori"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "833ed31f",
+   "metadata": {},
+   "source": [
+    "## clustering per vedere quali sono i centroid di questo spazio e se ci sono regioni determinate dai colori"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7c19e820",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

interfacegan_colour_disentanglement.ipynb

@@ -0,0 +1,520 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3722712c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline  \n",
+    "\n",
+    "import pandas as pd\n",
+    "import pickle\n",
+    "import random\n",
+    "\n",
+    "from PIL import Image, ImageColor\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "\n",
+    "from backend.disentangle_concepts import *\n",
+    "import dnnlib \n",
+    "import legacy\n",
+    "from backend.color_annotations import *\n",
+    "\n",
+    "import random\n",
+    "\n",
+    "from sklearn.linear_model import LinearRegression, LogisticRegression\n",
+    "\n",
+    "\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5630402a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "num_colors = 7"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "00e57598",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "values = [x*256/num_colors if x<num_colors else 256 for x in range(num_colors + 1)]\n",
+    "centers = [int((values[i-1]+values[i])/2) for i in range(len(values)) if i > 0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1550ecd7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(values)\n",
+    "print(centers)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ab9be91e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_color_image(hue, saturation, value, size=(20, 10)):\n",
+    "    color_rgb = ImageColor.getrgb(\"hsv({}, {}%, {}%)\".format(hue, int(saturation * 100), int(value * 100)))\n",
+    "    image = Image.new(\"RGB\", size, color_rgb)\n",
+    "    return image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bf1c8ab5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def display_image(image, title=''):\n",
+    "    plt.figure()\n",
+    "    plt.suptitle(title)\n",
+    "    plt.imshow(image)\n",
+    "    plt.axis('off')\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "519b16d4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def to_256(val):\n",
+    "    x = val*360/256\n",
+    "    return x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8f696758",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "names = ['Red', 'Orange', 'Yellow', 'Yellow Green', 'Chartreuse Green',\n",
+    "         'Kelly Green', 'Green Blue Seafoam', 'Cyan Blue',\n",
+    "         'Warm Blue', 'Indigo', 'Purple Magenta', 'Magenta Pink']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "50825823",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "saturation = 1  # Saturation value (0 to 1)\n",
+    "value = 1  # Value (brightness) value (0 to 1)\n",
+    "for hue, name in zip(centers, names[:num_colors]):\n",
+    "    image = create_color_image(to_256(hue), saturation, value)\n",
+    "    display_image(image, name)  # Display the generated color image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fe7acfaf-dc61-4211-9c78-8e4433bc9deb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "annotations_file = './data/textile_annotated_files/seeds0000-100000.pkl'\n",
+    "with open(annotations_file, 'rb') as f:\n",
+    "    annotations = pickle.load(f)\n",
+    "\n",
+    "ann_df = pd.read_csv('./data/textile_annotated_files/top_three_colours.csv').fillna('#000000')\n",
+    "\n",
+    "with dnnlib.util.open_url('./data/textile_model_files/network-snapshot-005000.pkl') as f:\n",
+    "    model = legacy.load_network_pkl(f)['G_ema'].to('cpu') # type: ignore\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cd114cb1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ann_df = tohsv(ann_df)\n",
+    "ann_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "feb64168",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = np.array(annotations['w_vectors']).reshape((len(annotations['w_vectors']), 512))\n",
+    "print(X.shape)\n",
+    "y_h = np.array(ann_df['H1'].values)\n",
+    "y_s = np.array(ann_df['S1'].values)\n",
+    "y_v = np.array(ann_df['S1'].values)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0ca08749",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "np.unique(y_h)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e8f33f14",
+   "metadata": {},
+   "source": [
+    "## Regression model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8da0a43d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_trainh, x_valh, y_trainh, y_valh = train_test_split(X, y_h, test_size=0.2)\n",
+    "x_trains, x_vals, y_trains, y_vals = train_test_split(X, y_s, test_size=0.2)\n",
+    "x_trainv, x_valv, y_trainv, y_valv = train_test_split(X, y_v, test_size=0.2)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8eddba20",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "regh = LinearRegression().fit(x_trainh, y_trainh)\n",
+    "print('Val performance logistic regression', np.round(regh.score(x_valh, y_valh),2))\n",
+    "\n",
+    "separation_vectorh = regh.coef_ / np.linalg.norm(regh.coef_)\n",
+    "print(separation_vectorh.shape)\n",
+    "\n",
+    "regs = LinearRegression().fit(x_trains, y_trains)\n",
+    "print('Val performance logistic regression', np.round(regs.score(x_vals, y_vals),2))\n",
+    "\n",
+    "separation_vectors = regs.coef_ / np.linalg.norm(regs.coef_)\n",
+    "print(separation_vectors.shape)\n",
+    "\n",
+    "regv = LinearRegression().fit(x_trainv, y_trainv)\n",
+    "print('Val performance logistic regression', np.round(reg.score(x_valv, y_valv),2))\n",
+    "\n",
+    "separation_vectorv = regv.coef_ / np.linalg.norm(regv.coef_)\n",
+    "print(separation_vectorv.shape)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c6a63345",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "seed = random.randint(0,100000)\n",
+    "original_image_vec = annotations['w_vectors'][seed]\n",
+    "img = generate_original_image(original_image_vec, model, latent_space='W')\n",
+    "img"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "09f13e6a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "images, lambdas = regenerate_images(model, original_image_vec, separation_vectors, min_epsilon=-(int(5)), max_epsilon=int(5), count=7, latent_space='W')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c66bcdde",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, axs = plt.subplots(1, len(images), figsize=(30,200))\n",
+    "for i,im in enumerate(images):\n",
+    "    axs[i].imshow(im)\n",
+    "    axs[i].set_title(np.round(lambdas[i], 2))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4c44f0dd",
+   "metadata": {},
+   "source": [
+    "fourier per regolarità pattern\n",
+    "linear correlation con il colore\n",
+    "distribution dei colori original e non \n",
+    "neural network per vedere quanto riesce a classificare"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c2790c25",
+   "metadata": {},
+   "source": [
+    "## Multiclass model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "afa0c100",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "colors_list = ['Warm Pink Red', 'Red Orange', 'Orange Yellow', 'Gold Yellow', 'Chartreuse Green',\n",
+    "               'Kelly Green', 'Green Blue Seafoam', 'Blue Green Cyan',\n",
+    "               'Warm Blue', 'Indigo Blue Purple', 'Purple Magenta', 'Magenta Pink']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "39a5668a",
+   "metadata": {},
+   "source": [
+    "double check colori"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5f2b48c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn import svm\n",
+    "\n",
+    "print([int(x*256/12) if x<12 else 255 for x in range(13)])\n",
+    "y_h_cat = pd.cut(y_h,bins=[x*256/12 if x<12 else 256 for x in range(13)],labels=colors_list).fillna('Warm Pink Red')\n",
+    "\n",
+    "print(y_h_cat.value_counts(dropna=False))\n",
+    "x_trainhc, x_valhc, y_trainhc, y_valhc = train_test_split(X, y_h_cat, test_size=0.2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "67651454",
+   "metadata": {},
+   "source": [
+    "### SVR and LR"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7804f593",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "clf = svm.LinearSVC().fit(x_trainhc, y_trainhc)\n",
+    "print('Val performance SVR regression', np.round(clf.score(x_valhc, y_valhc),2))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e6e31b75",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "clf_log = LogisticRegression(multi_class='ovr').fit(x_trainhc, y_trainhc)\n",
+    "print('Val performance logistic regression', np.round(clf_log.score(x_valhc, y_valhc),2))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "82e30f0c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "seed = random.randint(0,100000)\n",
+    "original_image_vec = annotations['w_vectors'][seed]\n",
+    "img = generate_original_image(original_image_vec, model, latent_space='W')\n",
+    "img"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c8ce6086",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.metrics import accuracy_score, confusion_matrix \n",
+    "\n",
+    "y_predhc = clf.predict(x_valhc)\n",
+    "print(y_predhc, y_valhc)\n",
+    "accuracy_score(y_valhc, y_predhc,)\n",
+    "\n",
+    "\n",
+    "#Get the confusion matrix\n",
+    "cm = confusion_matrix(y_valhc, y_predhc)\n",
+    "#array([[1, 0, 0],\n",
+    "#   [1, 0, 0],\n",
+    "#   [0, 1, 2]])\n",
+    "\n",
+    "#Now the normalize the diagonal entries\n",
+    "cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
+    "#array([[1.        , 0.        , 0.        ],\n",
+    "#      [1.        , 0.        , 0.        ],\n",
+    "#      [0.        , 0.33333333, 0.66666667]])\n",
+    "\n",
+    "#The diagonal entries are the accuracies of each class\n",
+    "cm.diagonal()\n",
+    "#array([1.        , 0.        , 0.66666667])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "112f4b87",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(clf.coef_, clf.coef_.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6241bce1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "warm_blue = clf.coef_[-3, :] / np.linalg.norm(clf.coef_[-3, :])\n",
+    "\n",
+    "images, lambdas = regenerate_images(model, original_image_vec, warm_blue, min_epsilon=-(int(5)), max_epsilon=int(5), count=7, latent_space='W')\n",
+    "fig, axs = plt.subplots(1, len(images), figsize=(30,200))\n",
+    "for i,im in enumerate(images):\n",
+    "    axs[i].imshow(im)\n",
+    "    axs[i].set_title(np.round(lambdas[i], 2))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2fefcf0c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "warm_blue = clf.coef_[-4, :] / np.linalg.norm(clf.coef_[-4, :])\n",
+    "\n",
+    "images, lambdas = regenerate_images(model, original_image_vec, warm_blue, min_epsilon=-(int(50)), max_epsilon=int(50), count=2, latent_space='W')\n",
+    "fig, axs = plt.subplots(1, len(images), figsize=(30,200))\n",
+    "for i,im in enumerate(images):\n",
+    "    axs[i].imshow(im)\n",
+    "    axs[i].set_title(np.round(lambdas[i], 2))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e0f31e0b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn import svm\n",
+    "\n",
+    "y_h_cat = pd.cut(y_h,bins=[x*256/6 if x<6 else 256 for x in range(7)],labels=['Red', 'Yellow', 'Green', 'Blue',\n",
+    "                                                                'Purple', 'Pink']).fillna('Red')\n",
+    "\n",
+    "print(y_h_cat.value_counts(dropna=False))\n",
+    "x_trainhc, x_valhc, y_trainhc, y_valhc = train_test_split(X, y_h_cat, test_size=0.2)\n",
+    "\n",
+    "clf6 = svm.LinearSVC().fit(x_trainhc, y_trainhc)\n",
+    "print('Val performance logistic regression', np.round(clf6.score(x_valhc, y_valhc),2))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f5f28b41",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "warm_blue = clf6.coef_[1, :] / np.linalg.norm(clf6.coef_[1, :])\n",
+    "\n",
+    "images, lambdas = regenerate_images(model, original_image_vec, warm_blue, min_epsilon=-(int(10)), max_epsilon=int(10), count=7, latent_space='W')\n",
+    "fig, axs = plt.subplots(1, len(images), figsize=(30,200))\n",
+    "for i,im in enumerate(images):\n",
+    "    axs[i].imshow(im)\n",
+    "    axs[i].set_title(np.round(lambdas[i], 2))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e0c7808",
+   "metadata": {},
+   "source": [
+    "## dimensionality reduction e vediamo dove finiscono i vari colori"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "833ed31f",
+   "metadata": {},
+   "source": [
+    "## clustering per vedere quali sono i centroid di questo spazio e se ci sono regioni determinate dai colori"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7c19e820",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

structure_annotations.ipynb

@@ -0,0 +1,382 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os \n",
+    "from glob import glob \n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "\n",
+    "from PIL import Image, ImageColor\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import torch\n",
+    "\n",
+    "from backend.disentangle_concepts import *\n",
+    "import dnnlib \n",
+    "import legacy\n",
+    "from backend.color_annotations import *\n",
+    "\n",
+    "\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "images_textiles = glob('/Users/ludovicaschaerf/Desktop/TextAIles/TextileGAN/Original Textiles/*')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "images = []\n",
+    "\n",
+    "for step in [10, 20]:\n",
+    "    imh = np.zeros((200, 200))\n",
+    "    imv = np.zeros((200, 200))\n",
+    "    imb = np.ones((200, 200))\n",
+    "    imb2 = np.ones((200, 200))\n",
+    "    \n",
+    "    for x,y in zip(range(0,200, step*2),range(step, 200, step*2)):\n",
+    "        imh[x:y, :] = 255\n",
+    "        imv[:, x:y] = 255\n",
+    "        imb[x:y, :] = 0\n",
+    "        imb[:, x:y] = 0\n",
+    "        imb2[x:y, :] = 0\n",
+    "        imb2[:, x*2:y*2] = 0\n",
+    "    \n",
+    "    images.append(imh)        \n",
+    "    images.append(imb)        \n",
+    "    images.append(imb2)        \n",
+    "    images.append(imv)        \n",
+    "\n",
+    "for im in images:\n",
+    "    plt.imshow(im, cmap='gray')\n",
+    "    plt.title('Original Image')\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_freqs(image):\n",
+    "    \n",
+    "    # Load the image\n",
+    "    # image = cv2.imread(image, cv2.IMREAD_GRAYSCALE)\n",
+    "    # Center crop the image to remove black borders\n",
+    "    height, width = image.shape\n",
+    "    short_side = min(height, width)\n",
+    "    crop_size = min(200, short_side)\n",
+    "    center_x = width // 2\n",
+    "    center_y = height // 2\n",
+    "    crop_half_size = crop_size // 2\n",
+    "    image = image[center_y - crop_half_size:center_y + crop_half_size,\n",
+    "                        center_x - crop_half_size:center_x + crop_half_size]\n",
+    "\n",
+    "    # kernel = np.ones((5,5), np.float32) / 25\n",
+    "    # image = cv2.filter2D( image, -1, kernel)\n",
+    "    # image = cv2.GaussianBlur(image,(5,5),0)\n",
+    "    # image = image - cv2.GaussianBlur(image, (21, 21), 1) + 127\n",
+    "\n",
+    "    # print(np.unique(image))\n",
+    "    # Perform 1D Fourier Transforms\n",
+    "    horizontal_freq = np.fft.fftshift(np.fft.fft(image, axis=1))\n",
+    "    vertical_freq = np.fft.fftshift(np.fft.fft(image, axis=0))\n",
+    "    twod = np.fft.fftshift(np.fft.fft2(image))\n",
+    "    \n",
+    "    # Calculate corresponding frequencies\n",
+    "    num_cols = image.shape[1]\n",
+    "    num_rows = image.shape[0]\n",
+    "    # horizontal_freqs = np.fft.fftshift(np.fft.fftfreq(num_cols))\n",
+    "    # vertical_freqs = np.fft.fftshift(np.fft.fftfreq(num_rows))\n",
+    "    \n",
+    "    horizontal_freqs = np.fft.fftfreq(num_cols)\n",
+    "    vertical_freqs = np.fft.fftfreq(num_rows)\n",
+    "    \n",
+    "    # # Sum power along the second axis\n",
+    "    # twod = twod.real*twod.real + twod.imag*twod.imag\n",
+    "    # twod = twod.sum(axis=1)/twod.shape[1]\n",
+    "\n",
+    "    # # Round up the size along this axis to an even number\n",
+    "    # n = int(math.ceil(image.shape[0] / 2.) * 2 )\n",
+    "\n",
+    "    # # Generate a list of frequencies\n",
+    "    # f = np.fft.fftfreq(n)\n",
+    "\n",
+    "    # # Graph it\n",
+    "    # plt.plot(f[1:],a[1:], label = 'sum of amplitudes over y vs f_x')\n",
+    "\n",
+    "    \n",
+    "\n",
+    "    # Calculate magnitude spectra\n",
+    "    horizontal_magnitudes = np.abs(horizontal_freq)[0]\n",
+    "    vertical_magnitudes = np.abs(vertical_freq)[0]\n",
+    "    \n",
+    "    # # Find peaks in the magnitudes\n",
+    "    # horizontal_peaks, _ = find_peaks(horizontal_magnitudes, height=100)  # Adjust height threshold as needed\n",
+    "    # vertical_peaks, _ = find_peaks(vertical_magnitudes, height=10)      # Adjust height threshold as needed\n",
+    "\n",
+    "    print('Median horizontal frequency', np.median(horizontal_magnitudes), ', median vertical frequency', np.median(vertical_magnitudes))\n",
+    "    # Plot frequency analysis with peaks\n",
+    "    plt.figure(figsize=(25, 5))\n",
+    "\n",
+    "    # Plot frequency analysis\n",
+    "    plt.subplot(1, 6, 1)\n",
+    "    plt.imshow(image, cmap='gray')\n",
+    "    plt.title('Original Image')\n",
+    "\n",
+    "    plt.subplot(1, 6, 2)\n",
+    "    plt.imshow(np.log(1 + np.abs(horizontal_freq)), cmap='gray')\n",
+    "    plt.title('Horizontal Frequency Analysis')\n",
+    "\n",
+    "    plt.subplot(1, 6, 3)\n",
+    "    plt.imshow(np.log(1 + np.abs(vertical_freq)), cmap='gray')\n",
+    "    plt.title('Vertical Frequency Analysis')\n",
+    "\n",
+    "    plt.subplot(1, 6, 4)\n",
+    "    plt.imshow(np.log(1 + np.abs(twod)), cmap='gray')\n",
+    "    plt.title('2D Frequency Analysis')\n",
+    "\n",
+    "    plt.subplot(1, 6, 5)\n",
+    "    plt.scatter(horizontal_freqs[1:], horizontal_magnitudes[1:], s=5)\n",
+    "    # plt.plot(horizontal_freqs[horizontal_peaks], horizontal_magnitudes[horizontal_peaks], 'ro', markersize=5)\n",
+    "    plt.xlabel('Horizontal Frequency')\n",
+    "    plt.ylabel('Magnitude')\n",
+    "    plt.title('Horizontal Frequency Analysis with Peaks')\n",
+    "\n",
+    "    plt.subplot(1, 6, 6)\n",
+    "    plt.scatter(vertical_freqs[1:], vertical_magnitudes[1:], s=5)\n",
+    "    # plt.plot(vertical_freqs[vertical_peaks], vertical_magnitudes[vertical_peaks], 'ro', markersize=5)\n",
+    "    plt.xlabel('Vertical Frequency')\n",
+    "    plt.ylabel('Magnitude')\n",
+    "    plt.title('Vertical Frequency Analysis with Peaks')\n",
+    "\n",
+    "\n",
+    "    plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When the absolute value of the frequency is high in the context of Fourier analysis, it indicates the presence of a rapidly changing or repeating pattern in the image. The frequency component's absolute value reflects how many cycles of the pattern occur within a fixed interval.\n",
+    "\n",
+    "In Fourier analysis:\n",
+    "\n",
+    "Higher Frequency Components: Higher absolute frequency values correspond to faster changes or repetitions in the image data. This means that the pattern or feature represented by that frequency component oscillates more rapidly across the image.\n",
+    "\n",
+    "Spatial Frequency: In image analysis, frequency is often associated with how quickly the intensity or color changes as you move across the image. High absolute frequency values indicate rapid changes or transitions in the image content.\n",
+    "\n",
+    "Fine Details and Textures: Rapidly oscillating frequency components are associated with fine details and textures in the image. For example, in textiles, high-frequency components might capture the intricate weave patterns or small-scale textures.\n",
+    "\n",
+    "Small-Scale Features: Patterns that repeat at small scales, such as fine lines or tiny structures, tend to result in high-frequency components with high absolute values.\n",
+    "\n",
+    "Edges and Transitions: Edges and sharp transitions between different colors or intensities are also associated with high-frequency components. These transitions involve rapid changes in intensity, leading to higher absolute frequency values."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "from scipy.signal import find_peaks\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "\n",
+    "for image in images:\n",
+    "    get_freqs(image)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from scipy.signal import find_peaks\n",
+    "from collections import Counter\n",
+    "import seaborn as sns\n",
+    "# Load the image\n",
+    "image = cv2.imread(images_textiles[0], cv2.IMREAD_GRAYSCALE)\n",
+    "\n",
+    "# Perform 1D Fourier Transforms\n",
+    "horizontal_freq = np.fft.fftshift(np.fft.fft(image, axis=1))\n",
+    "vertical_freq = np.fft.fftshift(np.fft.fft(image, axis=0))\n",
+    "\n",
+    "# Calculate magnitude spectra\n",
+    "horizontal_magnitudes = np.abs(horizontal_freq)[0]\n",
+    "vertical_magnitudes = np.abs(vertical_freq)[0]\n",
+    "\n",
+    "# Create histograms of magnitude recurrence\n",
+    "horizontal_magnitude_counter = Counter(np.round(horizontal_magnitudes).astype(int))\n",
+    "vertical_magnitude_counter = Counter(np.round(vertical_magnitudes).astype(int))\n",
+    "\n",
+    "# Plot magnitude recurrence histograms\n",
+    "plt.figure(figsize=(12, 5))\n",
+    "\n",
+    "plt.subplot(1, 2, 1)\n",
+    "sns.histplot(list(horizontal_magnitude_counter.elements()), kde=True, color='blue')\n",
+    "plt.xlim(0, 1000)  # Limit x-axis range\n",
+    "plt.xlabel('Magnitude')\n",
+    "plt.ylabel('Recurrence')\n",
+    "plt.title('Horizontal Magnitude Recurrence')\n",
+    "\n",
+    "plt.subplot(1, 2, 2)\n",
+    "sns.histplot(list(vertical_magnitude_counter.elements()), kde=True, color='green')\n",
+    "plt.xlim(0, 1000)  # Limit x-axis range\n",
+    "plt.xlabel('Magnitude')\n",
+    "plt.ylabel('Recurrence')\n",
+    "plt.title('Vertical Magnitude Recurrence')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from skimage.feature import hog\n",
+    "from skimage import exposure\n",
+    "\n",
+    "# Load the image\n",
+    "image = cv2.imread(images_textiles[4], cv2.IMREAD_GRAYSCALE)\n",
+    "\n",
+    "# Center crop the image to remove black borders\n",
+    "height, width = image.shape\n",
+    "crop_size = 200\n",
+    "center_x = width // 2\n",
+    "center_y = height // 2\n",
+    "crop_half_size = crop_size // 2\n",
+    "cropped_image = image[center_y - crop_half_size:center_y + crop_half_size,\n",
+    "                      center_x - crop_half_size:center_x + crop_half_size]\n",
+    "\n",
+    "# Compute HOG features\n",
+    "orientations = 9\n",
+    "pixels_per_cell = (5, 5)\n",
+    "cells_per_block = (1,1)\n",
+    "hog_features, hog_image = hog(cropped_image, orientations=orientations,\n",
+    "                              pixels_per_cell=pixels_per_cell,\n",
+    "                              cells_per_block=cells_per_block,\n",
+    "                              block_norm='L2-Hys',\n",
+    "                              visualize=True)\n",
+    "\n",
+    "# Plot the HOG image\n",
+    "plt.figure(figsize=(8, 4))\n",
+    "plt.subplot(1, 2, 1)\n",
+    "plt.imshow(cropped_image, cmap='gray')\n",
+    "plt.title('Original Image')\n",
+    "\n",
+    "plt.subplot(1, 2, 2)\n",
+    "plt.imshow(hog_image, cmap='gray')\n",
+    "plt.title('HOG Image')\n",
+    "plt.axis('off')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "# Plot the orientation distribution\n",
+    "hog_histogram, _ = np.histogram(hog_features, bins=orientations)\n",
+    "angles_deg = np.arange(0, 180, 180/orientations)\n",
+    "plt.figure(figsize=(6, 4))\n",
+    "plt.bar(angles_deg, hog_histogram, width=180/orientations)\n",
+    "plt.xlabel('Orientation (degrees)')\n",
+    "plt.ylabel('Frequency')\n",
+    "plt.title('Orientation Distribution')\n",
+    "plt.xticks(angles_deg)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import pywt\n",
+    "\n",
+    "# Load the image\n",
+    "image = cv2.imread(images_textiles[0], cv2.IMREAD_GRAYSCALE)\n",
+    "\n",
+    "# Perform Continuous Wavelet Transform (CWT) on each row of the image\n",
+    "wavelet = 'morl'  # You can choose a different wavelet basis\n",
+    "scales = np.arange(1, 20)  # Scales to analyze\n",
+    "\n",
+    "cwt_coeffs = []\n",
+    "for row in image:\n",
+    "    coeffs, _ = pywt.cwt(row, scales, wavelet)\n",
+    "    cwt_coeffs.append(coeffs)\n",
+    "\n",
+    "cwt_coeffs = np.array(cwt_coeffs)\n",
+    "\n",
+    "# Plot scaleograms\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "plt.imshow(np.abs(cwt_coeffs[:, 0, :]), extent=[0, image.shape[1], scales[-1], scales[0]], cmap='viridis', aspect='auto')\n",
+    "plt.colorbar(label='Magnitude')\n",
+    "plt.title('Wavelet Scaleogram')\n",
+    "plt.xlabel('Pixel')\n",
+    "plt.ylabel('Scale')\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "art-reco_x86",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.16"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

stylespace_colour_disentanglement.ipynb

@@ -0,0 +1,580 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "fe83bcc2",
+   "metadata": {},
+   "source": [
+    "![image](/Users/ludovicaschaerf/Desktop/latent-space-theories/data/stylegan3.webp)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3722712c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline  \n",
+    "\n",
+    "import pandas as pd\n",
+    "import pickle\n",
+    "import random\n",
+    "\n",
+    "from PIL import Image, ImageColor\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "\n",
+    "from backend.disentangle_concepts import *\n",
+    "from backend.color_annotations import *\n",
+    "from backend.networks_stylegan3 import *\n",
+    "import dnnlib \n",
+    "import legacy\n",
+    "\n",
+    "import random\n",
+    "\n",
+    "from sklearn.linear_model import LinearRegression, LogisticRegression\n",
+    "\n",
+    "\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fe7acfaf-dc61-4211-9c78-8e4433bc9deb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "annotations_file = './data/textile_annotated_files/seeds0000-100000.pkl'\n",
+    "with open(annotations_file, 'rb') as f:\n",
+    "    annotations = pickle.load(f)\n",
+    "\n",
+    "ann_df = pd.read_csv('./data/textile_annotated_files/top_three_colours.csv').fillna('#000000')\n",
+    "\n",
+    "with dnnlib.util.open_url('./data/textile_model_files/network-snapshot-005000.pkl') as f:\n",
+    "    model = legacy.load_network_pkl(f)['G_ema'].to('cpu') # type: ignore\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0e4b656e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "z = torch.from_numpy(annotations['w_vectors'][0].copy()).to('cpu')\n",
+    "W = z.expand((16, -1)).unsqueeze(0)\n",
+    "img = model.synthesis(W, noise_mode='const')\n",
+    "img.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1259f950",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "in_ = model.synthesis.input(W[0, 0].unsqueeze(0))\n",
+    "l1 = model.synthesis.L0_36_512(in_, W[0, 1].unsqueeze(0))\n",
+    "l1.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "918feb0e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = 'L0_36_512'\n",
+    "getattr(model.synthesis, a)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1bf7bfa4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rest_from_style(x, styles, layer):\n",
+    "    dtype = torch.float16 if (getattr(model.synthesis, layer).use_fp16 and device=='cuda') else torch.float32\n",
+    "    if getattr(model.synthesis, layer).is_torgb:\n",
+    "        print(layer, getattr(model.synthesis, layer).is_torgb)\n",
+    "        weight_gain = 1 / np.sqrt(getattr(model.synthesis, layer).in_channels * (getattr(model.synthesis, layer).conv_kernel ** 2))\n",
+    "        styles = styles * weight_gain\n",
+    "    input_gain = getattr(model.synthesis, layer).magnitude_ema.rsqrt().to(dtype)\n",
+    "    # Execute modulated conv2d.\n",
+    "    x = modulated_conv2d(x=x.to(dtype), w=getattr(model.synthesis, layer).weight.to(dtype), s=styles.to(dtype),\n",
+    "    padding=getattr(model.synthesis, layer).conv_kernel-1, demodulate=(not getattr(model.synthesis, layer).is_torgb), input_gain=input_gain.to(dtype))\n",
+    "    # Execute bias, filtered leaky ReLU, and clamping.\n",
+    "    gain = 1 if getattr(model.synthesis, layer).is_torgb else np.sqrt(2)\n",
+    "    slope = 1 if getattr(model.synthesis, layer).is_torgb else 0.2\n",
+    "    x = filtered_lrelu.filtered_lrelu(x=x, fu=getattr(model.synthesis, layer).up_filter, fd=getattr(model.synthesis, layer).down_filter, \n",
+    "                                        b=getattr(model.synthesis, layer).bias.to(x.dtype),\n",
+    "                                        up=getattr(model.synthesis, layer).up_factor, down=getattr(model.synthesis, layer).down_factor, \n",
+    "                                        padding=getattr(model.synthesis, layer).padding,\n",
+    "                                        gain=gain, slope=slope, clamp=getattr(model.synthesis, layer).conv_clamp)\n",
+    "    return x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c674780d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x1 = rest_from_style(in_, model.synthesis.L0_36_512.affine(W[0, 1].unsqueeze(0)), 'L0_36_512')\n",
+    "x1.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0305ce16",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def getS(w):\n",
+    "    w_torch = torch.from_numpy(w).to('cpu')\n",
+    "    W = w_torch.expand((16, -1)).unsqueeze(0)\n",
+    "    s = []\n",
+    "    s.append(model.synthesis.input.affine(W[0, 0].unsqueeze(0)).numpy())\n",
+    "    s.append(model.synthesis.L0_36_512.affine(W[0, 1].unsqueeze(0)).numpy())\n",
+    "    s.append(model.synthesis.L1_36_512.affine(W[0, 2].unsqueeze(0)).numpy())\n",
+    "    s.append(model.synthesis.L2_36_512.affine(W[0, 3].unsqueeze(0)).numpy())\n",
+    "    s.append(model.synthesis.L3_52_512.affine(W[0, 4].unsqueeze(0)).numpy())\n",
+    "    s.append(model.synthesis.L4_52_512.affine(W[0, 5].unsqueeze(0)).numpy())\n",
+    "    s.append(model.synthesis.L5_84_512.affine(W[0, 6].unsqueeze(0)).numpy())\n",
+    "    s.append(model.synthesis.L6_84_512.affine(W[0, 7].unsqueeze(0)).numpy())\n",
+    "    s.append(model.synthesis.L7_148_512.affine(W[0, 8].unsqueeze(0)).numpy())\n",
+    "    s.append(model.synthesis.L8_148_512.affine(W[0, 9].unsqueeze(0)).numpy())\n",
+    "    s.append(model.synthesis.L9_148_362.affine(W[0, 10].unsqueeze(0)).numpy())\n",
+    "    s.append(model.synthesis.L10_276_256.affine(W[0, 11].unsqueeze(0)).numpy())\n",
+    "    s.append(model.synthesis.L11_276_181.affine(W[0, 12].unsqueeze(0)).numpy())\n",
+    "    s.append(model.synthesis.L12_276_128.affine(W[0, 13].unsqueeze(0)).numpy())\n",
+    "    s.append(model.synthesis.L13_256_128.affine(W[0, 14].unsqueeze(0)).numpy())\n",
+    "    s.append(model.synthesis.L14_256_3.affine(W[0, 15].unsqueeze(0)).numpy())\n",
+    "    return s"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "981f5215",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "s = getS(annotations['w_vectors'][0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "389ad35a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "shapes = [512] + [x.shape[1] for x in s]\n",
+    "layers = ['w', 'input', 'L0_36_512', 'L1_36_512', 'L2_36_512', 'L3_52_512', 'L4_52_512', 'L5_84_512', 'L6_84_512',\n",
+    "          'L7_148_512', 'L8_148_512', 'L9_148_362', 'L10_276_256', 'L11_276_181', 'L12_276_128', 'L13_256_128',\n",
+    "          'L14_256_3']\n",
+    "sum(shapes), shapes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3c143e86",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def generate_flexible_images(w, change_vectors, lambdas=1, device='cpu'):\n",
+    "    w_torch = torch.from_numpy(w).to('cpu')\n",
+    "    # w_torch = w_torch + lambdas * change_vectors[0]\n",
+    "    W = w_torch.expand((16, -1)).unsqueeze(0)\n",
+    "    \n",
+    "    x = model.synthesis.input(W[0,0].unsqueeze(0))\n",
+    "    for i, layer in enumerate(layers):\n",
+    "        if i < 2:\n",
+    "            continue\n",
+    "        style = getattr(model.synthesis, layer).affine(W[0, i-1].unsqueeze(0))\n",
+    "        change = torch.from_numpy(change_vectors[i].copy()).unsqueeze(0).to(device)\n",
+    "        style = torch.add(style, change, alpha=lambdas)\n",
+    "        x = rest_from_style(x, style, layer)\n",
+    "    \n",
+    "    if model.synthesis.output_scale != 1:\n",
+    "            x = x * model.synthesis.output_scale\n",
+    "\n",
+    "    img = (x.permute(0, 2, 3, 1) * 127.5 + 128).clamp(0, 255).to(torch.uint8)\n",
+    "    img = PIL.Image.fromarray(img[0].cpu().numpy(), 'RGB')\n",
+    "        \n",
+    "    return img"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f03915ff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_original_pos(top_positions):\n",
+    "    current_idx = 0\n",
+    "    vectors = []\n",
+    "    for i, (leng, layer) in enumerate(zip(shapes, layers)):\n",
+    "        arr = np.zeros(leng)\n",
+    "        for top_position in top_positions:\n",
+    "            if top_position >= current_idx and top_position < current_idx + leng:\n",
+    "                arr[top_position - current_idx] = 1\n",
+    "            arr = arr / (np.linalg.norm(arr) + 0.000001)\n",
+    "        vectors.append(arr)\n",
+    "        current_idx += leng\n",
+    "    return vectors    \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e76d836d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ss = []\n",
+    "for i in tqdm(range(len(annotations['w_vectors']))):\n",
+    "    ss.append(getS(annotations['w_vectors'][i]))\n",
+    "    \n",
+    "annotations['s_vectors'] = ss"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6ea1ca59",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "annotations_file = './data/textile_annotated_files/seeds0000-100000_S.pkl'\n",
+    "with open(annotations_file, 'wb') as f:\n",
+    "    pickle.dump(annotations, f)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "12f78bdb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "len(ss)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cd114cb1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ann_df = tohsv(ann_df)\n",
+    "ann_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0d470f83",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def getX(annotations, space='s'):\n",
+    "    if space == 'x':\n",
+    "        X = np.array(annotations['w_vectors']).reshape((len(annotations['w_vectors']), 512))\n",
+    "    elif space == 's':\n",
+    "        concat_v = []\n",
+    "        for i in range(len(annotations['w_vectors'])):\n",
+    "            concat_v.append(np.concatenate([annotations['w_vectors'][i]] + annotations['s_vectors'][i], axis=1))\n",
+    "            \n",
+    "        X = np.array(concat_v)\n",
+    "        X = X[:, 0, :]\n",
+    "        print(X.shape)\n",
+    "        \n",
+    "    return X\n",
+    "        \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "feb64168",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = getX(annotations)\n",
+    "print(X.shape)\n",
+    "y_h = np.array(ann_df['H1'].values)\n",
+    "y_s = np.array(ann_df['S1'].values)\n",
+    "y_v = np.array(ann_df['S1'].values)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "afa0c100",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "colors_list = ['Warm Pink Red', 'Red Orange', 'Orange Yellow', 'Gold Yellow', 'Chartreuse Green',\n",
+    "               'Kelly Green', 'Green Blue Seafoam', 'Blue Green Cyan',\n",
+    "               'Warm Blue', 'Indigo Blue Purple', 'Purple Magenta', 'Magenta Pink']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "39a5668a",
+   "metadata": {},
+   "source": [
+    "double check colori"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5f2b48c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print([int(x*256/12) if x<12 else 255 for x in range(13)])\n",
+    "y_h_cat = pd.cut(y_h,bins=[x*256/12 if x<12 else 256 for x in range(13)],labels=colors_list).fillna('Warm Pink Red')\n",
+    "\n",
+    "print(y_h_cat.value_counts(dropna=False))\n",
+    "x_trainhc, x_valhc, y_trainhc, y_valhc = train_test_split(X, y_h_cat, test_size=0.2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6c2a1765",
+   "metadata": {},
+   "source": [
+    "### Variance based"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2be4202e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "positives = x_trainhc[np.where(y_trainhc == 'Warm Blue')]\n",
+    "print(positives.shape, x_trainhc.shape)\n",
+    "variations = detect_attribute_specific_channels(positives, x_trainhc, sign=True)\n",
+    "print(variations.shape, np.argmax(variations))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7d0c129d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "argsorted_vars = np.argsort(variations)[-5:]\n",
+    "sorted_vars = np.sort(variations)[-5:]\n",
+    "argsorted_vars, sorted_vars"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e2c2ed49",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "original_pos = get_original_pos(argsorted_vars)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "82e30f0c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "seed = random.randint(0,100000)\n",
+    "seed = 52722\n",
+    "original_image_vec = annotations['w_vectors'][seed]\n",
+    "img = generate_original_image(original_image_vec, model, latent_space='W')\n",
+    "img"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cd71f2c8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "device = 'cpu'\n",
+    "img1 = generate_flexible_images(original_image_vec, original_pos, lambdas=-1)\n",
+    "img1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "abc5ac3f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "img1 = generate_flexible_images(original_image_vec, original_pos, lambdas=-2)\n",
+    "img1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0602dcab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "len(original_pos)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d7eb412f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "img1 = generate_flexible_images(original_image_vec, original_pos, lambdas=1)\n",
+    "img1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "03161270",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "seps, vals = all_variance_based_disentanglements(colors_list, x_trainhc, y_trainhc, k=10, sign=True, space='s')\n",
+    "vals[2].shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ae1016d6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "warm_pink_val = get_verification_score(0, seps[0], model, annotations, samples=10, latent_space='W')\n",
+    "warm_pink_val"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b412cb25",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "warm_blue_val = get_verification_score(8, seps[8], model, annotations, samples=10, latent_space='W')\n",
+    "warm_blue_val"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6812cb6b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "seps, _ = all_variance_based_disentanglements(colors_list, x_trainhc, y_trainhc, k=10, sign=True)\n",
+    "\n",
+    "for sep, color in zip(seps, colors_list):\n",
+    "    images, lambdas = regenerate_images(model, original_image_vec, sep, min_epsilon=-(int(4)), max_epsilon=int(4), count=5, latent_space='W')\n",
+    "    fig, axs = plt.subplots(1, len(images), figsize=(50,10))\n",
+    "    fig.suptitle(color, fontsize=20)\n",
+    "    for i,im in enumerate(images):\n",
+    "        axs[i].imshow(im)\n",
+    "        axs[i].set_title(np.round(lambdas[i], 2))\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "24b8f275",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "seps = all_variance_based_disentanglements(colors_list, x_trainhc, y_trainhc, k=10, sign=True)\n",
+    "\n",
+    "for sep, color in zip(seps, colors_list):\n",
+    "    images, lambdas = regenerate_images(model, original_image_vec, sep, min_epsilon=-(int(4)), max_epsilon=int(4), count=5, latent_space='W')\n",
+    "    fig, axs = plt.subplots(1, len(images), figsize=(50,10))\n",
+    "    fig.suptitle(color, fontsize=20)\n",
+    "    for i,im in enumerate(images):\n",
+    "        axs[i].imshow(im)\n",
+    "        axs[i].set_title(np.round(lambdas[i], 2))\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b6c61fbb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "separation_vector_onehot = np.zeros(512)\n",
+    "separation_vector_onehot[argsorted_vars] = 1\n",
+    "\n",
+    "images, lambdas = regenerate_images(model, original_image_vec, separation_vector_onehot, min_epsilon=-(int(10)), max_epsilon=int(10), count=7, latent_space='W')\n",
+    "fig, axs = plt.subplots(1, len(images), figsize=(30,200))\n",
+    "for i,im in enumerate(images):\n",
+    "    axs[i].imshow(im)\n",
+    "    axs[i].set_title(np.round(lambdas[i], 2))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7c19e820",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

view_predictions.ipynb

@@ -2,31 +2,10 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "fe7acfaf-dc61-4211-9c78-8e4433bc9deb",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Intel MKL WARNING: Support of Intel(R) Streaming SIMD Extensions 4.2 (Intel(R) SSE4.2) enabled only processors has been deprecated. Intel oneAPI Math Kernel Library 2025.0 will require Intel(R) Advanced Vector Extensions (Intel(R) AVX) instructions.\n",
-      "Intel MKL WARNING: Support of Intel(R) Streaming SIMD Extensions 4.2 (Intel(R) SSE4.2) enabled only processors has been deprecated. Intel oneAPI Math Kernel Library 2025.0 will require Intel(R) Advanced Vector Extensions (Intel(R) AVX) instructions.\n"
-     ]
-    },
-    {
-     "ename": "ModuleNotFoundError",
-     "evalue": "No module named 'sklearn'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[1], line 8\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mtorch\u001b[39;00m\n\u001b[1;32m      7\u001b[0m \u001b[39m#import ninja\u001b[39;00m\n\u001b[0;32m----> 8\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mbackend\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mdisentangle_concepts\u001b[39;00m \u001b[39mimport\u001b[39;00m \u001b[39m*\u001b[39m\n\u001b[1;32m      9\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mdnnlib\u001b[39;00m \n\u001b[1;32m     10\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mlegacy\u001b[39;00m\n",
-      "File \u001b[0;32m~/Desktop/latent-space-theories/backend/disentangle_concepts.py:2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mnumpy\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mnp\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39msklearn\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39msvm\u001b[39;00m \u001b[39mimport\u001b[39;00m SVC\n\u001b[1;32m      3\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39msklearn\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mlinear_model\u001b[39;00m \u001b[39mimport\u001b[39;00m LogisticRegression\n\u001b[1;32m      4\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39msklearn\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mmodel_selection\u001b[39;00m \u001b[39mimport\u001b[39;00m train_test_split\n",
-      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'sklearn'"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import pandas as pd\n",
     "import pickle\n",
@@ -171,19 +150,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "0eae840f",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/ludovicaschaerf/anaconda3/envs/torch_arm/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from .autonotebook import tqdm as notebook_tqdm\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import open_clip\n",
     "import os\n",
@@ -194,7 +164,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "4d776015",
    "metadata": {},
    "outputs": [],
@@ -205,33 +175,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "e3f917a7",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "['Provenance ADRIA', 'Provenance AEGINA', 'Provenance AL MINA', 'Provenance ALICANTE', 'Provenance AMATHUS', 'Provenance AMPURIAS', 'Provenance APOLLONIA PONTICA', 'Provenance APULIA', 'Provenance ARGOLIS', 'Provenance ARGOS', 'Provenance ATHENS', 'Provenance ATHENS (?)', 'Provenance ATTICA', 'Provenance BARI', 'Provenance BENGHAZI', 'Provenance BEREZAN', 'Provenance BLACK SEA', 'Provenance BOEOTIA', 'Provenance BOLOGNA', 'Provenance CAPUA', 'Provenance CARIA', 'Provenance CARTHAGE', 'Provenance CHIUSI', 'Provenance CIVITAVECCHIA', 'Provenance CORINTH', 'Provenance CORSICA', 'Provenance CRETE', 'Provenance CRIMEA', 'Provenance CUMAE', 'Provenance CYCLADES', 'Provenance CYPRUS', 'Provenance CYRENAICA', 'Provenance CYRENE', 'Provenance EGYPT', 'Provenance ELIS', 'Provenance ENSERUNE', 'Provenance ETRURIA', 'Provenance EUBOEA', 'Provenance FALERII', 'Provenance GRANADA', 'Provenance GREECE', 'Provenance GREECE (?)', 'Provenance HISTRIA', 'Provenance ITALY', 'Provenance JAEN', 'Provenance KITION', 'Provenance LESBOS', 'Provenance LOCRI', 'Provenance LOCRIS', 'Provenance LYCIA', 'Provenance MACEDONIA', 'Provenance MARION', 'Provenance MARSEILLES', 'Provenance MARZABOTTO', 'Provenance METAPONTUM', 'Provenance MILETUS', 'Provenance NAPLES', 'Provenance NAUCRATIS', 'Provenance NOLA', 'Provenance NUMANA', 'Provenance OLD SMYRNA', 'Provenance ORVIETO', 'Provenance PAESTUM', 'Provenance PHOCIS', 'Provenance PITANE', 'Provenance POPULONIA', 'Provenance RHODES', 'Provenance ROME', 'Provenance RUVO', 'Provenance SALERNO', 'Provenance SAMOS', 'Provenance SARDINIA', 'Provenance SARDIS', 'Provenance SICILY', 'Provenance SMYRNA', 'Provenance SOUTH', 'Provenance SPARTA', 'Provenance SPINA', 'Provenance SUESSULA', 'Provenance TARANTO', 'Provenance TELL DEFENNEH', 'Provenance THASOS', 'Provenance THERA', 'Provenance THESSALY', 'Provenance THRACE', 'Provenance TOCRA', 'Provenance TODI', 'Provenance ULLASTRET', 'Provenance VALENCIA', 'Shape Name ALABASTRON', 'Shape Name ALABASTRON FRAGMENT', 'Shape Name AMPHORA', 'Shape Name AMPHORA (?) FRAGMENT', 'Shape Name AMPHORISKOS', 'Shape Name ARYBALLOS', 'Shape Name ASKOS', 'Shape Name ASKOS FRAGMENT', 'Shape Name BOTTLE', 'Shape Name BOWL', 'Shape Name BOWL FRAGMENT', 'Shape Name CHALICE', 'Shape Name CHALICE FRAGMENT', 'Shape Name CHOUS', 'Shape Name CHOUS FRAGMENT', 'Shape Name CUP', 'Shape Name CUP (?) FRAGMENT', 'Shape Name CUP A', 'Shape Name CUP A FRAGMENT', 'Shape Name CUP A FRAGMENTS', 'Shape Name CUP B', 'Shape Name CUP B FRAGMENT', 'Shape Name CUP B FRAGMENTS', 'Shape Name CUP C', 'Shape Name CUP C FRAGMENT', 'Shape Name CUP C FRAGMENTS', 'Shape Name CUP DROOP', 'Shape Name CUP DROOP FRAGMENT', 'Shape Name CUP FRAGMENT', 'Shape Name CUP FRAGMENTS', 'Shape Name CUP KASSEL', 'Shape Name CUP KASSEL FRAGMENT', 'Shape Name CUP LITTLE MASTER BAND', 'Shape Name CUP LITTLE MASTER BAND (?) FRAGMENT', 'Shape Name CUP LITTLE MASTER BAND FRAGMENT', 'Shape Name CUP LITTLE MASTER BAND FRAGMENTS', 'Shape Name CUP LITTLE MASTER FRAGMENT', 'Shape Name CUP LITTLE MASTER LIP', 'Shape Name CUP LITTLE MASTER LIP FRAGMENT', 'Shape Name CUP LITTLE MASTER LIP FRAGMENTS', 'Shape Name CUP SIANA', 'Shape Name CUP SIANA FRAGMENT', 'Shape Name CUP SIANA FRAGMENTS', 'Shape Name CUP SKYPHOS', 'Shape Name CUP SKYPHOS FRAGMENT', 'Shape Name CUP STEMLESS', 'Shape Name CUP STEMLESS FRAGMENT', 'Shape Name CUP STEMLESS FRAGMENTS', 'Shape Name DINOS', 'Shape Name DINOS FRAGMENT', 'Shape Name DISH', 'Shape Name EPICHYSIS', 'Shape Name EPINETRON FRAGMENT', 'Shape Name FEEDER', 'Shape Name FIGURE VASE', 'Shape Name FIGURE VASE ARYBALLOS', 'Shape Name FIGURE VASE ASKOS', 'Shape Name FIGURE VASE FRAGMENT', 'Shape Name FIGURE VASE KANTHAROS', 'Shape Name FIGURE VASE LEKYTHOS', 'Shape Name FIGURE VASE OINOCHOE', 'Shape Name FISH-PLATE', 'Shape Name FLASK', 'Shape Name FRAGMENT', 'Shape Name FRAGMENTS', 'Shape Name GUTTUS', 'Shape Name HYDRIA', 'Shape Name HYDRIA (?) FRAGMENT', 'Shape Name HYDRIA FRAGMENT', 'Shape Name HYDRIA FRAGMENTS', 'Shape Name INCENSE BURNER', 'Shape Name JAR', 'Shape Name JUG', 'Shape Name KALATHOS', 'Shape Name KANTHAROS', 'Shape Name KANTHAROS FRAGMENT', 'Shape Name KERNOS', 'Shape Name KOTYLE', 'Shape Name KOTYLE FRAGMENT', 'Shape Name KRATER', 'Shape Name KRATER (?) FRAGMENT', 'Shape Name KRATER FRAGMENT', 'Shape Name KRATER FRAGMENTS', 'Shape Name KYATHOS', 'Shape Name KYATHOS FRAGMENT', 'Shape Name LEBES', 'Shape Name LEBES FRAGMENT', 'Shape Name LEKANIS', 'Shape Name LEKANIS FRAGMENT', 'Shape Name LEKANIS FRAGMENTS', 'Shape Name LEKANIS LID', 'Shape Name LEKANIS LID FRAGMENT', 'Shape Name LEKYTHOS', 'Shape Name LEKYTHOS FRAGMENT', 'Shape Name LEKYTHOS FRAGMENTS', 'Shape Name LID', 'Shape Name LID FRAGMENT', 'Shape Name LOUTROPHOROS', 'Shape Name LOUTROPHOROS FRAGMENT', 'Shape Name LOUTROPHOROS FRAGMENTS', 'Shape Name LYDION', 'Shape Name MASTOID', 'Shape Name MINIATURE PANATHENAIC AMPHORA', 'Shape Name MUG', 'Shape Name MUG FRAGMENT', 'Shape Name NESTORIS', 'Shape Name OINOCHOE', 'Shape Name OINOCHOE (?) FRAGMENT', 'Shape Name OINOCHOE FRAGMENT', 'Shape Name OINOCHOE FRAGMENTS', 'Shape Name OLLA', 'Shape Name OLPE', 'Shape Name OLPE FRAGMENT', 'Shape Name OLPE FRAGMENTS', 'Shape Name PELIKE', 'Shape Name PELIKE FRAGMENT', 'Shape Name PELIKE FRAGMENTS', 'Shape Name PHIALE', 'Shape Name PHIALE FRAGMENT', 'Shape Name PITCHER', 'Shape Name PLAQUE FRAGMENT', 'Shape Name PLAQUE FRAGMENTS', 'Shape Name PLATE', 'Shape Name PLATE FRAGMENT', 'Shape Name PLATE FRAGMENTS', 'Shape Name PLEMOCHOE', 'Shape Name PSEUDO-PANATHENAIC AMPHORA', 'Shape Name PSEUDO-PANATHENAIC AMPHORA FRAGMENT', 'Shape Name PSYKTER', 'Shape Name PYXIS', 'Shape Name PYXIS FRAGMENT', 'Shape Name PYXIS FRAGMENTS', 'Shape Name PYXIS LID', 'Shape Name PYXIS LID FRAGMENT', 'Shape Name RHYTON', 'Shape Name SKYPHOS', 'Shape Name SKYPHOS (?) FRAGMENT', 'Shape Name SKYPHOS FRAGMENT', 'Shape Name SKYPHOS FRAGMENTS', 'Shape Name STAMNOS', 'Shape Name STAMNOS FRAGMENT', 'Shape Name STAMNOS FRAGMENTS', 'Shape Name STAND', 'Shape Name STAND FRAGMENT', 'Shape Name STEMLESS CUP FRAGMENT', 'Shape Name STIRRUP JAR', 'Shape Name TANKARD', 'Shape Name UNKNOWN', 'Shape Name URN', 'Shape Name VARIOUS', 'Shape Name VASE', 'Fabric ARGIVE GEOMETRIC', 'Fabric ARRETINE', 'Fabric ATHENIAN', 'Fabric ATHENIAN (?)', 'Fabric ATHENIAN GEOMETRIC', 'Fabric ATHENIAN PROTOGEOMETRIC', 'Fabric BOEOTIAN', 'Fabric BOEOTIAN GEOMETRIC', 'Fabric CALENIAN', 'Fabric CAMPANA', 'Fabric CANOSAN', 'Fabric CHALCIDIAN', 'Fabric CORINTHIAN', 'Fabric CRETAN', 'Fabric CYCLADIC', 'Fabric CYPRIOT', 'Fabric CYPRIOT, BRONZE AGE', 'Fabric CYPRIOT, IRON AGE', 'Fabric CYPRIOT, MYCENAEAN STYLE', 'Fabric DAUNIAN', 'Fabric EAST GREEK', 'Fabric EAST GREEK GEOMETRIC', 'Fabric EAST GREEK, CLAZOMENIAN', 'Fabric EAST GREEK, FIKELLURA', 'Fabric EAST GREEK, NAUCRATITE', 'Fabric EGYPTIAN', 'Fabric ETRUSCAN', 'Fabric ETRUSCO-CORINTHIAN', 'Fabric FALISCAN', 'Fabric GALLIC', 'Fabric GALLO-ROMAN', 'Fabric GREEK', 'Fabric HELLADIC', 'Fabric HELLENISTIC', 'Fabric IBERIAN', 'Fabric IONIAN', 'Fabric ITALIOTE', 'Fabric ITALO-CORINTHIAN', 'Fabric ITALO-GEOMETRIC', 'Fabric LACONIAN', 'Fabric LACONIAN GEOMETRIC', 'Fabric MESSAPIAN', 'Fabric MINOAN', 'Fabric MYCENEAN', 'Fabric PONTIC', 'Fabric PROTO-ELAMITE', 'Fabric PROTOATTIC', 'Fabric PROTOCORINTHIAN', 'Fabric PROTOCORINTHIAN, TRANSITIONAL', 'Fabric ROMAN', 'Fabric SOUTH ITALIAN', 'Fabric SOUTH ITALIAN, APULIAN', 'Fabric SOUTH ITALIAN, CAMPANIAN', 'Fabric SOUTH ITALIAN, GNATHIAN', 'Fabric SOUTH ITALIAN, LUCANIAN', 'Fabric SOUTH ITALIAN, PAESTAN', 'Fabric SOUTH ITALIAN, SICILIAN', 'Fabric TERRA SIGILLATA', 'Fabric UNCERTAIN', 'Fabric VEIAN', 'Fabric VILLA NOVA', 'Technique ADDED COLOUR', 'Technique BLACK GLAZE', 'Technique BLACK PATTERN', 'Technique BLACK-FIGURE', 'Technique BROWN GLAZE', 'Technique BUCCHERO', 'Technique IMPASTO', 'Technique OUTLINE', 'Technique PATTERN', 'Technique PLAIN', 'Technique PSEUDO RED-FIGURE', 'Technique RED POLISHED WARE', 'Technique RED-FIGURE', 'Technique RELIEF', 'Technique RESERVING', 'Technique SILHOUETTE', 'Technique WHITE PAINTED WARE']\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/ludovicaschaerf/anaconda3/envs/torch_arm/lib/python3.11/site-packages/torch/amp/autocast_mode.py:221: UserWarning: User provided device_type of 'cuda', but CUDA is not available. Disabling\n",
-      "  warnings.warn('User provided device_type of \\'cuda\\', but CUDA is not available. Disabling')\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(318, 768)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "model_clip, _, preprocess = open_clip.create_model_and_transforms('ViT-L-14', pretrained='laion2b_s32b_b82k')\n",
     "tokenizer = open_clip.get_tokenizer('ViT-L-14')\n",
@@ -257,7 +204,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "f7858bbf",
    "metadata": {},
    "outputs": [],
@@ -267,7 +214,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "id": "de6bd428",
    "metadata": {},
    "outputs": [],
@@ -277,7 +224,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "d19c8e4c",
    "metadata": {},
    "outputs": [],

view_segmentations.ipynb

@@ -0,0 +1,77 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from PIL import Image\n",
+    "from lang_sam import LangSAM"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "def save_mask_as_image(mask, output_path):\n",
+    "    # Create a blank image with the same dimensions as the mask\n",
+    "    width, height = mask.shape[1], mask.shape[0]\n",
+    "    image = Image.new(\"L\", (width, height))\n",
+    "\n",
+    "    # Set the pixel values based on the mask\n",
+    "    for y in range(height):\n",
+    "        for x in range(width):\n",
+    "            pixel_value = 255 if mask[y, x] == 1 else 0\n",
+    "            image.putpixel((x, y), pixel_value)\n",
+    "\n",
+    "    # Save the image as a PNG\n",
+    "    image.save(output_path)\n",
+    "\n",
+    "\n",
+    "\n",
+    "model = LangSAM()\n",
+    "TEST_DIR = '/Users/ludovicaschaerf/Desktop/Data/VA_textiles_masks/'\n",
+    "OUT_DIR = '/Users/ludovicaschaerf/Desktop/Data/VA_textiles/'\n",
+    "image_pil = Image.open(TEST_DIR + \"O25495.jpg\").convert(\"RGB\")\n",
+    "text_prompt = \"textile\"\n",
+    "masks, boxes, phrases, logits = model.predict(image_pil, text_prompt)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "save_mask_as_image(masks[0], OUT_DIR + \"O25495.jpg\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "art-reco_x86",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.16"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}