diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..6ccbdf13744b1496732289c35825e511486f7046
Binary files /dev/null and b/.DS_Store differ
diff --git a/Multilingual_CLIP/HISTORY.md b/Multilingual_CLIP/HISTORY.md
new file mode 100644
index 0000000000000000000000000000000000000000..eb89ba679e75e4cf86a206160fc9df7d4b224187
--- /dev/null
+++ b/Multilingual_CLIP/HISTORY.md
@@ -0,0 +1,39 @@
+## 1.0.10
+
+* it works
+
+## 1.0.8
+
+* small fix
+
+## 1.0.7
+
+* small fix
+
+## 1.0.6
+
+* small fix
+
+## 1.0.5
+
+* small fix
+
+## 1.0.4
+
+* small fix
+
+## 1.0.3
+
+* rename all mentions to multilingual_clip
+
+## 1.0.2
+
+* Multilingual-clip
+
+## 1.0.1
+
+* name it m-clip
+
+## 1.0.0
+
+* first pypi release of multilingual_clip
diff --git a/Multilingual_CLIP/Images/Multilingual-CLIP.png b/Multilingual_CLIP/Images/Multilingual-CLIP.png
new file mode 100644
index 0000000000000000000000000000000000000000..42ac4bd627c6223ada303e3b5aec35b62418bd89
Binary files /dev/null and b/Multilingual_CLIP/Images/Multilingual-CLIP.png differ
diff --git a/Multilingual_CLIP/Images/Orange Apple.png b/Multilingual_CLIP/Images/Orange Apple.png
new file mode 100644
index 0000000000000000000000000000000000000000..69440ee768f20581408039db5c68a6a2cb4eaba2
Binary files /dev/null and b/Multilingual_CLIP/Images/Orange Apple.png differ
diff --git a/Multilingual_CLIP/Images/Smile.jpg b/Multilingual_CLIP/Images/Smile.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..4a861606030540cb9e91fa6191a1cbd7490cbf67
Binary files /dev/null and b/Multilingual_CLIP/Images/Smile.jpg differ
diff --git a/Multilingual_CLIP/Images/bananas.jpg b/Multilingual_CLIP/Images/bananas.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..5985e790280304360bb4038bbaff824840bf27b5
Binary files /dev/null and b/Multilingual_CLIP/Images/bananas.jpg differ
diff --git a/Multilingual_CLIP/Images/fruit bowl.jpg b/Multilingual_CLIP/Images/fruit bowl.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..e4a2f5470a84c175b84485a6f9debba4078ae33d
Binary files /dev/null and b/Multilingual_CLIP/Images/fruit bowl.jpg differ
diff --git a/Multilingual_CLIP/Images/green apple.jpg b/Multilingual_CLIP/Images/green apple.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..128029c3474be072c0862faba605b7293db32ddc
Binary files /dev/null and b/Multilingual_CLIP/Images/green apple.jpg differ
diff --git a/Multilingual_CLIP/Images/happy person.jpg b/Multilingual_CLIP/Images/happy person.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..92a3a3768b944db52b42355ddc0c76a27aa5a055
Binary files /dev/null and b/Multilingual_CLIP/Images/happy person.jpg differ
diff --git a/Multilingual_CLIP/Images/man on bike.jpg b/Multilingual_CLIP/Images/man on bike.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..6e1df1b63d3634b6bfb8a70465bddbca06852e64
Binary files /dev/null and b/Multilingual_CLIP/Images/man on bike.jpg differ
diff --git a/Multilingual_CLIP/Images/purple apple.png b/Multilingual_CLIP/Images/purple apple.png
new file mode 100644
index 0000000000000000000000000000000000000000..5af8ec888b33f4f509fca165e499b3a41607b278
Binary files /dev/null and b/Multilingual_CLIP/Images/purple apple.png differ
diff --git a/Multilingual_CLIP/Images/red apple.jpg b/Multilingual_CLIP/Images/red apple.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..fc56191210d91507ac53c29b342d86701ad951a1
Binary files /dev/null and b/Multilingual_CLIP/Images/red apple.jpg differ
diff --git a/Multilingual_CLIP/Images/sad.jpg b/Multilingual_CLIP/Images/sad.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..0546cb407173ad429843a7fab5603addbc30c1c3
Binary files /dev/null and b/Multilingual_CLIP/Images/sad.jpg differ
diff --git a/Multilingual_CLIP/LICENSE b/Multilingual_CLIP/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..1fff6a0157b950db4dc6729c9f2c50a10a9d3e82
--- /dev/null
+++ b/Multilingual_CLIP/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Fredrik Carlsson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Multilingual_CLIP/Makefile b/Multilingual_CLIP/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..fdc6d91fd5eaf10f98a4e7c3522df0f3f28cd44d
--- /dev/null
+++ b/Multilingual_CLIP/Makefile
@@ -0,0 +1,3 @@
+install: ## [Local development] Upgrade pip, install requirements, install package.
+ python -m pip install -U pip
+ python -m pip install -e .
diff --git a/Multilingual_CLIP/Model Cards/M-BERT Base 69/Fine-Tune-Languages.md b/Multilingual_CLIP/Model Cards/M-BERT Base 69/Fine-Tune-Languages.md
new file mode 100644
index 0000000000000000000000000000000000000000..a14482e1b50c4ee52baf5197e6819885b344f208
--- /dev/null
+++ b/Multilingual_CLIP/Model Cards/M-BERT Base 69/Fine-Tune-Languages.md
@@ -0,0 +1,42 @@
+### List of languages included during CLIP fine-tuning
+
+* Albanian
+* Amharic
+* Arabic
+* Azerbaijani
+* Bengali
+* Bulgarian
+* Catalan
+* Chinese (Simplified)
+* Chinese (Traditional)
+* Dutch
+* English
+* Estonian
+* Farsi
+* French
+* Georgian
+* German
+* Greek
+* Hindi
+* Hungarian
+* Icelandic
+* Indonesian
+* Italian
+* Japanese
+* Kazakh
+* Korean
+* Latvian
+* Macedonian
+* Malay
+* Pashto
+* Polish
+* Romanian
+* Russian
+* Slovenian
+* Spanish
+* Swedish
+* Tagalog
+* Thai
+* Turkish
+* Urdu
+* Vietnamese
diff --git a/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/French-Both.png b/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/French-Both.png
new file mode 100644
index 0000000000000000000000000000000000000000..df4c13fb815c56776b4dcc7268eddbed2a9cb1ff
Binary files /dev/null and b/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/French-Both.png differ
diff --git a/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/German-Both.png b/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/German-Both.png
new file mode 100644
index 0000000000000000000000000000000000000000..f9fdde75a8a4353f34df28af300c7727a7af762b
Binary files /dev/null and b/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/German-Both.png differ
diff --git a/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/Greek-Both.png b/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/Greek-Both.png
new file mode 100644
index 0000000000000000000000000000000000000000..9c6f1293ed355a68ba67af01c6f096cd1ad53bf2
Binary files /dev/null and b/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/Greek-Both.png differ
diff --git a/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/Kannada-Both.png b/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/Kannada-Both.png
new file mode 100644
index 0000000000000000000000000000000000000000..10900f23bc023282c7cea9b0c168ba56e8dd7cae
Binary files /dev/null and b/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/Kannada-Both.png differ
diff --git a/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/M-Swedish-Both.png b/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/M-Swedish-Both.png
new file mode 100644
index 0000000000000000000000000000000000000000..bb98158666146caea9266e685cdd91ddf17731dc
Binary files /dev/null and b/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/M-Swedish-Both.png differ
diff --git a/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/Russian-Both.png b/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/Russian-Both.png
new file mode 100644
index 0000000000000000000000000000000000000000..a3ddaf6d91c658cef3fbdd331dadac2b5060f397
Binary files /dev/null and b/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/Russian-Both.png differ
diff --git a/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/Spanish-Both.png b/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/Spanish-Both.png
new file mode 100644
index 0000000000000000000000000000000000000000..ab705fb2970001ee1ca05851f0631b8a500f62b9
Binary files /dev/null and b/Multilingual_CLIP/Model Cards/M-BERT Base 69/Images/Spanish-Both.png differ
diff --git a/Multilingual_CLIP/Model Cards/M-BERT Base 69/README.md b/Multilingual_CLIP/Model Cards/M-BERT Base 69/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..9ad3080d571fa1b9e789255e7eb0bdcbc7c94b81
--- /dev/null
+++ b/Multilingual_CLIP/Model Cards/M-BERT Base 69/README.md
@@ -0,0 +1,74 @@
+
+
M-BERT Base 69
+
+
+ Huggingface Model
+ ·
+ Huggingface Base Model
+
+
+
+## Usage
+To use this model along with the original CLIP vision encoder follow the [main page usage instructions](https://github.com/FreddeFrallan/Multilingual-CLIP) to download the additional linear weights.
+Once this is done, you can load and use the model with the following code
+```python
+from multilingual_clip import multilingual_clip
+
+model = multilingual_clip.load_model('M-BERT-Base-69')
+embeddings = model(['Älgen är skogens konung!', 'Wie leben Eisbären in der Antarktis?', 'Вы знали, что все белые медведи левши?'])
+print(embeddings.shape)
+# Yields: torch.Size([3, 640])
+```
+
+
+## About
+A [bert-base-multilingual](https://huggingface.co/bert-base-multilingual-cased) tuned to match the embedding space for 69 languages, to the embedding space of the CLIP text encoder which accompanies the Res50x4 vision encoder. column represents the Softmax prediction over all the texts given the corresponding image. The images and matchings texts are ordered identically, hence a perfect solution would have 100 across the diagonal.
+
+#### French
+
+#### German
+
+#### Spanish
+
+#### Russian
+
+#### Swedish
+
+#### Greek
+
+#### Kannada
+Kannada was not included in the 40 fine-tuning languages, but included during language modelling pre-training
+
+
diff --git a/Multilingual_CLIP/Model Cards/Swe-CLIP 2M/README.md b/Multilingual_CLIP/Model Cards/Swe-CLIP 2M/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..a479887e8936d25467dde7dcfac0972c6252570d
--- /dev/null
+++ b/Multilingual_CLIP/Model Cards/Swe-CLIP 2M/README.md
@@ -0,0 +1,29 @@
+
+
Swe-CLIP 2M
+
+
+ Huggingface Model
+ ·
+ Huggingface Base Model
+
+
+
+## Usage
+To use this model along with the original CLIP vision encoder follow the [main page usage instructions](https://github.com/FreddeFrallan/Multilingual-CLIP) to download the additional linear weights.
+Once this is done, you can load and use the model with the following code
+```python
+from multilingual_clip import multilingual_clip
+
+model = multilingual_clip.load_model('Swe-CLIP-2M')
+embeddings = model(['Älgen är skogens konung!', 'Alla isbjörnar är vänsterhänta'])
+print(embeddings.shape)
+# Yields: torch.Size([2, 640])
+```
+
+
+## About
+A [KB/Bert-Swedish-Cased](https://huggingface.co/KB/bert-base-swedish-cased) tuned to match the embedding space of the CLIP text encoder which accompanies the Res50x4 vision encoder.
+
Swe-CLIP 500k
+
+
+ Huggingface Model
+ ·
+ Huggingface Base Model
+
+
+
+## Usage
+To use this model along with the original CLIP vision encoder follow the [main page usage instructions](https://github.com/FreddeFrallan/Multilingual-CLIP) to download the additional linear weights.
+Once this is done, you can load and use the model with the following code
+```python
+from multilingual_clip import multilingual_clip
+
+model = multilingual_clip.load_model('Swe-CLIP-500k')
+embeddings = model(['Älgen är skogens konung!', 'Alla isbjörnar är vänsterhänta'])
+print(embeddings.shape)
+# Yields: torch.Size([2, 640])
+```
+
+
+## About
+A [KB/Bert-Swedish-Cased](https://huggingface.co/KB/bert-base-swedish-cased) tuned to match the embedding space of the CLIP text encoder which accompanies the Res50x4 vision encoder. "
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "3xeGiNoVAq7t"
+ },
+ "source": [
+ "### Create Captions"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "ergScfHaAwbw"
+ },
+ "source": [
+ "russan_captions = [\n",
+ " 'Зеленое яблоко', 'Красное яблоко', 'Фиолетовое яблоко', 'Апельсиновое яблоко', 'Миска с фруктами', 'Гроздь бананов свисает с дерева' \n",
+ "]\n",
+ "\n",
+ "french_captions = [\n",
+ " 'Une pomme verte', 'Une pomme rouge', 'Une pomme violette', 'Une pomme orange', 'Un bol rempli de fruits', 'Un tas de bananes pendu à un arbre' \n",
+ "]\n",
+ "\n",
+ "german_captions = [\n",
+ " 'Ein grüner Apfel', 'Ein roter Apfel', 'Ein lila Apfel', 'Ein orangefarbener Apfel', 'Eine Schüssel voller Früchte', 'Ein Bündel Bananen hängt an einem Baum' \n",
+ "]\n",
+ "\n",
+ "spanish_captions = [\n",
+ " 'Una manzana verde', 'Una manzana roja', 'Una manzana de color lila', 'Una manzana de color naranja', 'Un frutero lleno de fruta', 'Un racimo de bananas colgados de un banano',\n",
+ "]\n",
+ "\n",
+ "greek_captions = [\n",
+ " 'Ένα πράσινο μήλο', 'Ένα κόκκινο μήλο', 'Ένα μοβ μήλο', 'Ένα πορτοκαλί μήλο', 'Ένα μπολ γεμάτο με φρούτα', 'Ένα τσαμπί μπανάνες κρεμάμενες από ένα δέντρο',\n",
+ "]\n",
+ "\n",
+ "swedish_captions = [\n",
+ " 'Ett grönt äpple', 'Ett rött äpple', 'Ett lila äpple', 'Ett oranget äpple', 'En skål fylld med frukt', 'En klase bananer som hänger från ett träd' \n",
+ "]\n",
+ "\n",
+ "all_captions = {'Russian': russan_captions, 'French': french_captions, 'German': german_captions,\n",
+ " 'Spanish': spanish_captions, 'Greek': greek_captions, 'Swedish': swedish_captions\n",
+ " }"
+ ],
+ "execution_count": 16,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "AleQ_9u5r_FN"
+ },
+ "source": [
+ "### Prepare Images for CLIP"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "PDvfAOlOruTq"
+ },
+ "source": [
+ "img_input = torch.stack([compose(img).to('cpu') for img in images.values()])"
+ ],
+ "execution_count": 17,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "kAHNhOG5DJNc"
+ },
+ "source": [
+ "### Generate Text & Vision Embeddings"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "jh4CEXWKGRJD"
+ },
+ "source": [
+ "with torch.no_grad():\n",
+ " image_embs = clip_model.encode_image(img_input).float().to('cpu')\n",
+ "\n",
+ " language_embs = {}\n",
+ " for lang, captions in all_captions.items():\n",
+ " language_embs[lang] = text_model(captions)\n",
+ "\n",
+ "print(\"CLIP-Vision: {}\".format(image_embs.shape))\n",
+ "for lang, embs in language_embs.items():\n",
+ " print(\"{}: {}\".format(lang, embs.shape))"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "nN2d9mJoFoso"
+ },
+ "source": [
+ "### Compare Predictions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "pvcy1M27G4td"
+ },
+ "source": [
+ "Compare the Cosine-Similarities between the image embeddings and the different language embeddings."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "QjF_zccgGcTF"
+ },
+ "source": [
+ "def compare_embeddings(logit_scale, img_embs, txt_embs):\n",
+ " # normalized features\n",
+ " image_features = img_embs / img_embs.norm(dim=-1, keepdim=True)\n",
+ " text_features = txt_embs / txt_embs.norm(dim=-1, keepdim=True)\n",
+ "\n",
+ " # cosine similarity as logits\n",
+ " logits_per_image = logit_scale * image_features @ text_features.t()\n",
+ " logits_per_text = logit_scale * text_features @ image_features.t()\n",
+ "\n",
+ " # shape = [global_batch_size, global_batch_size]\n",
+ " return logits_per_image, logits_per_text\n",
+ "\n",
+ "# CLIP Temperature scaler\n",
+ "logit_scale = clip_model.logit_scale.exp().float().to('cpu')\n",
+ "\n",
+ "language_logits = {}\n",
+ "for lang, embs in language_embs.items():\n",
+ " language_logits[lang] = compare_embeddings(logit_scale, image_embs, embs)"
+ ],
+ "execution_count": 22,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "fXQ49XtJL1V1"
+ },
+ "source": [
+ "### Visualize Results"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "uNU1R2rkGrMD"
+ },
+ "source": [
+ "Here we will not visualize the results, so that every column is the Softmax distribution over all the texts for the respective image."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "CRap5vgT57nt",
+ "outputId": "d4526146-17e8-4a58-c7eb-586e8cde8b2d",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000
+ }
+ },
+ "source": [
+ "def plot_heatmap(result_matrix):\n",
+ " height, width = result_matrix.shape\n",
+ " fig, ax = plt.subplots()\n",
+ " fig.set_size_inches(8,8)\n",
+ " im = ax.imshow(result_matrix)\n",
+ "\n",
+ "\n",
+ "\n",
+ " # Create X & Y Labels\n",
+ " ax.set_xticks(np.arange(width))\n",
+ " ax.set_yticks(np.arange(height))\n",
+ " ax.set_xticklabels([\"Image {}\".format(i) for i in range(width)])\n",
+ " ax.set_yticklabels([\"Text {}\".format(i) for i in range(height)])\n",
+ "\n",
+ " for i in range(height):\n",
+ " for j in range(width):\n",
+ " text = ax.text(j, i, result_matrix[i, j],\n",
+ " ha=\"center\", va=\"center\", color='grey', size=20)\n",
+ "\n",
+ " fig.tight_layout()\n",
+ " plt.show()\n",
+ "\n",
+ "for lang, (img_logits, txt_logits) in language_logits.items():\n",
+ " # Convert Logits into Softmax predictions\n",
+ " probs = img_logits.softmax(dim=-1).cpu().detach().numpy()\n",
+ "\n",
+ " # Transpose so that each column is the softmax for each picture over the texts\n",
+ " probs = np.around(probs, decimals=2).T * 100\n",
+ "\n",
+ " print(\"Language: {}\".format(lang))\n",
+ " plot_heatmap(probs)"
+ ],
+ "execution_count": 54,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "text": [
+ "Language: Russian\n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Language: French\n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Language: German\n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Language: Spanish\n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Language: Greek\n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Language: Swedish\n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "w3yGhGEvFh7v"
+ },
+ "source": [
+ "## Conclusion\n",
+ "Although the diagonal is not completely maxed out, all languages managed to correctly classify all images. Interestingly, all languages had an easier time classifying the purple apple which was photoshopped than the red apple."
+ ]
+ }
+ ]
+}
diff --git a/Multilingual_CLIP/README.md b/Multilingual_CLIP/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b906dd3fe17d029f55f0bae2c73035d9415f8089
--- /dev/null
+++ b/Multilingual_CLIP/README.md
@@ -0,0 +1,236 @@
+
+
Multilingual-CLIP
+ OpenAI CLIP text encoders for any language
+
+
+ Live Demo
+ ·
+ Pre-trained Models
+ ·
+ Report Bug
+
+
+
+[](https://colab.research.google.com/github/FreddeFrallan/Multilingual-CLIP/blob/master/Multilingual_CLIP.ipynb)
+[](https://pypi.python.org/pypi/multilingual-clip)
+
+
+
+## Overview
+
+
+[OpenAI](https://openai.com/) recently released the paper [Learning Transferable Visual Models From Natural Language Supervision](https://arxiv.org/abs/2103.00020) in which they present the CLIP (Contrastive Language–Image Pre-training) model. This model is trained to connect text and images, by matching their corresponding vector representations using a contrastive learning objective.
+CLIP consists of two separate models, a visual encoder and a text encoder. These were trained on a wooping 400 Million images and corresponding captions.
+OpenAI has since released a set of their smaller CLIP models, which can be found on the [official CLIP Github](https://github.com/openai/CLIP).
+
+## Demo
+A live demonstration of multilingual Text-Image retrieval using M-CLIP can be found [here!](https://rom1504.github.io/clip-retrieval/?back=https%3A%2F%2Fknn5.laion.ai&index=laion_400m&useMclip=true) This demo was created by [Rom1504](https://github.com/rom1504), and it allows you to search the LAION-400M dataset in various languages using M-CLIP.
+
+#### This repository contains
+* Pre-trained CLIP-Text encoders for multiple languages
+* Pytorch & Tensorflow inference code
+* Tensorflow training code
+
+### Requirements
+While it is possible that other versions works equally fine, we have worked with the following:
+
+* Python = 3.6.9
+* Transformers = 4.8.1
+
+## Install
+
+`pip install multilingual-clip torch`
+
+You can also choose to `pip install tensorflow` instead of torch.
+
+
+## Inference Usage
+
+Inference code for Tensorflow is also available in [inference_example.py](https://github.com/FreddeFrallan/Multilingual-CLIP/blob/main/inference_example.py)
+
+```python
+from multilingual_clip import pt_multilingual_clip
+import transformers
+
+texts = [
+ 'Three blind horses listening to Mozart.',
+ 'Älgen är skogens konung!',
+ 'Wie leben Eisbären in der Antarktis?',
+ 'Вы знали, что все белые медведи левши?'
+]
+model_name = 'M-CLIP/XLM-Roberta-Large-Vit-L-14'
+
+# Load Model & Tokenizer
+model = pt_multilingual_clip.MultilingualCLIP.from_pretrained(model_name)
+tokenizer = transformers.AutoTokenizer.from_pretrained(model_name)
+
+embeddings = model.forward(texts, tokenizer)
+print(embeddings.shape)
+```
+
+## Install for development
+
+Setup a virtualenv:
+
+```
+python3 -m venv .env
+source .env/bin/activate
+pip install -e .
+```
+
+## Pre-trained Models
+Every text encoder is a [Huggingface](https://huggingface.co/) available transformer, with an additional linear layer on top. For more information of a specific model, click the Model Name to see its model card.
+Txt2Img @10-Recal for the humanly tanslated [MS-COCO testset](https://arxiv.org/abs/2109.07622).
+
+| Name | En | De | Es | Fr | Zh | It | Pl | Ko | Ru | Tr | Jp |
+| ----------------------------------|:-----: |:-----: |:-----: |:-----: | :-----: |:-----: |:-----: |:-----: |:-----: |:-----: |:-----: |
+| [OpenAI CLIP Vit-B/32](https://github.com/openai/CLIP)| 90.3 | - | - | - | - | - | - | - | - | - | - |
+| [OpenAI CLIP Vit-L/14](https://github.com/openai/CLIP)| 91.8 | - | - | - | - | - | - | - | - | - | - |
+| [OpenCLIP ViT-B-16+-](https://github.com/openai/CLIP)| 94.3 | - | - | - | - | - | - | - | - | - | - |
+| [LABSE Vit-L/14](https://huggingface.co/M-CLIP/LABSE-Vit-L-14)| 91.6 | 89.6 | 89.5 | 89.9 | 88.9 | 90.1 | 89.8 | 80.8 | 85.5 | 89.8 | 73.9 |
+| [XLM-R Large Vit-B/32](https://huggingface.co/M-CLIP/XLM-Roberta-Large-Vit-B-32)| 91.8 | 88.7 | 89.1 | 89.4 | 89.3 | 89.8| 91.4 | 82.1 | 86.1 | 88.8 | 81.0 |
+| [XLM-R Vit-L/14](https://huggingface.co/M-CLIP/XLM-Roberta-Large-Vit-L-14)| 92.4 | 90.6 | 91.0 | 90.0 | 89.7 | 91.1 | 91.3 | 85.2 | 85.8 | 90.3 | 81.9 |
+| [XLM-R Large Vit-B/16+](https://huggingface.co/M-CLIP/XLM-Roberta-Large-Vit-B-16Plus)| 95.0 | 93.0 | 93.6 | 93.1 | 94.0 | 93.1 | 94.4 | 89.0 | 90.0 | 93.0 | 84.2 |
+
+The training curves for these models are available at this [Weights and Biases Report](https://wandb.ai/freddefrallan/M-CLIP/reports/M-CLIP-2-6-2022--VmlldzoyMTE1MjU1/edit?firstReport&runsetFilter), the results for other non-succesfull and ongoing experiments can be found in the [Weights and Biases Project](https://wandb.ai/freddefrallan/M-CLIP?workspace=user-freddefrallan).
+
+## Legacy Usage and Models
+Older versions of M-CLIP had the linear weights stored separately from Huggingface. Whilst the new models have them directly incorporated in the Huggingface repository. More information about these older models can be found in this section.
+
+
+ Click for more information
+
+##### Download CLIP Model
+```bash
+$ conda install --yes -c pytorch pytorch=1.7.1 torchvision cudatoolkit=11.0
+$ pip install ftfy regex tqdm
+$ pip install git+https://github.com/openai/CLIP.git
+```
+Replace `cudatoolkit=11.0` above with the appropriate CUDA version on your machine or `cpuonly` when installing on a machine without a GPU.
+For more information please see the official [CLIP repostitory](https://github.com/openai/CLIP).
+##### Download Linear Weights
+```bash
+# Linear Model Weights
+$ bash legacy_get-weights.sh
+```
+
+### Inference
+```python
+from multilingual_clip import multilingual_clip
+
+print(multilingual_clip.AVAILABLE_MODELS.keys())
+
+model = multilingual_clip.load_model('M-BERT-Distil-40')
+
+embeddings = model(['Älgen är skogens konung!', 'Wie leben Eisbären in der Antarktis?', 'Вы знали, что все белые медведи левши?'])
+print(embeddings.shape)
+# Yields: torch.Size([3, 640])
+```
+
+
+
+For a more elaborate example, comparing the textual embeddings to the CLIP image embeddings see this [colab notebook](https://colab.research.google.com/github/FreddeFrallan/Multilingual-CLIP/blob/master/Multilingual_CLIP.ipynb).
+
+
+## Legacy Pre-trained Models
+Every text encoder is a [Huggingface](https://huggingface.co/) available transformer, with an additional linear layer on top. Neither of the models have been extensively tested, but for more information and qualitative test results for a specific model, click the Model Name to see its model card.
+*** Make sure to update to the most recent version of the repostitory when downloading a new model, and re-run the shell script to download the Linear Weights. ***
+
+
+| Name |Model Base|Vision Model | Pre-trained Languages | Target Languages | #Parameters|
+| ----------------------------------|:-----: |:-----: |:-----: |:-----: |:-----: |
+|**Multilingual** ||
+| [M-BERT Distil 40](https://github.com/FreddeFrallan/Multilingual-CLIP/tree/main/Model%20Cards/M-BERT%20Distil%2040) | [M-BERT Distil](https://huggingface.co/bert-base-multilingual-uncased)| RN50x4 | [101 Languages](https://github.com/google-research/bert/blob/master/multilingual.md#list-of-languages) | [40 Languages](https://github.com/FreddeFrallan/Multilingual-CLIP/blob/main/Model%20Cards/M-BERT%20Distil%2040/Fine-Tune-Languages.md) | 66 M|
+| [M-BERT Base 69](https://github.com/FreddeFrallan/Multilingual-CLIP/tree/main/Model%20Cards/M-BERT%20Base%2069) | [M-BERT Base](https://huggingface.co/bert-base-multilingual-uncased)|RN50x4 | [101 Languages](https://github.com/google-research/bert/blob/master/multilingual.md#list-of-languages) | 68 Languages | 110 M|
+| [M-BERT Base ViT-B](https://github.com/FreddeFrallan/Multilingual-CLIP/tree/main/Model%20Cards/M-BERT%20Base%20ViT-B) | [M-BERT Base](https://huggingface.co/bert-base-multilingual-uncased)|ViT-B/32 | [101 Languages](https://github.com/google-research/bert/blob/master/multilingual.md#list-of-languages) | 68 Languages | 110 M|
+|**Monolingual** ||
+|[Swe-CLIP 500k](https://github.com/FreddeFrallan/Multilingual-CLIP/tree/main/Model%20Cards/Swe-CLIP%20500k)| [KB-BERT](https://huggingface.co/KB/bert-base-swedish-cased)| RN50x4 | Swedish | Swedish | 110 M|
+|[Swe-CLIP 2M](https://github.com/FreddeFrallan/Multilingual-CLIP/tree/main/Model%20Cards/Swe-CLIP%202M)| [KB-BERT](https://huggingface.co/KB/bert-base-swedish-cased)| RN50x4 | Swedish | Swedish | 110 M|
+
+
+
+## Training a new model
+[This folder](https://github.com/FreddeFrallan/Multilingual-CLIP/tree/main/multilingual_clip/TeacherLearning) contains the code used for training the above models. If you wsh to train your own model you must do the following things:
+
+* Prepare a set of translated sentence pairs from English -> Your Language(s)
+* Compute regular CLIP-Text embeddings for the English sentences.
+* Edit [Training.py](https://github.com/FreddeFrallan/Multilingual-CLIP/blob/main/multilingual_clip/TeacherLearning/Training.py) to load your data.
+* Train a new CLIP-Text encoder via Teacher Learning
+
+### Pre-computed CLIP Embeddings & Translaton Data
+[This Google Drive folder](https://drive.google.com/drive/folders/1I9a7naSZubUATWzLFv61DQMWyFlF7wR5?usp=sharing) contains both pre-computed CLIP-Text Embeddings for a large porton of the the image captions of [GCC](https://ai.google.com/research/ConceptualCaptions/) + [MSCOCO](https://cocodataset.org/#home) + [VizWiz](https://vizwiz.org/tasks-and-datasets/image-captioning/).
+
+The Google Drive folder also contains the translation data used to train the currently available models.
+Good Luck
+
+## Contribution
+If you have trained a CLIP Text encoder specific to your language, or another model covering a language not supported here, Please feel free to contact us and we will either upload your model and credit you, or simply link to your already uploaded model.
+
+
+## Contact
+If you have questions regarding the code or otherwise related to this Github page, please open an [issue](https://github.com/FreddeFrallan/Contrastive-Tension/issues).
+
+For other purposes, feel free to contact me directly at: Fredrik.Carlsson@ri.se
+
+
+## Acknowledgements
+* [Stability.ai](https://stability.ai/) for providing much appreciated compute during training.
+* [CLIP](https://openai.com/blog/clip/)
+* [OpenAI](https://openai.com/)
+* [Huggingface](https://huggingface.co/)
+* [Best Readme Template](https://github.com/othneildrew/Best-README-Template)
+* ["Two Cats" Image by pl1602](https://search.creativecommons.org/photos/8dfd802b-58e5-4cc5-889d-96abba540de1)
+
+
+## License
+Distributed under the MIT License. See `LICENSE` for more information.
+
+
+## Citing
+If you found this repository useful, please consider citing:
+
+```bibtex
+@InProceedings{carlsson-EtAl:2022:LREC,
+ author = {Carlsson, Fredrik and Eisen, Philipp and Rekathati, Faton and Sahlgren, Magnus},
+ title = {Cross-lingual and Multilingual CLIP},
+ booktitle = {Proceedings of the Language Resources and Evaluation Conference},
+ month = {June},
+ year = {2022},
+ address = {Marseille, France},
+ publisher = {European Language Resources Association},
+ pages = {6848--6854},
+ abstract = {The long-standing endeavor of relating the textual and the visual domain recently underwent a pivotal breakthrough, as OpenAI released CLIP. This model distinguishes how well an English text corresponds with a given image with unprecedented accuracy. Trained via a contrastive learning objective over a huge dataset of 400M of images and captions, it is a work that is not easily replicated, especially for low resource languages. Capitalizing on the modularization of the CLIP architecture, we propose to use cross-lingual teacher learning to re-train the textual encoder for various non-English languages. Our method requires no image data and relies entirely on machine translation which removes the need for data in the target language. We find that our method can efficiently train a new textual encoder with relatively low computational cost, whilst still outperforming previous baselines on multilingual image-text retrieval.},
+ url = {https://aclanthology.org/2022.lrec-1.739}
+}
+```
+
+
+
+
+[contributors-shield]: https://img.shields.io/github/contributors/othneildrew/Best-README-Template.svg?style=for-the-badge
+[contributors-url]: https://github.com/othneildrew/Best-README-Template/graphs/contributors
+[forks-shield]: https://img.shields.io/github/forks/othneildrew/Best-README-Template.svg?style=for-the-badge
+[forks-url]: https://github.com/othneildrew/Best-README-Template/network/members
+[stars-shield]: https://img.shields.io/github/stars/othneildrew/Best-README-Template.svg?style=for-the-badge
+[stars-url]: https://github.com/othneildrew/Best-README-Template/stargazers
+[issues-shield]: https://img.shields.io/github/issues/othneildrew/Best-README-Template.svg?style=for-the-badge
+[issues-url]: https://github.com/othneildrew/Best-README-Template/issues
+[license-shield]: https://img.shields.io/github/license/othneildrew/Best-README-Template.svg?style=for-the-badge
+[license-url]: https://github.com/othneildrew/Best-README-Template/blob/master/LICENSE.txt
+[linkedin-shield]: https://img.shields.io/badge/-LinkedIn-black.svg?style=for-the-badge&logo=linkedin&colorB=555
+[linkedin-url]: https://linkedin.com/in/othneildrew
+[product-screenshot]: images/screenshot.png
diff --git a/Multilingual_CLIP/inference_example.py b/Multilingual_CLIP/inference_example.py
new file mode 100644
index 0000000000000000000000000000000000000000..5b2b86382eac29abcf66145e2385f927762d0a9c
--- /dev/null
+++ b/Multilingual_CLIP/inference_example.py
@@ -0,0 +1,34 @@
+import transformers
+
+
+def tf_example(texts, model_name='M-CLIP/XLM-Roberta-Large-Vit-L-14'):
+ from multilingual_clip import tf_multilingual_clip
+
+ model = tf_multilingual_clip.MultiLingualCLIP.from_pretrained(model_name)
+ tokenizer = transformers.AutoTokenizer.from_pretrained(model_name)
+
+ inData = tokenizer.batch_encode_plus(texts, return_tensors='tf', padding=True)
+ embeddings = model(inData)
+ print(embeddings.shape)
+
+
+def pt_example(texts, model_name='M-CLIP/XLM-Roberta-Large-Vit-L-14'):
+ from multilingual_clip import pt_multilingual_clip
+
+ model = pt_multilingual_clip.MultilingualCLIP.from_pretrained(model_name)
+ tokenizer = transformers.AutoTokenizer.from_pretrained(model_name)
+
+ embeddings = model.forward(texts, tokenizer)
+ print(embeddings.shape)
+
+
+if __name__ == '__main__':
+ exampleTexts = [
+ 'Three blind horses listening to Mozart.',
+ 'Älgen är skogens konung!',
+ 'Wie leben Eisbären in der Antarktis?',
+ 'Вы знали, что все белые медведи левши?'
+ ]
+
+ # tf_example(exampleTexts)
+ pt_example(exampleTexts)
diff --git a/Multilingual_CLIP/larger_mclip.md b/Multilingual_CLIP/larger_mclip.md
new file mode 100644
index 0000000000000000000000000000000000000000..8e9ee0f7e44fd7fb443a5c13e4a0abbfcd287838
--- /dev/null
+++ b/Multilingual_CLIP/larger_mclip.md
@@ -0,0 +1,60 @@
+# Multilingual CLIP 2/6-2022
+
+## Overview
+Recently, OpenAI released some of their [bigger CLIP models](https://github.com/openai/CLIP/blob/main/model-card.md). Additionally, [OpenCLIP](https://github.com/mlfoundations/open_clip) is continuing to provide their large models, which have proven to match or even outperform the OpenAI models.
+
+Thanks to the compute provided by [Stability.ai](https://stability.ai/) and [laion.ai](https://laion.ai/), we are now happy to announce that we provide multilingual text encoders for these models!
+Along with:
+ - Updated Inference & Training Code
+ - The Corresponding Machine Translated Image Caption Dataset
+ - PyPi package installer
+
+ 95.0 | 93.0 | 93.6 | 93.1 | 94.0 | 93.1 | 94.4 | 89.0 | 90.0 | 93.0 | 84.2 |
+
+To our surprise, using M-CLIP with XLM-RoBerta Large outperforms the original English models for English. Exactly why this is the case reamins to be determined, and we plan to followup up with more extensive testing.
+
+The ViT-L/14 model is integrated into clip retrieval, you can test the retrieval capabilities of this multilingual encoder [there](https://rom1504.github.io/clip-retrieval/?useMclip=true&query=%E9%BB%84%E8%89%B2%E3%81%84%E7%8C%AB). This is a search over 5 billion of clip embeddings of laion5B dataset implemented with an efficient knn index.
+
+The training curves for these models can be found at the [Weights and Biases report](https://wandb.ai/freddefrallan/M-CLIP/reports/M-CLIP-2-6-2022--VmlldzoyMTE1MjU1/edit?firstReport&runsetFilter)
+
+## Training Data & Machine Translation
+English image captions were taken from the Vit-L filtered captions of the datasets: [CC3M+CC12M+SBU](https://github.com/salesforce/BLIP#pre-training-datasets-download), which are provided by the BLIP repository.
+
+From these 14 million captions we sampled 7 million captions, divided them into 48 equally sized buckets, and translated each bucket into one of the [48 target languages](https://github.com/FreddeFrallan/Multilingual-CLIP/blob/main/translation/data/fine_tune_languages.csv). This means that after translation we still end up with a total of 7 million captions. Where 7M/48 = 145,833 of them are in for example Dutch.
+The machine-translated captions are available at [Huggingface](https://huggingface.co/datasets/M-CLIP/ImageCaptions-7M-Translations).
+
+Each translation was performed with the corresponding Opus model. For more information see the [machine translation instructions](https://github.com/FreddeFrallan/Multilingual-CLIP/tree/main/translation).
+
+It should be noted that only translated captions were used during training. Meaning that none of the original English captions were included. This entails that all the English (and other languages not included in the 49 target languages) results are due to transfer learning.
+
+## Training Details
+All released models used in essence the same hyperparameters. These detail are available at [Weights and Biases project](https://wandb.ai/freddefrallan/M-CLIP?workspace=user-freddefrallan).
+
+Following is a short list of some of the shared hyperparameters:
+ - Batch size of 2048 samples.
+ - Adam Optimizer with a target learning rate of 10^-5, with a linear warmup schedule for 1k update steps.
+ - 5000 randomly sampled validation samples
+
+All models were allowed to train until the validation MSE loss had converged. For most models this took about 24 hours, using 8 Nvidia A-100 GPUs. No early stopping was performed in regard to the Image-Text retrieval tasks.
+
+## Additional Experiments
+In addition to the released models, we also performed some experiments that yielded negative or unsubstantial results. The training curves and specific settings for most of these additional experiments can be found at the [Weights and Biases project](https://wandb.ai/freddefrallan/M-CLIP?workspace=user-freddefrallan).
+
+Following is a summary of things we tried:
+
+- Optimizing the Cosine-Similarity instead of minimizing the mean-squared error: **No noticeable performance difference**.
+ - MBERT-BASE as encoder: **Worse performance than LaBSE**
+ - USE-CML: **Worse performance than LaBSE**
+ - Adding additional TanH layer to the XLM-R Large: **No substantial performance difference, although it achieved slightly faster learning at the start.**
+ - Using first *([CLS]?)* token as sentence embedding, instead of mean-pooling for XLM-R Large: **Significantly worse performance. *(Perhaps due to the lack of Next-Sentence Prediction task in the RoBerta pre-training?)***
diff --git a/Multilingual_CLIP/legacy_get-weights.sh b/Multilingual_CLIP/legacy_get-weights.sh
new file mode 100644
index 0000000000000000000000000000000000000000..ac6bb104eb079981774189dbe8f6e6bec29b1ff6
--- /dev/null
+++ b/Multilingual_CLIP/legacy_get-weights.sh
@@ -0,0 +1,20 @@
+#
+
+OUTPATH=$PWD/data/weights
+
+mkdir -p $OUTPATH
+
+URLSWECLIP=https://www.dropbox.com/s/s77xw5308jeljlp/Swedish-500k%20Linear%20Weights.pkl
+wget -c "${URLSWECLIP}" -P $OUTPATH
+
+URLSWECLIP2M=https://www.dropbox.com/s/82c54rsvlry3kwh/Swedish-2M%20Linear%20Weights.pkl
+wget -c "${URLSWECLIP2M}" -P $OUTPATH
+
+URLMCLIP=https://www.dropbox.com/s/oihqzctnty5e9kk/M-BERT%20Distil%2040%20Linear%20Weights.pkl
+wget -c "${URLMCLIP}" -P $OUTPATH
+
+URLMCLIPBASE=https://www.dropbox.com/s/y4pycinv0eapeb3/M-BERT-Base-69%20Linear%20Weights.pkl
+wget -c "${URLMCLIPBASE}" -P $OUTPATH
+
+URLMCLIPBASEVIT=https://www.dropbox.com/s/2oxu7hw0y9fwdqs/M-BERT-Base-69-ViT%20Linear%20Weights.pkl
+wget -c "${URLMCLIPBASEVIT}" -P $OUTPATH
diff --git a/Multilingual_CLIP/legacy_inference.py b/Multilingual_CLIP/legacy_inference.py
new file mode 100644
index 0000000000000000000000000000000000000000..3735b44bf1203ef9d1f83fe2d7845c2cdd3500b0
--- /dev/null
+++ b/Multilingual_CLIP/legacy_inference.py
@@ -0,0 +1,13 @@
+from multilingual_clip.legacy_multilingual_clip import MultilingualClip
+
+model_path = 'M-CLIP/Swedish-500k'
+tok_path = 'M-CLIP/Swedish-500k'
+head_weight_path = 'data/weights/Swe-CLIP Linear Weights.pkl'
+
+sweclip_args = {'model_name': model_path,
+ 'tokenizer_name': tok_path,
+ 'head_path': head_weight_path}
+
+sweclip = MultilingualClip(**sweclip_args)
+
+print(sweclip('test'))
\ No newline at end of file
diff --git a/Multilingual_CLIP/multilingual_clip/Config_MCLIP.py b/Multilingual_CLIP/multilingual_clip/Config_MCLIP.py
new file mode 100644
index 0000000000000000000000000000000000000000..88807e2db5809de257a1eaa17cef3f801f8e0fd5
--- /dev/null
+++ b/Multilingual_CLIP/multilingual_clip/Config_MCLIP.py
@@ -0,0 +1,11 @@
+import transformers
+
+
+class MCLIPConfig(transformers.PretrainedConfig):
+ model_type = "M-CLIP"
+
+ def __init__(self, modelBase='xlm-roberta-large', transformerDimSize=1024, imageDimSize=768, **kwargs):
+ self.transformerDimensions = transformerDimSize
+ self.numDims = imageDimSize
+ self.modelBase = modelBase
+ super().__init__(**kwargs)
diff --git a/Multilingual_CLIP/multilingual_clip/TeacherLearning/ConvertTrainingModelToPT.py b/Multilingual_CLIP/multilingual_clip/TeacherLearning/ConvertTrainingModelToPT.py
new file mode 100644
index 0000000000000000000000000000000000000000..d5f77ceddc09f82118476819b3c4000e79b1fe17
--- /dev/null
+++ b/Multilingual_CLIP/multilingual_clip/TeacherLearning/ConvertTrainingModelToPT.py
@@ -0,0 +1,39 @@
+import TrainingModel
+import transformers
+import pickle
+
+
+def convertTFTransformerToPT(saveNameBase):
+ ptFormer = transformers.AutoModel.from_pretrained(saveNameBase + '-Transformer', from_tf=True)
+ ptFormer.save_pretrained(saveNameBase + '-Transformer' + "-PT")
+
+ with open('{}-Linear-Weights.pkl'.format(saveNameBase), 'rb') as fp:
+ weights = pickle.load(fp)
+ # TODO Add code for converting the linear weights into a torch linear layer
+
+
+def splitAndStoreTFModelToDisk(transformerBase, weightsPath, visualDimensionSpace, saveNameBase):
+ # Splits the Sentence Transformer and its linear layer
+ # The Transformer can then be loaded into PT, and the linear weights can be added as a linear layer
+
+ tokenizer = transformers.AutoTokenizer.from_pretrained(transformerBase)
+ model = TrainingModel.SentenceModelWithLinearTransformation(transformerBase, visualDimensionSpace)
+ model.load_weights(weightsPath).expect_partial()
+
+ tokenizer.save_pretrained(saveNameBase + '-Tokenizer')
+ model.transformer.save_pretrained(saveNameBase + '-Transformer')
+ linearWeights = model.postTransformation.get_weights()
+ print("Saving Linear Weights into pickle file.", linearWeights.shape)
+
+ with open('{}-Linear-Weights.pkl'.format(saveNameBase), 'wb') as fp:
+ pickle.dump(linearWeights, fp)
+
+
+if __name__ == '__main__':
+ weightsPath = 'XLM-Large-Sentence-VitB-16Plus-1652563598.5977607-135.weights'
+ transformerBase = 'xlm-roberta-large'
+ modelSaveBase = 'XLM-Large-VitB-16+'
+ visualDimensionSpace = 640
+
+ splitAndStoreTFModelToDisk(transformerBase, weightsPath, visualDimensionSpace, modelSaveBase)
+ # convertTFTransformerToPT(modelSaveBase + "-Transformer")
diff --git a/Multilingual_CLIP/multilingual_clip/TeacherLearning/Dataset.py b/Multilingual_CLIP/multilingual_clip/TeacherLearning/Dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..87d8e7e3913b016f0224daeb45bebacf3cecd6c0
--- /dev/null
+++ b/Multilingual_CLIP/multilingual_clip/TeacherLearning/Dataset.py
@@ -0,0 +1,59 @@
+import tensorflow as tf
+
+
+def createDataset(targetCaptions, embeddings, batchSize, tokenizer, maxSeqLen=32, loopForever=True,
+ shuffleSize=None, encoderDims=(1, 768)):
+ def generatorFunc():
+ while True:
+ embeddings.shuffle()
+ for d in embeddings:
+ key, textEmb = d['id'], d['embedding']
+ try:
+ caption = targetCaptions[key]['caption_multi']
+ if (caption is None):
+ continue
+
+ textIds = tokenizer.encode(caption)
+ seqLen = len(textIds)
+ if (seqLen > maxSeqLen):
+ continue
+
+ padSize = maxSeqLen - len(textIds)
+ textIds = textIds + [0] * padSize
+ attMask = [1] * seqLen + [0] * padSize
+ yield textIds, attMask, textEmb
+ except:
+ pass
+
+ if (loopForever == False):
+ break
+
+ f = lambda x, y=tf.float32: tf.convert_to_tensor(x, y)
+
+ def _parse_function(textIds, attMask, textEmb):
+ textIDs, att = f(textIds, tf.int32), f(attMask)
+ tEmb = f(textEmb)
+ return (textIDs, att), tEmb[0]
+
+ dataset = tf.data.Dataset.from_generator(generatorFunc,
+ output_types=(
+ tf.int32, tf.float32, tf.float32),
+ output_shapes=(
+ (maxSeqLen,), (maxSeqLen,), encoderDims),
+ )
+
+ if (shuffleSize is not None):
+ dataset = dataset.shuffle(shuffleSize)
+ dataset = dataset.map(_parse_function).batch(batchSize)
+
+ return dataset
+
+
+def createTrainingAndValidationDataset(trainEmbeddings, valEmbeddings, batchSize, tokenizer, targetCaptions,
+ maxSeqLen=32, encoderDims=(1, 768)):
+ valDataset = createDataset(targetCaptions, valEmbeddings, batchSize, tokenizer,
+ loopForever=False, maxSeqLen=maxSeqLen, encoderDims=encoderDims)
+ trainDataset = createDataset(targetCaptions, trainEmbeddings, batchSize, tokenizer,
+ loopForever=True, maxSeqLen=maxSeqLen, encoderDims=encoderDims)
+
+ return trainDataset, valDataset
diff --git a/Multilingual_CLIP/multilingual_clip/TeacherLearning/Training.py b/Multilingual_CLIP/multilingual_clip/TeacherLearning/Training.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b68876327fdd94122d402a6f713d2a2144bc36f
--- /dev/null
+++ b/Multilingual_CLIP/multilingual_clip/TeacherLearning/Training.py
@@ -0,0 +1,70 @@
+import Dataset, TrainingModel
+import tensorflow as tf
+import transformers
+import datasets
+import Utils
+
+
+def loadTextTranslations():
+ return datasets.load_dataset('M-CLIP/ImageCaptions-7M-Translations')['train']
+
+
+def loadTargetEmbeddings(imageBase="Vit-B-32", validationSize=5000):
+ trainSamples = datasets.load_dataset('M-CLIP/ImageCaptions-7M-Embeddings', imageBase,
+ split='train[{}:]'.format(validationSize))
+ valSamples = datasets.load_dataset('M-CLIP/ImageCaptions-7M-Embeddings', imageBase,
+ split='train[:{}]'.format(validationSize))
+
+ embeddingShape = tf.convert_to_tensor(trainSamples[0]['embedding']).shape
+ return trainSamples, valSamples, embeddingShape
+
+
+def singleGPUTraining():
+ numValidationSamples = 5000
+ stepsPerEpoch, lr = 1000, 0.00001
+ gradAccumSteps, batchSize = 1, 256
+ numTrainSteps, numWarmupSteps = 99999999, 1000
+
+ modelBase = 'xlm-roberta-large'
+ tokenizerBase = 'xlm-roberta-large'
+ imageBase = "Vit-B-32"
+ modelName = '{}-{}'.format(modelBase, imageBase)
+
+ startWeights = None
+ targetCaptions = loadTextTranslations()
+ trainEmbeddings, valEmbeddings, imageEncoderDimensions = loadTargetEmbeddings(validationSize=numValidationSamples)
+
+ def createOptimizerFunc():
+ optimizer, schedule = transformers.optimization_tf.create_optimizer(lr, numTrainSteps, numWarmupSteps)
+ if (gradAccumSteps <= 1):
+ return optimizer
+ else:
+ return Utils.GradientAccumulator(optimizer, gradAccumSteps)
+
+ tokenizer = transformers.AutoTokenizer.from_pretrained(tokenizerBase)
+ model = TrainingModel.SentenceModelWithLinearTransformation(modelBase, imageEncoderDimensions[-1])
+
+ if (startWeights is not None):
+ model.load_weights(startWeights)
+ model.compile(createOptimizerFunc(), 'mse', metrics=['mae', 'cosine_similarity'])
+
+ trainDataset, valDataset = Dataset.createTrainingAndValidationDataset(trainEmbeddings, valEmbeddings, batchSize,
+ tokenizer,
+ targetCaptions=targetCaptions,
+ encoderDims=imageEncoderDimensions)
+
+ if (gradAccumSteps > 1): # In order to make fair logging on Wandb
+ stepsPerEpoch *= gradAccumSteps
+
+ model.fit(trainDataset, epochs=1000, steps_per_epoch=stepsPerEpoch,
+ validation_data=valDataset,
+ callbacks=[
+ Utils.CustomSaveCallBack(modelName, saveInterval=5, firstSavePoint=5),
+ ]
+ )
+
+
+if __name__ == '__main__':
+ strategy = tf.distribute.MirroredStrategy()
+ with strategy.scope():
+ singleGPUTraining()
\ No newline at end of file
diff --git a/Multilingual_CLIP/multilingual_clip/TeacherLearning/TrainingModel.py b/Multilingual_CLIP/multilingual_clip/TeacherLearning/TrainingModel.py
new file mode 100644
index 0000000000000000000000000000000000000000..400788cfd45c7776f20f9b38601fdf435c819c0b
--- /dev/null
+++ b/Multilingual_CLIP/multilingual_clip/TeacherLearning/TrainingModel.py
@@ -0,0 +1,66 @@
+import tensorflow as tf
+import transformers
+
+
+class SentenceModel(tf.keras.Model):
+
+ def __init__(self, modelBase, from_pt=True, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.transformer = transformers.TFAutoModel.from_pretrained(modelBase, from_pt=from_pt)
+
+ @tf.function
+ def generateSingleEmbedding(self, input, training=False):
+ inds, att = input
+ embs = self.transformer({'input_ids': inds, 'attention_mask': att}, training=training)[0]
+ outAtt = tf.cast(att, tf.float32)
+ sampleLength = tf.reduce_sum(outAtt, axis=-1, keepdims=True)
+ maskedEmbs = embs * tf.expand_dims(outAtt, axis=-1)
+ return tf.reduce_sum(maskedEmbs, axis=1) / tf.cast(sampleLength, tf.float32)
+
+ @tf.function
+ def generateMultipleEmbeddings(self, input, training=False):
+ inds, att = input
+ embs = self.transformer({'input_ids': inds, 'attention_mask': att}, training=training)['last_hidden_state']
+ print("Embs:", embs.shape)
+
+ outAtt = tf.cast(att, tf.float32)
+ sampleLength = tf.reduce_sum(outAtt, axis=-1, keepdims=True)
+ print("Att mask:", tf.expand_dims(outAtt, axis=-1).shape)
+ maskedEmbs = embs * tf.expand_dims(outAtt, axis=-1)
+ return tf.reduce_sum(maskedEmbs, axis=1) / tf.cast(sampleLength, tf.float32)
+
+ @tf.function
+ def call(self, inputs, training=False, mask=None):
+ return self.generateSingleEmbedding(inputs, training)
+
+ def save_pretrained(self, saveName):
+ self.transformer.save_pretrained(saveName)
+
+ def from_pretrained(self, saveName):
+ self.transformer = transformers.TFAutoModel.from_pretrained(saveName)
+
+
+class SentenceModelWithLinearTransformation(SentenceModel):
+
+ def __init__(self, modelBase, embeddingSize=640, *args, **kwargs):
+ super().__init__(modelBase, *args, **kwargs)
+ self.postTransformation = tf.keras.layers.Dense(embeddingSize, activation='linear')
+
+ @tf.function
+ def call(self, inputs, training=False, mask=None):
+ return self.postTransformation(self.generateMultipleEmbeddings(inputs, training))
+
+
+class SentenceModelWithTanHTransformation(SentenceModel):
+
+ def __init__(self, modelBase, embeddingSize=640, *args, **kwargs):
+ super().__init__(modelBase, *args, **kwargs)
+
+ self.postTransformation = tf.keras.layers.Dense(embeddingSize, activation='tanh')
+ self.postTransformation2 = tf.keras.layers.Dense(embeddingSize, activation='linear')
+
+ @tf.function
+ def call(self, inputs, training=False, mask=None):
+ meanEmbedding = self.generateSingleEmbedding(inputs, training)
+ d1 = self.postTransformation(meanEmbedding)
+ return self.postTransformation2(d1)
diff --git a/Multilingual_CLIP/multilingual_clip/TeacherLearning/Utils.py b/Multilingual_CLIP/multilingual_clip/TeacherLearning/Utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..434c3ea0a91693ddaa4ac412de0ca86095255c93
--- /dev/null
+++ b/Multilingual_CLIP/multilingual_clip/TeacherLearning/Utils.py
@@ -0,0 +1,278 @@
+from tensorflow_addons.utils import types
+from typeguard import typechecked
+import tensorflow as tf
+import numpy as np
+import pickle
+
+def splitListIntoChunks(data, numChunks):
+ chunkSize = int(len(data) / numChunks)
+ chunks = []
+ for i in range(numChunks - 1):
+ start, end = i * chunkSize, (i + 1) * chunkSize
+ chunks.append(data[start:end])
+
+ chunks.append(data[end:])
+ return chunks
+
+
+def splitIntoValueChunks(data, numChunks, getValueFunc):
+ values = [getValueFunc(d) for d in data]
+ minValue, maxValue = np.min(values), np.max(values)
+ chunkSize = (maxValue - minValue) / float(numChunks)
+
+ data.sort(key=lambda x: getValueFunc(x))
+ sizeCeil = minValue + chunkSize
+ chunks, currentChunkIndex = [[]], 0
+ for d in data:
+ v = getValueFunc(d)
+ while (v > sizeCeil):
+ chunks.append([])
+ sizeCeil += chunkSize
+ currentChunkIndex += 1
+ chunks[currentChunkIndex].append(d)
+
+ return chunks
+
+
+def startGraphLogging():
+ from datetime import datetime
+ stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+ logdir = 'logs/func/%s' % stamp
+ writer = tf.summary.create_file_writer(logdir)
+ tf.summary.trace_on(graph=True, profiler=True)
+ return writer, logdir
+
+
+def finishGraphLogging(writer, logdir):
+ with writer.as_default():
+ tf.summary.trace_export(
+ name="my_func_trace",
+ step=0,
+ profiler_outdir=logdir)
+
+
+class CustomSaveCallBack(tf.keras.callbacks.Callback):
+
+ def __init__(self, saveName, saveInterval=10, firstSavePoint=-1):
+ super().__init__()
+ self.saveName = saveName
+ self.saveInterval = saveInterval
+ self.firstSavePoint = saveInterval if firstSavePoint < 0 else firstSavePoint
+ self.saveCounter = 0
+
+ def on_epoch_end(self, epoch, logs=None):
+ if (epoch + 1 >= self.firstSavePoint):
+ if (self.saveCounter % self.saveInterval == 0):
+ print("Saving model!")
+ self.model.save_weights(self.saveName.format(epoch + 1))
+
+ self.saveCounter += 1
+
+
+def saveTokenizer(base='gpt2', dumpPath='GPT2-Tokenizer.pkl'):
+ import transformers
+ tokenizer = transformers.AutoTokenizer.from_pretrained(base)
+ with open(dumpPath, 'wb') as fp:
+ pickle.dump(tokenizer, fp)
+
+
+def loadTokenizer(dumpPath='GPT2-Tokenizer.pkl'):
+ with open(dumpPath, 'rb') as fp:
+ return pickle.load(fp)
+
+
+class GradientAccumulator(tf.keras.optimizers.Optimizer):
+ """Optimizer wrapper for gradient accumulation."""
+
+ @typechecked
+ def __init__(
+ self,
+ inner_optimizer: types.Optimizer,
+ accum_steps: types.TensorLike = 4,
+ name: str = "GradientAccumulator",
+ **kwargs,
+ ):
+ r"""Construct a new GradientAccumulator optimizer.
+ Args:
+ inner_optimizer: str or `tf.keras.optimizers.Optimizer` that will be
+ used to compute and apply gradients.
+ accum_steps: int > 0. Update gradient in every accumulation steps.
+ name: Optional name for the operations created when applying
+ gradients. Defaults to "GradientAccumulator".
+ **kwargs: keyword arguments. Allowed to be {`clipnorm`,
+ `clipvalue`, `lr`, `decay`}. `clipnorm` is clip gradients by
+ norm; `clipvalue` is clip gradients by value, `decay` is
+ included for backward compatibility to allow time inverse
+ decay of learning rate. `lr` is included for backward
+ compatibility, recommended to use `learning_rate` instead.
+ """
+ super().__init__(name, **kwargs)
+ self._optimizer = tf.keras.optimizers.get(inner_optimizer)
+ self._gradients = []
+ self._accum_steps = accum_steps
+ self._step = None
+ self._iterations = self._optimizer.iterations
+
+ def _create_slots(self, var_list):
+ self._optimizer._create_slots(var_list=var_list)
+ for var in var_list:
+ self.add_slot(var, "ga")
+
+ self._gradients = [self.get_slot(var, "ga") for var in var_list]
+
+ @property
+ def step(self):
+ """Variable. The number of training steps this Optimizer has run."""
+ if self._step is None:
+ with self._distribution_strategy_scope():
+ self._step = self.add_weight(
+ "iter",
+ shape=[],
+ initializer="ones",
+ dtype=tf.int64,
+ trainable=False,
+ aggregation=tf.VariableAggregation.ONLY_FIRST_REPLICA,
+ )
+ self._weights.append(self._step)
+ return self._step
+
+ @step.setter
+ def step(self, variable):
+ if self._step is not None:
+ raise RuntimeError(
+ "Cannot set `step` to a new Variable after "
+ "the Optimizer weights have been created"
+ )
+ self._step = variable
+ self._weights.append(self._step)
+
+ @property
+ def gradients(self):
+ """The accumulated gradients on the current replica."""
+ if not self._gradients:
+ raise ValueError(
+ "The accumulator should be called first to initialize the gradients"
+ )
+ return list(
+ gradient.read_value() if gradient is not None else gradient
+ for gradient in self._gradients
+ )
+
+ def apply_gradients(self, grads_and_vars, name=None, **kwargs):
+ train_op = super().apply_gradients(grads_and_vars, name, **kwargs)
+ with tf.control_dependencies([train_op]):
+ with tf.control_dependencies(
+ [
+ self._optimizer.iterations.assign_add(
+ tf.cast(
+ tf.where(self.step % self._accum_steps == 0, 1, 0), tf.int64
+ ),
+ read_value=False,
+ )
+ ]
+ ):
+ return self.step.assign_add(1, read_value=False)
+
+ def _resource_apply_dense(self, grad, var, apply_state=None):
+ accum_gradient = self.get_slot(var, "ga")
+ if accum_gradient is not None and grad is not None:
+ accum_gradient.assign_add(
+ grad, use_locking=self._use_locking, read_value=False
+ )
+
+ return self._apply_grad(accum_gradient, var, apply_state)
+
+ def _resource_apply_sparse(self, grad: types.TensorLike, var, indices, apply_state):
+ accum_gradient = self.get_slot(var, "ga")
+ if accum_gradient is not None and grad is not None:
+ self._resource_scatter_add(accum_gradient, indices, grad)
+
+ return self._apply_grad(accum_gradient, var, apply_state)
+
+ def _apply_grad(self, accum_gradient, var, apply_state):
+ grad = tf.where(
+ self.step % self._accum_steps == 0,
+ accum_gradient,
+ tf.zeros_like(var),
+ )
+ if "apply_state" in self._optimizer._dense_apply_args:
+ train_op = self._optimizer._resource_apply_dense(
+ grad,
+ var,
+ apply_state=apply_state,
+ )
+ else:
+ train_op = self._optimizer._resource_apply_dense(grad, var)
+ reset_val = tf.where(
+ grad == accum_gradient, tf.zeros_like(accum_gradient), accum_gradient
+ )
+ reset_op = accum_gradient.assign(
+ reset_val,
+ use_locking=self._use_locking,
+ read_value=False,
+ )
+
+ return tf.group(train_op, reset_op)
+
+ def reset(self):
+ """Resets the accumulated gradients on the current replica."""
+ assign_ops = []
+ if not self._gradients:
+ return assign_ops
+
+ for gradient in self._gradients:
+ if gradient is not None:
+ assign_ops.append(
+ gradient.assign(
+ tf.zeros_like(gradient),
+ use_locking=self._use_locking,
+ read_value=False,
+ )
+ )
+
+ return tf.group(assign_ops)
+
+ @property
+ def inner_optimizer(self):
+ """The optimizer that this LossScaleOptimizer is wrapping."""
+ return self._optimizer
+
+ @property
+ def iterations(self):
+ return self._optimizer.iterations
+
+ @iterations.setter
+ def iterations(self, variable):
+ self._optimizer.iterations = variable
+
+ @property
+ def lr(self):
+ return self._optimizer._get_hyper("learning_rate")
+
+ @lr.setter
+ def lr(self, lr):
+ self._optimizer._set_hyper("learning_rate", lr) #
+
+ @property
+ def learning_rate(self):
+ return self._optimizer._get_hyper("learning_rate")
+
+ @learning_rate.setter
+ def learning_rate(self, learning_rate):
+ self._optimizer._set_hyper("learning_rate", learning_rate)
+
+ def get_config(self):
+ config = {
+ "accum_steps": self._accum_steps,
+ "optimizer": tf.keras.optimizers.serialize(self._optimizer),
+ }
+ base_config = super().get_config()
+ return {**base_config, **config}
+
+ @classmethod
+ def from_config(cls, config, custom_objects=None):
+ optimizer = tf.keras.optimizers.deserialize(
+ config.pop("optimizer"), custom_objects=custom_objects
+ )
+ return cls(optimizer, **config)
+
diff --git a/Multilingual_CLIP/multilingual_clip/TeacherLearning/__init__.py b/Multilingual_CLIP/multilingual_clip/TeacherLearning/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/Multilingual_CLIP/multilingual_clip/__init__.py b/Multilingual_CLIP/multilingual_clip/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/Multilingual_CLIP/multilingual_clip/legacy_multilingual_clip.py b/Multilingual_CLIP/multilingual_clip/legacy_multilingual_clip.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2900b61834e245f611ca8ad38e37491d283b98e
--- /dev/null
+++ b/Multilingual_CLIP/multilingual_clip/legacy_multilingual_clip.py
@@ -0,0 +1,68 @@
+import pickle
+
+import torch
+import transformers
+
+
+class MultilingualClip(torch.nn.Module):
+ def __init__(self, model_name, tokenizer_name, head_name, weights_dir='data/weights/', cache_dir=None):
+ super().__init__()
+ self.model_name = model_name
+ self.tokenizer_name = tokenizer_name
+ self.head_path = weights_dir + head_name
+
+ self.tokenizer = transformers.AutoTokenizer.from_pretrained(tokenizer_name, cache_dir=cache_dir)
+ self.transformer = transformers.AutoModel.from_pretrained(model_name, cache_dir=cache_dir)
+ self.clip_head = torch.nn.Linear(in_features=768, out_features=640)
+ self._load_head()
+
+ def forward(self, txt):
+ txt_tok = self.tokenizer(txt, padding=True, return_tensors='pt')
+ embs = self.transformer(**txt_tok)[0]
+ att = txt_tok['attention_mask']
+ embs = (embs * att.unsqueeze(2)).sum(dim=1) / att.sum(dim=1)[:, None]
+ return self.clip_head(embs)
+
+ def _load_head(self):
+ with open(self.head_path, 'rb') as f:
+ lin_weights = pickle.loads(f.read())
+ self.clip_head.weight = torch.nn.Parameter(torch.tensor(lin_weights[0]).float().t())
+ self.clip_head.bias = torch.nn.Parameter(torch.tensor(lin_weights[1]).float())
+
+
+AVAILABLE_MODELS = {
+ 'M-BERT-Distil-40': {
+ 'model_name': 'M-CLIP/M-BERT-Distil-40',
+ 'tokenizer_name': 'M-CLIP/M-BERT-Distil-40',
+ 'head_name': 'M-BERT Distil 40 Linear Weights.pkl'
+ },
+
+ 'M-BERT-Base-69': {
+ 'model_name': 'M-CLIP/M-BERT-Base-69',
+ 'tokenizer_name': 'M-CLIP/M-BERT-Base-69',
+ 'head_name': 'M-BERT-Base-69 Linear Weights.pkl'
+ },
+
+ 'Swe-CLIP-500k': {
+ 'model_name': 'M-CLIP/Swedish-500k',
+ 'tokenizer_name': 'M-CLIP/Swedish-500k',
+ 'head_name': 'Swedish-500k Linear Weights.pkl'
+ },
+
+ 'Swe-CLIP-2M': {
+ 'model_name': 'M-CLIP/Swedish-2M',
+ 'tokenizer_name': 'M-CLIP/Swedish-2M',
+ 'head_name': 'Swedish-2M Linear Weights.pkl'
+ },
+
+ 'M-BERT-Base-ViT-B': {
+ 'model_name': 'M-CLIP/M-BERT-Base-ViT-B',
+ 'tokenizer_name': 'M-CLIP/M-BERT-Base-ViT-B',
+ 'head_name': 'M-BERT-Base-69-ViT Linear Weights.pkl'
+ },
+}
+
+
+def load_model(name, cache_dir=None):
+ config = AVAILABLE_MODELS[name]
+ return MultilingualClip(**config, cache_dir=cache_dir)
diff --git a/Multilingual_CLIP/multilingual_clip/pt_multilingual_clip.py b/Multilingual_CLIP/multilingual_clip/pt_multilingual_clip.py
new file mode 100644
index 0000000000000000000000000000000000000000..cac2a7eb7f34d08e1d93d1ede6f7f91607aaad02
--- /dev/null
+++ b/Multilingual_CLIP/multilingual_clip/pt_multilingual_clip.py
@@ -0,0 +1,27 @@
+from Multilingual_CLIP.multilingual_clip import Config_MCLIP
+import transformers
+import torch
+
+
+class MultilingualCLIP(transformers.PreTrainedModel):
+ config_class = Config_MCLIP.MCLIPConfig
+
+ def __init__(self, config, *args, **kwargs):
+ super().__init__(config, *args, **kwargs)
+ self.transformer = transformers.AutoModel.from_pretrained(config.modelBase)
+ self.LinearTransformation = torch.nn.Linear(in_features=config.transformerDimensions,
+ out_features=config.numDims)
+
+ def forward(self, txt, tokenizer, device):
+ txt_tok = tokenizer(txt, padding='max_length', max_length=77, truncation=True, return_tensors='pt').to(device)
+ embs = self.transformer(**txt_tok)
+ print(embs.keys())
+ embs = embs[0]
+ att = txt_tok['attention_mask']
+ embs = (embs * att.unsqueeze(2)) / att.sum(dim=1)[:, None].unsqueeze(2)
+ return self.LinearTransformation(embs)
+
+ @classmethod
+ def _load_state_dict_into_model(cls, model, state_dict, pretrained_model_name_or_path, _fast_init=True):
+ model.load_state_dict(state_dict)
+ return model, [], [], []
diff --git a/Multilingual_CLIP/multilingual_clip/tf_multilingual_clip.py b/Multilingual_CLIP/multilingual_clip/tf_multilingual_clip.py
new file mode 100644
index 0000000000000000000000000000000000000000..94b5e5fedc3ec3bf527333d567cc21ac01ee98c7
--- /dev/null
+++ b/Multilingual_CLIP/multilingual_clip/tf_multilingual_clip.py
@@ -0,0 +1,64 @@
+from multilingual_clip import Config_MCLIP
+import tensorflow as tf
+import transformers
+
+
+class SentenceModel(tf.keras.Model):
+
+ def __init__(self, modelBase, from_pt=True, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.transformer = transformers.TFAutoModel.from_pretrained(modelBase, from_pt=from_pt)
+
+ @tf.function
+ def generateMeanPooledSentenceEmbs(self, input, training=False):
+ output = self.transformer(input, training=training)
+ hiddenStates = output['last_hidden_state']
+
+ outAtt = tf.cast(input['attention_mask'], tf.float32)
+ sampleLength = tf.reduce_sum(outAtt, axis=-1, keepdims=True)
+ maskedEmbs = hiddenStates * tf.expand_dims(outAtt, axis=-1)
+ return tf.reduce_sum(maskedEmbs, axis=1) / tf.cast(sampleLength, tf.float32)
+
+ @tf.function
+ def call(self, inputs, training=False, mask=None):
+ return self.generateMeanPooledSentenceEmbs(inputs, training)
+
+
+class SentenceModelWithLinearTransformation(SentenceModel):
+
+ def __init__(self, modelBase, embeddingSize=640, *args, **kwargs):
+ super().__init__(modelBase, *args, **kwargs)
+ self.postTransformation = tf.keras.layers.Dense(embeddingSize, activation='linear', name='LinearTransformation')
+
+ @tf.function
+ def call(self, inputs, training=False, mask=None):
+ return self.postTransformation(self.generateMeanPooledSentenceEmbs(inputs, training))
+
+
+class MultiLingualCLIP(transformers.TFPreTrainedModel):
+ config_class = Config_MCLIP.MCLIPConfig
+
+ @property
+ def dummy_inputs(self):
+ return {'input_ids': tf.ones((4, 12), tf.int32),
+ 'attention_mask': tf.ones((4, 12), tf.int32)}
+
+ @tf.function(
+ input_signature=[
+ tf.TensorSpec((None, None), tf.int32), tf.TensorSpec((None, None), tf.int32)
+ ]
+ )
+ def serving(self, ids, att):
+ output = self.call((ids, att))
+ return self.serving_output(output)
+
+ def serving_output(self, outputs):
+ return outputs
+
+ def __init__(self, config, *args, **kwargs):
+ super().__init__(config, *args, **kwargs)
+ self.sentenceModel = SentenceModelWithLinearTransformation(config.modelBase, config.numDims)
+
+ @tf.function
+ def call(self, inputs, training=False, mask=None):
+ return self.sentenceModel.call(inputs, training)
diff --git a/Multilingual_CLIP/requirements.txt b/Multilingual_CLIP/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..976a2b1f3998279c10c413279a095be86bf69167
--- /dev/null
+++ b/Multilingual_CLIP/requirements.txt
@@ -0,0 +1 @@
+transformers
diff --git a/Multilingual_CLIP/setup.py b/Multilingual_CLIP/setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..28d4bba75429f73b17806d00b1bd98d371875cc1
--- /dev/null
+++ b/Multilingual_CLIP/setup.py
@@ -0,0 +1,38 @@
+from setuptools import setup, find_packages
+from pathlib import Path
+import os
+
+if __name__ == "__main__":
+ with Path(Path(__file__).parent, "README.md").open(encoding="utf-8") as file:
+ long_description = file.read()
+
+ def _read_reqs(relpath):
+ fullpath = os.path.join(os.path.dirname(__file__), relpath)
+ with open(fullpath) as f:
+ return [s.strip() for s in f.readlines() if (s.strip() and not s.startswith("#"))]
+
+ REQUIREMENTS = _read_reqs("requirements.txt")
+
+ setup(
+ name="multilingual_clip",
+ packages=find_packages(),
+ include_package_data=True,
+ version="1.0.10",
+ license="MIT",
+ description="OpenAI CLIP text encoders for multiple languages!",
+ long_description=long_description,
+ long_description_content_type="text/markdown",
+ author="Fredrik Carlsson",
+ author_email="FreddeFc@gmail.com",
+ url="https://github.com/FreddeFrallan/Multilingual-CLIP",
+ data_files=[(".", ["README.md"])],
+ keywords=["machine learning"],
+ install_requires=REQUIREMENTS,
+ classifiers=[
+ "Development Status :: 4 - Beta",
+ "Intended Audience :: Developers",
+ "Topic :: Scientific/Engineering :: Artificial Intelligence",
+ "License :: OSI Approved :: MIT License",
+ "Programming Language :: Python :: 3.6",
+ ],
+ )
diff --git a/Multilingual_CLIP/translation/01_ccs_to_df.py b/Multilingual_CLIP/translation/01_ccs_to_df.py
new file mode 100644
index 0000000000000000000000000000000000000000..b0e671cf14341318d70968cf4060d6bdf43b2bcc
--- /dev/null
+++ b/Multilingual_CLIP/translation/01_ccs_to_df.py
@@ -0,0 +1,11 @@
+import pandas as pd
+import json
+
+with open("data/ccs_synthetic_filtered_large.json") as f:
+ d = json.load(f)
+
+df = pd.DataFrame(d)
+df["index"] = df.index + 1
+df["nr_words"] = df["caption"].apply(lambda x: len(x.split()))
+
+df.to_feather("data/ccs_synthetic.feather")
diff --git a/Multilingual_CLIP/translation/01_translate_sv.py b/Multilingual_CLIP/translation/01_translate_sv.py
new file mode 100644
index 0000000000000000000000000000000000000000..469c00e97d837c1c37d8abfbbea1b11fe6fa5d26
--- /dev/null
+++ b/Multilingual_CLIP/translation/01_translate_sv.py
@@ -0,0 +1,68 @@
+import pandas as pd
+import torch
+from tqdm import tqdm
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, DataCollatorWithPadding
+from torch.utils.data import Dataset, DataLoader
+
+df = pd.read_feather("data/ccs_synthetic.feather")
+
+# from transformers import MarianTokenizer
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+
+class CaptionDataset(Dataset):
+ def __init__(self, df, tokenizer_name):
+ self.df = df
+ self.tokenizer = AutoTokenizer.from_pretrained(tokenizer_name)
+
+ def __len__(self):
+ return len(self.df)
+
+ def __getitem__(self, index):
+ sentence1 = df.loc[index, "caption"]
+
+ tokens = self.tokenizer(sentence1, return_tensors="pt")
+
+ return tokens
+
+
+tokenizer = AutoTokenizer.from_pretrained("Helsinki-NLP/opus-mt-en-sv")
+model = AutoModelForSeq2SeqLM.from_pretrained("Helsinki-NLP/opus-mt-en-sv")
+model.to(device)
+model.eval()
+
+
+def custom_collate_fn(data):
+ """
+ Data collator with padding.
+ """
+ tokens = [sample["input_ids"][0] for sample in data]
+ attention_masks = [sample["attention_mask"][0] for sample in data]
+
+ attention_masks = torch.nn.utils.rnn.pad_sequence(attention_masks, batch_first=True)
+ padded_tokens = torch.nn.utils.rnn.pad_sequence(tokens, batch_first=True)
+
+ batch = {"input_ids": padded_tokens, "attention_mask": attention_masks}
+ return batch
+
+
+test_data = CaptionDataset(df, "Helsinki-NLP/opus-mt-en-sv")
+test_dataloader = DataLoader(
+ test_data,
+ batch_size=64,
+ shuffle=False,
+ num_workers=4,
+ collate_fn=custom_collate_fn,
+)
+
+with torch.no_grad():
+ decoded_tokens = []
+ for i, batch in enumerate(tqdm(test_dataloader)):
+
+ batch = {k: v.to(device) for k, v in batch.items()}
+ output_tokens = model.generate(**batch)
+ decoded_tokens += tokenizer.batch_decode(output_tokens.to("cpu"), skip_special_tokens=True)
+
+
+df["caption_sv"] = decoded_tokens
+df.to_feather("data/ccs_synthetic_sv.feather")
diff --git a/Multilingual_CLIP/translation/02_multilingual_shard.py b/Multilingual_CLIP/translation/02_multilingual_shard.py
new file mode 100644
index 0000000000000000000000000000000000000000..6952757406cded470b78f9547d5736c571400286
--- /dev/null
+++ b/Multilingual_CLIP/translation/02_multilingual_shard.py
@@ -0,0 +1,48 @@
+import os
+import pandas as pd
+import numpy as np
+
+n = 150000 # Chunk size. How many obs to translate per language.
+
+df_blip = pd.read_csv("data/fine_tune_languages.csv", index_col=None)
+df = pd.read_feather("data/ccs_synthetic_sv.feather")
+df = df[["caption", "caption_sv", "url", "index"]]
+
+df2 = pd.DataFrame(np.repeat(df_blip.to_numpy(), n, axis=0), columns=df_blip.columns)
+df = pd.concat([df, df2], axis=1)
+
+df["caption_multi"] = None
+df = df.rename(
+ columns={"language_code": "multi_language_code", "language_name": "multi_language_name"}
+)
+df = df[
+ [
+ "caption",
+ "caption_sv",
+ "caption_multi",
+ "url",
+ "multi_language_code",
+ "multi_language_name",
+ "multi_target",
+ "target_code",
+ "opus_mt_url",
+ "index",
+ ]
+]
+df["multi_target"] = df["multi_target"].astype("Int64")
+
+df.loc[df["multi_language_code"] == "en", "caption_multi"] = df.loc[
+ df["multi_language_code"] == "en", "caption"
+]
+
+
+df_list = [df[i : i + n].reset_index(drop=True) for i in range(0, len(df), n)]
+
+os.makedirs("data_multi", exist_ok=True)
+for i in range(0, len(df_list)):
+ code = df_list[i]["multi_language_code"][0]
+ part_num = str(i).zfill(3)
+ df_list[i].to_feather(f"data_multi/{part_num}_ccs_synthetic_{code}.feather")
+
+
+df.to_feather("data/ccs_synthetic_multi.feather")
diff --git a/Multilingual_CLIP/translation/02_translate_multi.sh b/Multilingual_CLIP/translation/02_translate_multi.sh
new file mode 100644
index 0000000000000000000000000000000000000000..594186a27520507fb3c1b1e7943ae41382fc4396
--- /dev/null
+++ b/Multilingual_CLIP/translation/02_translate_multi.sh
@@ -0,0 +1,4 @@
+for filename in $(ls data_multi);
+do
+ python 02_translate_multilingual.py --filename $filename
+done
\ No newline at end of file
diff --git a/Multilingual_CLIP/translation/02_translate_multilingual.py b/Multilingual_CLIP/translation/02_translate_multilingual.py
new file mode 100644
index 0000000000000000000000000000000000000000..37be9ab5145f9f05bf2b7e181a17de590c83c94d
--- /dev/null
+++ b/Multilingual_CLIP/translation/02_translate_multilingual.py
@@ -0,0 +1,95 @@
+import os
+import pandas as pd
+import torch
+import argparse
+import shutil
+from tqdm import tqdm
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, DataCollatorWithPadding
+from torch.utils.data import Dataset, DataLoader
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-f", "--filename", type=str)
+parser.add_argument(
+ "data_folder",
+ nargs="?",
+ type=str,
+ default="data_multi",
+)
+args = parser.parse_args()
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+os.makedirs("data_translated", exist_ok=True)
+
+if args.filename == "015_ccs_synthetic_en.feather":
+ # No need to translate English -> English
+ shutil.copy2(os.path.join(args.data_folder, "015_ccs_synthetic_en.feather"), "data_translated")
+ os._exit(0)
+
+df = pd.read_feather(os.path.join(args.data_folder, args.filename))
+df["opus_mt_url"] = df["opus_mt_url"].str.replace("https://huggingface.co/", "")
+print(f"Starting translation of English to {df['multi_language_name'][0]}")
+
+
+class CaptionDataset(Dataset):
+ def __init__(self, df, tokenizer_name):
+ self.df = df
+ self.tokenizer = AutoTokenizer.from_pretrained(tokenizer_name)
+
+ def __len__(self):
+ return len(self.df)
+
+ def __getitem__(self, index):
+ sentence1 = df.loc[index, "caption"]
+
+ tokens = self.tokenizer(sentence1, return_tensors="pt")
+
+ return tokens
+
+
+tokenizer = AutoTokenizer.from_pretrained(df["opus_mt_url"][0])
+model = AutoModelForSeq2SeqLM.from_pretrained(df["opus_mt_url"][0])
+model.to(device)
+model.eval()
+
+
+def custom_collate_fn(data):
+ """
+ Data collator with padding.
+ """
+ tokens = [sample["input_ids"][0] for sample in data]
+ attention_masks = [sample["attention_mask"][0] for sample in data]
+
+ attention_masks = torch.nn.utils.rnn.pad_sequence(attention_masks, batch_first=True)
+ padded_tokens = torch.nn.utils.rnn.pad_sequence(tokens, batch_first=True)
+
+ batch = {"input_ids": padded_tokens, "attention_mask": attention_masks}
+ return batch
+
+
+if df["multi_target"][0] == 1:
+ # If model is a multilingual model we need to concatenate target language code
+ # in the form '>> CODE >>' in front of string so model outputs correct language.
+ df["caption"] = ">>" + df["target_code"] + "<<" + df["caption"]
+
+test_data = CaptionDataset(df, df["opus_mt_url"][0])
+test_dataloader = DataLoader(
+ test_data,
+ batch_size=50,
+ shuffle=False,
+ num_workers=4,
+ collate_fn=custom_collate_fn,
+)
+
+with torch.no_grad():
+ decoded_tokens = []
+ for i, batch in enumerate(tqdm(test_dataloader)):
+
+ batch = {k: v.to(device) for k, v in batch.items()}
+ output_tokens = model.generate(**batch)
+ decoded_tokens += tokenizer.batch_decode(output_tokens.to("cpu"), skip_special_tokens=True)
+
+df["caption_multi"] = decoded_tokens
+df.to_feather(os.path.join("data_translated", args.filename))
+
+print(f"Finished translating English to {df['multi_language_name'][0]}")
diff --git a/Multilingual_CLIP/translation/03_merge_sv_multi.py b/Multilingual_CLIP/translation/03_merge_sv_multi.py
new file mode 100644
index 0000000000000000000000000000000000000000..3c7490bb4bbcc8732638eb9e16c9a8115b3f48d4
--- /dev/null
+++ b/Multilingual_CLIP/translation/03_merge_sv_multi.py
@@ -0,0 +1,31 @@
+import os
+import pandas as pd
+
+filenames = os.listdir("data_translated")
+df = pd.read_feather("data/ccs_synthetic_multi.feather")
+df_list = [pd.read_feather(os.path.join("data_translated", filename)) for filename in filenames]
+df_multi = pd.concat(df_list)
+df_multi = df_multi.reset_index(drop=True)
+
+df = df.drop("caption_multi", axis=1)
+df = df.merge(df_multi[["caption_multi", "index"]], how="left", on="index")
+
+df = df[
+ [
+ "caption",
+ "caption_sv",
+ "caption_multi",
+ "url",
+ "multi_language_code",
+ "multi_language_name",
+ "multi_target",
+ "target_code",
+ "opus_mt_url",
+ "index",
+ ]
+]
+
+df = df.rename(columns={"multi_target": "multiple_target_model"})
+df["opus_mt_url"] = df["opus_mt_url"].str.replace("https://huggingface.co/", "")
+
+df.to_feather("ccs_synthetic.feather")
diff --git a/Multilingual_CLIP/translation/README.md b/Multilingual_CLIP/translation/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..3d5eb47d9af21e9b974130f432292e8085ff5914
--- /dev/null
+++ b/Multilingual_CLIP/translation/README.md
@@ -0,0 +1,51 @@
+A set of scripts to machine translate the subset of (synthetic) Conceptual Captions used in [BLIP](https://github.com/salesforce/BLIP#pre-training-datasets-download). The conda `environment.yml` file allows you to recreate the environment we used via `conda env create -f environment.yml` (creates env named `translate`).
+
+## Step 0: Download data
+
+```bash
+wget https://storage.googleapis.com/sfr-vision-language-research/BLIP/datasets/ccs_synthetic_filtered_large.json -P data
+```
+
+## Step 1: Swedish captions
+
+Convert to tabular and save data to `.feather`. File is saved as `data/ccs_synthetic.feather`
+
+```hash
+python 01_ccs_to_df.py
+```
+
+Now translate captions from English -> Swedish. Will take about ~26 hours to translate 12.5 million captions with an RTX 3090.
+
+```bash
+python 01_translate_sv.py
+```
+
+### Step 2: Multilingual captions
+
+We separate the original file into `n=150000` observations sized chunks for each language we are translating to. Run `02_multilingual_shard.py` to create a separate data file with 150k obs for each target language. Resulting files will be in `data_multi/` folder. The purpose of this script is also to merge target language metadata from `data/fine_tune_languages.csv` into the data files. This way the data files contain URL:s and languages codes for calling the correct language pair model and tokenizer names from `OPUS-MT` (via the `Helsinki-NLP` model repository on Huggingface).
+
+The list of language pairs and links to models were manually assembled. [This leaderboard](https://opus.nlpl.eu/leaderboard/) may help in getting an overview of further available pairs.
+
+```bash
+python 02_multilingual_shard.py
+```
+
+Clean up and remove the chunks that did not have a target language (file names ending with `nan`)
+
+```bash
+find data_multi | grep nan.feather | xargs rm -f
+```
+
+Run the multilingual translation script for every data file. Use the bash script `02_translate_multi.sh`. Results will be stored in `data_translated/`.
+
+```bash
+bash 02_translate_multi.sh
+```
+
+### Step 3 (optional): Merge to single big file
+
+Merge everything to the same file as the Swedish captions.
+
+```bash
+python 03_merge_sv_multi.py
+```
diff --git a/Multilingual_CLIP/translation/data/fine_tune_languages.csv b/Multilingual_CLIP/translation/data/fine_tune_languages.csv
new file mode 100644
index 0000000000000000000000000000000000000000..98f0b96f9eb8b13406853f4b6d7aa1d2998f508f
--- /dev/null
+++ b/Multilingual_CLIP/translation/data/fine_tune_languages.csv
@@ -0,0 +1,49 @@
+language_name,language_code,multi_target,target_code,opus_mt_url
+afrikaans,af,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-af
+albanian,sq,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-sq
+amharic,am,1,amh,https://huggingface.co/Helsinki-NLP/opus-mt-en-mul
+arabic,ar,1,ara,https://huggingface.co/Helsinki-NLP/opus-mt-en-ar
+azerbaijani,az,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-az
+bengali,bn,1,ben,https://huggingface.co/Helsinki-NLP/opus-mt-en-mul
+bosnian,bs,1,bos_Latn,https://huggingface.co/Helsinki-NLP/opus-mt-en-sla
+bulgarian,bg,1,bul,https://huggingface.co/Helsinki-NLP/opus-mt-en-bg
+catalan,ca,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-ca
+chinese_simplified,zh,1,cmn_Hans,https://huggingface.co/Helsinki-NLP/opus-mt-en-zh
+chinese_traditional,zh,1,cmn_Hant,https://huggingface.co/Helsinki-NLP/opus-mt-en-zh
+croatian,hr,1,hrv,https://huggingface.co/Helsinki-NLP/opus-mt-en-sla
+czech,cs,1,ces,https://huggingface.co/Helsinki-NLP/opus-mt-en-sla
+danish,da,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-da
+dutch,nl,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-nl
+english,en,0,,
+estonian,et,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-et
+french,fr,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-fr
+german,de,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-de
+greek,el,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-el
+hindi,hi,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-hi
+hungarian,hu,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-hu
+icelandic,is,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-is
+indonesian,id,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-id
+italian,it,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-it
+japanese,ja,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-jap
+macedonian,mk,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-mk
+malayalam,ml,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-ml
+marathi,mr,1,mar,https://huggingface.co/Helsinki-NLP/opus-mt-en-mul
+polish,pl,1,pol,https://huggingface.co/Helsinki-NLP/opus-mt-en-sla
+portuguese,pt,1,por,https://huggingface.co/Helsinki-NLP/opus-mt-tc-big-en-pt
+romanian,ro,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-ro
+russian,ru,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-ru
+serbian,sr,1,srp_Cyrl,https://huggingface.co/Helsinki-NLP/opus-mt-en-sla
+slovenian,sl,1,slv,https://huggingface.co/Helsinki-NLP/opus-mt-en-sla
+spanish,es,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-es
+swahili,sw,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-sw
+swedish,sv,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-sv
+tagalog,tl,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-tl
+telugu,te,1,tel,https://huggingface.co/Helsinki-NLP/opus-mt-en-mul
+turkish,tr,0,,https://huggingface.co/Helsinki-NLP/opus-mt-tc-big-en-tr
+turkmen,tk,1,tuk,https://huggingface.co/Helsinki-NLP/opus-mt-en-trk
+ukrainian,uk,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-uk
+urdu,ur,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-ur
+uyghur,ug,1,uig_Arab,https://huggingface.co/Helsinki-NLP/opus-mt-en-trk
+uzbek,uz,1,uzb_Latn,https://huggingface.co/Helsinki-NLP/opus-mt-en-trk
+vietnamese,vi,1,vie,https://huggingface.co/Helsinki-NLP/opus-mt-en-vi
+xhosa,xh,0,,https://huggingface.co/Helsinki-NLP/opus-mt-en-xh
diff --git a/Multilingual_CLIP/translation/environment.yml b/Multilingual_CLIP/translation/environment.yml
new file mode 100644
index 0000000000000000000000000000000000000000..6cd5b5681ea7d382829532ec9a8c8ed12e9ddbfa
--- /dev/null
+++ b/Multilingual_CLIP/translation/environment.yml
@@ -0,0 +1,120 @@
+name: translate
+channels:
+ - pytorch
+ - defaults
+dependencies:
+ - _libgcc_mutex=0.1=main
+ - _openmp_mutex=4.5=1_gnu
+ - blas=1.0=mkl
+ - brotlipy=0.7.0=py38h27cfd23_1003
+ - bzip2=1.0.8=h7b6447c_0
+ - ca-certificates=2022.3.29=h06a4308_0
+ - certifi=2021.10.8=py38h06a4308_2
+ - cffi=1.15.0=py38hd667e15_1
+ - charset-normalizer=2.0.4=pyhd3eb1b0_0
+ - cryptography=36.0.0=py38h9ce1e76_0
+ - cudatoolkit=11.3.1=h2bc3f7f_2
+ - ffmpeg=4.3=hf484d3e_0
+ - freetype=2.11.0=h70c0345_0
+ - giflib=5.2.1=h7b6447c_0
+ - gmp=6.2.1=h2531618_2
+ - gnutls=3.6.15=he1e5248_0
+ - idna=3.3=pyhd3eb1b0_0
+ - intel-openmp=2021.4.0=h06a4308_3561
+ - jpeg=9d=h7f8727e_0
+ - lame=3.100=h7b6447c_0
+ - lcms2=2.12=h3be6417_0
+ - ld_impl_linux-64=2.35.1=h7274673_9
+ - libffi=3.3=he6710b0_2
+ - libgcc-ng=9.3.0=h5101ec6_17
+ - libgomp=9.3.0=h5101ec6_17
+ - libiconv=1.15=h63c8f33_5
+ - libidn2=2.3.2=h7f8727e_0
+ - libpng=1.6.37=hbc83047_0
+ - libstdcxx-ng=9.3.0=hd4cf53a_17
+ - libtasn1=4.16.0=h27cfd23_0
+ - libtiff=4.2.0=h85742a9_0
+ - libunistring=0.9.10=h27cfd23_0
+ - libuv=1.40.0=h7b6447c_0
+ - libwebp=1.2.2=h55f646e_0
+ - libwebp-base=1.2.2=h7f8727e_0
+ - lz4-c=1.9.3=h295c915_1
+ - mkl=2021.4.0=h06a4308_640
+ - mkl-service=2.4.0=py38h7f8727e_0
+ - mkl_fft=1.3.1=py38hd3c417c_0
+ - mkl_random=1.2.2=py38h51133e4_0
+ - ncurses=6.3=h7f8727e_2
+ - nettle=3.7.3=hbbd107a_1
+ - numpy=1.21.2=py38h20f2e39_0
+ - numpy-base=1.21.2=py38h79a1101_0
+ - openh264=2.1.1=h4ff587b_0
+ - openssl=1.1.1n=h7f8727e_0
+ - pip=21.2.4=py38h06a4308_0
+ - pycparser=2.21=pyhd3eb1b0_0
+ - pyopenssl=22.0.0=pyhd3eb1b0_0
+ - pysocks=1.7.1=py38h06a4308_0
+ - python=3.8.13=h12debd9_0
+ - pytorch=1.11.0=py3.8_cuda11.3_cudnn8.2.0_0
+ - pytorch-mutex=1.0=cuda
+ - readline=8.1.2=h7f8727e_1
+ - requests=2.27.1=pyhd3eb1b0_0
+ - setuptools=58.0.4=py38h06a4308_0
+ - six=1.16.0=pyhd3eb1b0_1
+ - sqlite=3.38.2=hc218d9a_0
+ - tk=8.6.11=h1ccaba5_0
+ - torchvision=0.12.0=py38_cu113
+ - typing_extensions=4.1.1=pyh06a4308_0
+ - urllib3=1.26.8=pyhd3eb1b0_0
+ - wheel=0.37.1=pyhd3eb1b0_0
+ - xz=5.2.5=h7b6447c_0
+ - zlib=1.2.11=h7f8727e_4
+ - zstd=1.4.9=haebb681_0
+ - pip:
+ - aiohttp==3.8.1
+ - aiosignal==1.2.0
+ - arabic-reshaper==2.1.3
+ - async-timeout==4.0.2
+ - attrs==21.4.0
+ - beautifulsoup4==4.11.1
+ - black==22.3.0
+ - click==8.1.2
+ - datasets==2.0.0
+ - diffimg==0.2.3
+ - dill==0.3.4
+ - filelock==3.6.0
+ - frozenlist==1.3.0
+ - fsspec==2022.3.0
+ - future==0.18.2
+ - huggingface-hub==0.5.1
+ - jiwer==2.3.0
+ - joblib==1.1.0
+ - multidict==6.0.2
+ - multiprocess==0.70.12.2
+ - mypy-extensions==0.4.3
+ - nltk==3.7
+ - opencv-python==4.5.5.64
+ - packaging==21.3
+ - pandas==1.4.2
+ - pathspec==0.9.0
+ - pillow==7.0.0
+ - platformdirs==2.5.1
+ - pyarrow==7.0.0
+ - pycountry==22.3.5
+ - pyparsing==3.0.8
+ - python-bidi==0.4.2
+ - python-dateutil==2.8.2
+ - python-levenshtein==0.12.2
+ - pytz==2022.1
+ - pyyaml==6.0
+ - regex==2022.3.15
+ - responses==0.18.0
+ - sacremoses==0.0.49
+ - sentencepiece==0.1.96
+ - soupsieve==2.3.2
+ - tokenizers==0.11.6
+ - tomli==2.0.1
+ - tqdm==4.64.0
+ - transformers==4.18.0
+ - trdg==1.6.0
+ - xxhash==3.0.0
+ - yarl==1.7.2