Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+.gradio/flagged/Télécharger[[:space:]]un[[:space:]]fichier[[:space:]]exécutable/8f4fec8239b0bcbd58df/jre-8u271-windows-x64.exe filter=lfs diff=lfs merge=lfs -text
+.gradio/flagged/Télécharger[[:space:]]un[[:space:]]fichier[[:space:]]exécutable/be2fac359432906d185e/jre-8u271-windows-x64.exe filter=lfs diff=lfs merge=lfs -text

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

.gradio/flagged/Télécharger un fichier exécutable/8f4fec8239b0bcbd58df/jre-8u271-windows-x64.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6210a4cdfc5c67d34027224dfadf48798bf3508e5db6ef268bb93f0fb7d697d5
+size 83364488

.gradio/flagged/Télécharger un fichier exécutable/be2fac359432906d185e/jre-8u271-windows-x64.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6210a4cdfc5c67d34027224dfadf48798bf3508e5db6ef268bb93f0fb7d697d5
+size 83364488

.gradio/flagged/dataset1.csv

@@ -0,0 +1,3 @@
+Télécharger un fichier exécutable,output,timestamp
+.gradio/flagged/Télécharger un fichier exécutable/be2fac359432906d185e/jre-8u271-windows-x64.exe,🚨 MALWARE (Probabilité: 85.70%),2024-12-17 19:35:57.886915
+.gradio/flagged/Télécharger un fichier exécutable/8f4fec8239b0bcbd58df/jre-8u271-windows-x64.exe,🚨 MALWARE (Probabilité: 85.70%),2024-12-17 19:44:23.100754

.ipynb_checkpoints/Untitled-checkpoint.ipynb

@@ -0,0 +1,179 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "b156c93b-7114-4401-8956-0bbdf3f55819",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/cheikh/anaconda3/lib/python3.12/site-packages/gradio/blocks.py:1049: UserWarning: Cannot load huggingface. Caught Exception: 404 Client Error: Not Found for url: https://huggingface.co/api/spaces/huggingface (Request ID: Root=1-6761d652-5bc4d5a26e798b4156071116;691ae8e4-ee45-43b8-8d96-de80ab472888)\n",
+      "\n",
+      "Sorry, we can't find the page you are looking for.\n",
+      "  warnings.warn(f\"Cannot load {theme}. Caught Exception: {str(e)}\")\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "* Running on local URL:  http://127.0.0.1:7861\n",
+      "* Running on public URL: https://9cd0ff2c927f533d29.gradio.live\n",
+      "\n",
+      "This share link expires in 72 hours. For free permanent hosting and GPU upgrades, run `gradio deploy` from the terminal in the working directory to deploy to Hugging Face Spaces (https://huggingface.co/spaces)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"https://9cd0ff2c927f533d29.gradio.live\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "import os\n",
+    "import joblib\n",
+    "import pefile\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import gradio as gr\n",
+    "import hashlib\n",
+    "\n",
+    "\n",
+    "# Charger le modèle pré-entraîné\n",
+    "try:\n",
+    "    model = joblib.load('random_forest_model.pkl')\n",
+    "except Exception as e:\n",
+    "    print(f\"Erreur de chargement du modèle : {e}\")\n",
+    "    model = None\n",
+    "\n",
+    "def calculate_file_hash(file_path):\n",
+    "    \"\"\"Calculer le hash SHA-256 du fichier.\"\"\"\n",
+    "    sha256_hash = hashlib.sha256()\n",
+    "    with open(file_path, \"rb\") as f:\n",
+    "        for byte_block in iter(lambda: f.read(4096), b\"\"):\n",
+    "            sha256_hash.update(byte_block)\n",
+    "    return sha256_hash.hexdigest()\n",
+    "\n",
+    "def extract_pe_attributes(file_path):\n",
+    "    \"\"\"Extraction avancée des attributs du fichier PE.\"\"\"\n",
+    "    try:\n",
+    "        pe = pefile.PE(file_path)\n",
+    "\n",
+    "        attributes = {\n",
+    "            # Attributs PE standard\n",
+    "            'AddressOfEntryPoint': pe.OPTIONAL_HEADER.AddressOfEntryPoint,\n",
+    "            'MajorLinkerVersion': pe.OPTIONAL_HEADER.MajorLinkerVersion,\n",
+    "            'MajorImageVersion': pe.OPTIONAL_HEADER.MajorImageVersion,\n",
+    "            'MajorOperatingSystemVersion': pe.OPTIONAL_HEADER.MajorOperatingSystemVersion,\n",
+    "            'DllCharacteristics': pe.OPTIONAL_HEADER.DllCharacteristics,\n",
+    "            'SizeOfStackReserve': pe.OPTIONAL_HEADER.SizeOfStackReserve,\n",
+    "            'NumberOfSections': pe.FILE_HEADER.NumberOfSections,\n",
+    "             'ResourceSize':pe.OPTIONAL_HEADER.DATA_DIRECTORY[2].Size\n",
+    "        }\n",
+    "        \"\"\"## Ressources\n",
+    "        data_directory_entries = pe.OPTIONAL_HEADER.DATA_DIRECTORY\n",
+    "        # Parcourir la liste pour trouver l'entrée du répertoire des ressources\n",
+    "        for entry in data_directory_entries:\n",
+    "            if entry.name == \"IMAGE_DIRECTORY_ENTRY_RESOURCE\":\n",
+    "                resource_size = entry.Size\n",
+    "                attributes['ResourceSize'] = resource_size\n",
+    "                break\n",
+    "        else:\n",
+    "            attributes['ResourceSize'] = 0\"\"\"\n",
+    "            \n",
+    "        \n",
+    "\n",
+    "        return attributes\n",
+    "    except Exception as e:\n",
+    "        print(f\"Erreur de traitement du fichier {file_path}: {str(e)}\")\n",
+    "        return f\"Erreur de traitement du fichier {file_path}: {str(e)}\"\n",
+    "\n",
+    "def predict_malware(file):\n",
+    "    \"\"\"Prédiction de malware avec gestion d'erreurs.\"\"\"\n",
+    "    if model is None:\n",
+    "        return \"Erreur : Modèle non chargé\"\n",
+    "\n",
+    "    try:\n",
+    "        # Extraire les attributs du fichier\n",
+    "        attributes = extract_pe_attributes(file.name)\n",
+    "        if \"Erreur\" in attributes:\n",
+    "            return attributes\n",
+    "\n",
+    "        # Convertir en DataFrame\n",
+    "        df = pd.DataFrame([attributes])\n",
+    "\n",
+    "        # Prédiction\n",
+    "        prediction = model.predict(df)\n",
+    "        proba = model.predict_proba(df)[0]\n",
+    "\n",
+    "        # Résultat avec probabilité\n",
+    "        if prediction[0] == 1:\n",
+    "            return f\"🚨 MALWARE (Probabilité: {proba[1] * 100:.2f}%)\"\n",
+    "        else:\n",
+    "            return f\"✅ Fichier Légitime (Probabilité: {proba[0] * 100:.2f}%)\"\n",
+    "    except Exception as e:\n",
+    "        return f\"Erreur d'analyse : {str(e)}\"\n",
+    "\n",
+    "# Interface Gradio\n",
+    "demo = gr.Interface(\n",
+    "    fn=predict_malware,\n",
+    "    inputs=gr.File(file_types=['.exe', '.dll', '.sys'], label=\"Télécharger un fichier exécutable\"),\n",
+    "    outputs=\"text\",\n",
+    "    title=\"🛡️ Détecteur de Malwares\",\n",
+    "    theme='huggingface'  # Thème moderne\n",
+    ")\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    demo.launch(share=True)  # Rend l'interface accessible publiquement\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5f87e13b-157d-4105-865f-daa2919c2711",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c23ce0c3-ac81-438b-a8b8-1264ac99dd12",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

README.md

@@ -1,12 +1,6 @@
 ---
-title: Malware
-emoji: 😻
-colorFrom: purple
-colorTo: green
+title: malware
+app_file: Untitled.ipynb
 sdk: gradio
 sdk_version: 5.9.1
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

Untitled.ipynb

@@ -0,0 +1,170 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "b156c93b-7114-4401-8956-0bbdf3f55819",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/cheikh/anaconda3/lib/python3.12/site-packages/sklearn/base.py:376: InconsistentVersionWarning: Trying to unpickle estimator DecisionTreeClassifier from version 1.5.2 when using version 1.4.2. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n",
+      "https://scikit-learn.org/stable/model_persistence.html#security-maintainability-limitations\n",
+      "  warnings.warn(\n",
+      "/home/cheikh/anaconda3/lib/python3.12/site-packages/sklearn/base.py:376: InconsistentVersionWarning: Trying to unpickle estimator RandomForestClassifier from version 1.5.2 when using version 1.4.2. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n",
+      "https://scikit-learn.org/stable/model_persistence.html#security-maintainability-limitations\n",
+      "  warnings.warn(\n",
+      "/home/cheikh/anaconda3/lib/python3.12/site-packages/gradio/blocks.py:1049: UserWarning: Cannot load huggingface. Caught Exception: 404 Client Error: Not Found for url: https://huggingface.co/api/spaces/huggingface (Request ID: Root=1-6761d6db-0c06b74870454450704094b9;d4cdbbda-a206-4969-bdc5-e2685d9d5157)\n",
+      "\n",
+      "Sorry, we can't find the page you are looking for.\n",
+      "  warnings.warn(f\"Cannot load {theme}. Caught Exception: {str(e)}\")\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "* Running on local URL:  http://127.0.0.1:7862\n",
+      "* Running on public URL: https://3202cd86a5db7b27c9.gradio.live\n",
+      "\n",
+      "This share link expires in 72 hours. For free permanent hosting and GPU upgrades, run `gradio deploy` from the terminal in the working directory to deploy to Hugging Face Spaces (https://huggingface.co/spaces)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"https://3202cd86a5db7b27c9.gradio.live\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "import os\n",
+    "import joblib\n",
+    "import pefile\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import gradio as gr\n",
+    "import hashlib\n",
+    "\n",
+    "\n",
+    "# Charger le modèle pré-entraîné\n",
+    "try:\n",
+    "    model = joblib.load('random_forest_model.pkl')\n",
+    "except Exception as e:\n",
+    "    print(f\"Erreur de chargement du modèle : {e}\")\n",
+    "    model = None\n",
+    "\n",
+    "def calculate_file_hash(file_path):\n",
+    "    \"\"\"Calculer le hash SHA-256 du fichier.\"\"\"\n",
+    "    sha256_hash = hashlib.sha256()\n",
+    "    with open(file_path, \"rb\") as f:\n",
+    "        for byte_block in iter(lambda: f.read(4096), b\"\"):\n",
+    "            sha256_hash.update(byte_block)\n",
+    "    return sha256_hash.hexdigest()\n",
+    "\n",
+    "def extract_pe_attributes(file_path):\n",
+    "    \"\"\"Extraction avancée des attributs du fichier PE.\"\"\"\n",
+    "    try:\n",
+    "        pe = pefile.PE(file_path)\n",
+    "\n",
+    "        attributes = {\n",
+    "            # Attributs PE standard\n",
+    "            'AddressOfEntryPoint': pe.OPTIONAL_HEADER.AddressOfEntryPoint,\n",
+    "            'MajorLinkerVersion': pe.OPTIONAL_HEADER.MajorLinkerVersion,\n",
+    "            'MajorImageVersion': pe.OPTIONAL_HEADER.MajorImageVersion,\n",
+    "            'MajorOperatingSystemVersion': pe.OPTIONAL_HEADER.MajorOperatingSystemVersion,\n",
+    "            'DllCharacteristics': pe.OPTIONAL_HEADER.DllCharacteristics,\n",
+    "            'SizeOfStackReserve': pe.OPTIONAL_HEADER.SizeOfStackReserve,\n",
+    "            'NumberOfSections': pe.FILE_HEADER.NumberOfSections,\n",
+    "             'ResourceSize':pe.OPTIONAL_HEADER.DATA_DIRECTORY[2].Size\n",
+    "        }\n",
+    "        \n",
+    "        \"\"\"## Ressources\n",
+    "        data_directory_entries = pe.OPTIONAL_HEADER.DATA_DIRECTORY\n",
+    "        # Parcourir la liste pour trouver l'entrée du répertoire des ressources\n",
+    "        for entry in data_directory_entries:\n",
+    "            if entry.name == \"IMAGE_DIRECTORY_ENTRY_RESOURCE\":\n",
+    "                resource_size = entry.Size\n",
+    "                attributes['ResourceSize'] = resource_size\n",
+    "                break\n",
+    "        else:\n",
+    "            attributes['ResourceSize'] = 0\"\"\"\n",
+    "            \n",
+    "\n",
+    "\n",
+    "        return attributes\n",
+    "    except Exception as e:\n",
+    "        print(f\"Erreur de traitement du fichier {file_path}: {str(e)}\")\n",
+    "        return f\"Erreur de traitement du fichier {file_path}: {str(e)}\"\n",
+    "\n",
+    "def predict_malware(file):\n",
+    "    \"\"\"Prédiction de malware avec gestion d'erreurs.\"\"\"\n",
+    "    if model is None:\n",
+    "        return \"Erreur : Modèle non chargé\"\n",
+    "\n",
+    "    try:\n",
+    "        # Extraire les attributs du fichier\n",
+    "        attributes = extract_pe_attributes(file.name)\n",
+    "        if \"Erreur\" in attributes:\n",
+    "            return attributes\n",
+    "\n",
+    "        # Convertir en DataFrame\n",
+    "        df = pd.DataFrame([attributes])\n",
+    "\n",
+    "        # Prédiction\n",
+    "        prediction = model.predict(df)\n",
+    "        proba = model.predict_proba(df)[0]\n",
+    "\n",
+    "        # Résultat avec probabilité\n",
+    "        if prediction[0] == 1:\n",
+    "            return f\"🚨 MALWARE (Probabilité: {proba[1] * 100:.2f}%)\"\n",
+    "        else:\n",
+    "            return f\"✅ Fichier Légitime (Probabilité: {proba[0] * 100:.2f}%)\"\n",
+    "    except Exception as e:\n",
+    "        return f\"Erreur d'analyse : {str(e)}\"\n",
+    "\n",
+    "# Interface Gradio\n",
+    "demo = gr.Interface(\n",
+    "    fn=predict_malware,\n",
+    "    inputs=gr.File(file_types=['.exe', '.dll', '.sys'], label=\"Télécharger un fichier exécutable\"),\n",
+    "    outputs=\"text\",\n",
+    "    title=\"🛡️ Détecteur de Malwares\",\n",
+    "    theme='huggingface'  # Thème moderne\n",
+    ")\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    demo.launch(share=True)  # Rend l'interface accessible publiquement\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.12.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

dl1.py

@@ -0,0 +1,64 @@
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+from sklearn.compose import make_column_transformer, make_column_selector
+from sklearn.model_selection import train_test_split
+
+fuel = pd.read_csv('../input/dl-course-data/fuel.csv')
+
+X = fuel.copy()
+# Remove target
+y = X.pop('FE')
+
+preprocessor = make_column_transformer(
+    (StandardScaler(),
+     make_column_selector(dtype_include=np.number)),
+    (OneHotEncoder(sparse=False),
+     make_column_selector(dtype_include=object)),
+)
+
+X = preprocessor.fit_transform(X)
+y = np.log(y) # log transform target instead of standardizing
+
+input_shape = [X.shape[1]]
+print("Input shape: {}".format(input_shape))
+
+from tensorflow import keras
+from tensorflow.keras import layers
+
+model = keras.Sequential([
+    layers.Dense(128, activation='relu', input_shape=input_shape),
+    layers.Dense(128, activation='relu'),
+    layers.Dense(64, activation='relu'),
+    layers.Dense(1),
+])
+model.compile(
+    optimizer='adam',
+    loss='mae',
+)
+history = model.fit(
+    X, y,
+    batch_size=128,
+    epochs=200,
+)
+
+import pandas as pd
+
+history_df = pd.DataFrame(history.history)
+# Start the plot at epoch 5. You can change this to get a different view.
+history_df.loc[5:, ['loss']].plot();
+
+# YOUR CODE HERE: Experiment with different values for the learning rate, batch size, and number of examples
+learning_rate = 0.05
+batch_size = 32
+num_examples = 256
+
+animate_sgd(
+    learning_rate=learning_rate,
+    batch_size=batch_size,
+    num_examples=num_examples,
+    # You can also change these, if you like
+    steps=50, # total training steps (batches seen)
+    true_w=3.0, # the slope of the data
+    true_b=2.0, # the bias of the data
+)

dl2.py

@@ -0,0 +1,108 @@
+import pandas as pd
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+from sklearn.compose import make_column_transformer
+from sklearn.model_selection import GroupShuffleSplit
+
+from tensorflow import keras
+from tensorflow.keras import layers
+from tensorflow.keras import callbacks
+
+spotify = pd.read_csv('../input/dl-course-data/spotify.csv')
+
+X = spotify.copy().dropna()
+y = X.pop('track_popularity')
+artists = X['track_artist']
+
+features_num = ['danceability', 'energy', 'key', 'loudness', 'mode',
+                'speechiness', 'acousticness', 'instrumentalness',
+                'liveness', 'valence', 'tempo', 'duration_ms']
+features_cat = ['playlist_genre']
+
+preprocessor = make_column_transformer(
+    (StandardScaler(), features_num),
+    (OneHotEncoder(), features_cat),
+)
+
+# We'll do a "grouped" split to keep all of an artist's songs in one
+# split or the other. This is to help prevent signal leakage.
+def group_split(X, y, group, train_size=0.75):
+    splitter = GroupShuffleSplit(train_size=train_size)
+    train, test = next(splitter.split(X, y, groups=group))
+    return (X.iloc[train], X.iloc[test], y.iloc[train], y.iloc[test])
+
+X_train, X_valid, y_train, y_valid = group_split(X, y, artists)
+
+X_train = preprocessor.fit_transform(X_train)
+X_valid = preprocessor.transform(X_valid)
+y_train = y_train / 100 # popularity is on a scale 0-100, so this rescales to 0-1.
+y_valid = y_valid / 100
+
+input_shape = [X_train.shape[1]]
+print("Input shape: {}".format(input_shape))
+
+
+model = keras.Sequential([
+    layers.Dense(1, input_shape=input_shape),
+])
+model.compile(
+    optimizer='adam',
+    loss='mae',
+)
+history = model.fit(
+    X_train, y_train,
+    validation_data=(X_valid, y_valid),
+    batch_size=512,
+    epochs=50,
+    verbose=0, # suppress output since we'll plot the curves
+)
+history_df = pd.DataFrame(history.history)
+history_df.loc[0:, ['loss', 'val_loss']].plot()
+print("Minimum Validation Loss: {:0.4f}".format(history_df['val_loss'].min()));
+
+
+model = keras.Sequential([
+    layers.Dense(128, activation='relu', input_shape=input_shape),
+    layers.Dense(64, activation='relu'),
+    layers.Dense(1)
+])
+model.compile(
+    optimizer='adam',
+    loss='mae',
+)
+history = model.fit(
+    X_train, y_train,
+    validation_data=(X_valid, y_valid),
+    batch_size=512,
+    epochs=50,
+)
+history_df = pd.DataFrame(history.history)
+history_df.loc[:, ['loss', 'val_loss']].plot()
+print("Minimum Validation Loss: {:0.4f}".format(history_df['val_loss'].min()));
+
+
+early_stopping = callbacks.EarlyStopping(
+    patience=5,
+    min_delta=0.001,
+    restore_best_weights=True,
+)
+
+
+model = keras.Sequential([
+    layers.Dense(128, activation='relu', input_shape=input_shape),
+    layers.Dense(64, activation='relu'),
+    layers.Dense(1)
+])
+model.compile(
+    optimizer='adam',
+    loss='mae',
+)
+history = model.fit(
+    X_train, y_train,
+    validation_data=(X_valid, y_valid),
+    batch_size=512,
+    epochs=50,
+    callbacks=[early_stopping]
+)
+history_df = pd.DataFrame(history.history)
+history_df.loc[:, ['loss', 'val_loss']].plot()
+print("Minimum Validation Loss: {:0.4f}".format(history_df['val_loss'].min()));

dl3.py

@@ -0,0 +1,133 @@
+import pandas as pd
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+from sklearn.compose import make_column_transformer
+from sklearn.model_selection import GroupShuffleSplit
+
+from tensorflow import keras
+from tensorflow.keras import layers
+from tensorflow.keras import callbacks
+
+spotify = pd.read_csv('../input/dl-course-data/spotify.csv')
+
+X = spotify.copy().dropna()
+y = X.pop('track_popularity')
+artists = X['track_artist']
+
+features_num = ['danceability', 'energy', 'key', 'loudness', 'mode',
+                'speechiness', 'acousticness', 'instrumentalness',
+                'liveness', 'valence', 'tempo', 'duration_ms']
+features_cat = ['playlist_genre']
+
+preprocessor = make_column_transformer(
+    (StandardScaler(), features_num),
+    (OneHotEncoder(), features_cat),
+)
+
+def group_split(X, y, group, train_size=0.75):
+    splitter = GroupShuffleSplit(train_size=train_size)
+    train, test = next(splitter.split(X, y, groups=group))
+    return (X.iloc[train], X.iloc[test], y.iloc[train], y.iloc[test])
+
+X_train, X_valid, y_train, y_valid = group_split(X, y, artists)
+
+X_train = preprocessor.fit_transform(X_train)
+X_valid = preprocessor.transform(X_valid)
+y_train = y_train / 100
+y_valid = y_valid / 100
+
+input_shape = [X_train.shape[1]]
+print("Input shape: {}".format(input_shape))
+
+model = keras.Sequential([
+    layers.Dense(128, activation='relu', input_shape=input_shape),
+    layers.Dropout(0.3),
+    layers.Dense(64, activation='relu'),
+    layers.Dropout(0.3),
+    layers.Dense(1)
+])
+
+model.compile(
+    optimizer='adam',
+    loss='mae',
+)
+history = model.fit(
+    X_train, y_train,
+    validation_data=(X_valid, y_valid),
+    batch_size=512,
+    epochs=50,
+    verbose=0,
+)
+history_df = pd.DataFrame(history.history)
+history_df.loc[:, ['loss', 'val_loss']].plot()
+print("Minimum Validation Loss: {:0.4f}".format(history_df['val_loss'].min()))
+
+
+import pandas as pd
+
+concrete = pd.read_csv('../input/dl-course-data/concrete.csv')
+df = concrete.copy()
+
+df_train = df.sample(frac=0.7, random_state=0)
+df_valid = df.drop(df_train.index)
+
+X_train = df_train.drop('CompressiveStrength', axis=1)
+X_valid = df_valid.drop('CompressiveStrength', axis=1)
+y_train = df_train['CompressiveStrength']
+y_valid = df_valid['CompressiveStrength']
+
+input_shape = [X_train.shape[1]]
+
+
+model = keras.Sequential([
+    layers.Dense(512, activation='relu', input_shape=input_shape),
+    layers.Dense(512, activation='relu'),
+    layers.Dense(512, activation='relu'),
+    layers.Dense(1),
+])
+model.compile(
+    optimizer='sgd', # SGD is more sensitive to differences of scale
+    loss='mae',
+    metrics=['mae'],
+)
+history = model.fit(
+    X_train, y_train,
+    validation_data=(X_valid, y_valid),
+    batch_size=64,
+    epochs=100,
+    verbose=0,
+)
+
+history_df = pd.DataFrame(history.history)
+history_df.loc[0:, ['loss', 'val_loss']].plot()
+print(("Minimum Validation Loss: {:0.4f}").format(history_df['val_loss'].min()))
+
+
+model = keras.Sequential([
+    layers.BatchNormalization(input_shape=input_shape),
+    layers.Dense(512, activation='relu'),
+    layers.BatchNormalization(),
+    layers.Dense(512, activation='relu'),
+    layers.BatchNormalization(),
+    layers.Dense(512, activation='relu'),
+    layers.BatchNormalization(),
+    layers.Dense(1),
+])
+
+
+model.compile(
+    optimizer='sgd',
+    loss='mae',
+    metrics=['mae'],
+)
+EPOCHS = 100
+history = model.fit(
+    X_train, y_train,
+    validation_data=(X_valid, y_valid),
+    batch_size=64,
+    epochs=EPOCHS,
+    verbose=0,
+)
+
+history_df = pd.DataFrame(history.history)
+history_df.loc[0:, ['loss', 'val_loss']].plot()
+print(("Minimum Validation Loss: {:0.4f}").format(history_df['val_loss'].min()))

dl4.py

@@ -0,0 +1,92 @@
+import pandas as pd
+
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+from sklearn.impute import SimpleImputer
+from sklearn.pipeline import make_pipeline
+from sklearn.compose import make_column_transformer
+
+hotel = pd.read_csv('../input/dl-course-data/hotel.csv')
+
+X = hotel.copy()
+y = X.pop('is_canceled')
+
+X['arrival_date_month'] = \
+    X['arrival_date_month'].map(
+        {'January':1, 'February': 2, 'March':3,
+         'April':4, 'May':5, 'June':6, 'July':7,
+         'August':8, 'September':9, 'October':10,
+         'November':11, 'December':12}
+    )
+
+features_num = [
+    "lead_time", "arrival_date_week_number",
+    "arrival_date_day_of_month", "stays_in_weekend_nights",
+    "stays_in_week_nights", "adults", "children", "babies",
+    "is_repeated_guest", "previous_cancellations",
+    "previous_bookings_not_canceled", "required_car_parking_spaces",
+    "total_of_special_requests", "adr",
+]
+features_cat = [
+    "hotel", "arrival_date_month", "meal",
+    "market_segment", "distribution_channel",
+    "reserved_room_type", "deposit_type", "customer_type",
+]
+
+transformer_num = make_pipeline(
+    SimpleImputer(strategy="constant"), # there are a few missing values
+    StandardScaler(),
+)
+transformer_cat = make_pipeline(
+    SimpleImputer(strategy="constant", fill_value="NA"),
+    OneHotEncoder(handle_unknown='ignore'),
+)
+
+preprocessor = make_column_transformer(
+    (transformer_num, features_num),
+    (transformer_cat, features_cat),
+)
+
+# stratify - make sure classes are evenlly represented across splits
+X_train, X_valid, y_train, y_valid = \
+    train_test_split(X, y, stratify=y, train_size=0.75)
+
+X_train = preprocessor.fit_transform(X_train)
+X_valid = preprocessor.transform(X_valid)
+
+input_shape = [X_train.shape[1]]
+
+from tensorflow import keras
+from tensorflow.keras import layers
+
+model = keras.Sequential([
+    layers.BatchNormalization(input_shape=input_shape),
+    layers.Dense(256, activation='relu'),
+    layers.BatchNormalization(),
+    layers.Dropout(0.3),
+    layers.Dense(256, activation='relu'),
+    layers.BatchNormalization(),
+    layers.Dropout(0.3),
+    layers.Dense(1, activation='sigmoid')
+])
+model.compile(
+    optimizer='adam',
+    loss='binary_crossentropy',
+    metrics=['binary_accuracy'],
+)
+early_stopping = keras.callbacks.EarlyStopping(
+    patience=5,
+    min_delta=0.001,
+    restore_best_weights=True,
+)
+history = model.fit(
+    X_train, y_train,
+    validation_data=(X_valid, y_valid),
+    batch_size=512,
+    epochs=200,
+    callbacks=[early_stopping],
+)
+
+history_df = pd.DataFrame(history.history)
+history_df.loc[:, ['loss', 'val_loss']].plot(title="Cross-entropy")
+history_df.loc[:, ['binary_accuracy', 'val_binary_accuracy']].plot(title="Accuracy")

random_forest_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e2f05c9a67688563b18f755aa4bc75c3daa19bd91f92af80ba3cbde89ab710e
+size 37522105

test.py

@@ -0,0 +1,77 @@
+import pefile
+import tkinter as tk
+from tkinter import filedialog
+
+def extract_pe_info(file_path):
+    try:
+        pe = pefile.PE(file_path)
+        info = {
+            'AddressOfEntryPoint': hex(pe.OPTIONAL_HEADER.AddressOfEntryPoint),
+            'MajorLinkerVersion': pe.OPTIONAL_HEADER.MajorLinkerVersion,
+            'MajorImageVersion': pe.OPTIONAL_HEADER.MajorImageVersion,
+            'MajorOperatingSystemVersion': pe.OPTIONAL_HEADER.MajorOperatingSystemVersion,
+            'DllCharacteristics': hex(pe.OPTIONAL_HEADER.DllCharacteristics),
+            'SizeOfStackReserve': pe.OPTIONAL_HEADER.SizeOfStackReserve,
+            'NumberOfSections': pe.FILE_HEADER.NumberOfSections,
+            'SizeOfImage': pe.OPTIONAL_HEADER.SizeOfImage,
+            'SizeOfHeaders': pe.OPTIONAL_HEADER.SizeOfHeaders,
+            'Subsystem': pe.OPTIONAL_HEADER.Subsystem,
+            'Magic': pe.FILE_HEADER.Machine,
+            'Characteristics': hex(pe.FILE_HEADER.Characteristics),
+            'TimeDateStamp': pe.FILE_HEADER.TimeDateStamp,
+            'ImageBase': hex(pe.OPTIONAL_HEADER.ImageBase),
+            'CheckSum': pe.OPTIONAL_HEADER.CheckSum,
+
+            'SizeOfCode': pe.OPTIONAL_HEADER.SizeOfCode,
+            'SizeOfInitializedData': pe.OPTIONAL_HEADER.SizeOfInitializedData,
+            'SizeOfUninitializedData': pe.OPTIONAL_HEADER.SizeOfUninitializedData,
+            'AddressOfEntryPoint': hex(pe.OPTIONAL_HEADER.AddressOfEntryPoint),
+
+            'ImageBase': hex(pe.OPTIONAL_HEADER.ImageBase),
+
+            'MajorImageVersion': pe.OPTIONAL_HEADER.MajorImageVersion,
+            'MajorSubsystemVersion': pe.OPTIONAL_HEADER.MajorSubsystemVersion,
+
+            'SizeOfImage': pe.OPTIONAL_HEADER.SizeOfImage,
+            'SizeOfHeaders': pe.OPTIONAL_HEADER.SizeOfHeaders,
+            'Subsystem': pe.OPTIONAL_HEADER.Subsystem,
+
+            'SizeOfHeapReserve': pe.OPTIONAL_HEADER.SizeOfHeapReserve,
+
+            'NumberOfRvaAndSizes': pe.OPTIONAL_HEADER.NumberOfRvaAndSizes,
+            'DataDirectory': pe.OPTIONAL_HEADER.DATA_DIRECTORY,
+        }
+        return info
+    except Exception as e:
+        return str(e)
+
+def inspect_pe_attributes(file_path):
+    try:
+        pe = pefile.PE(file_path)
+        # Récupérer la liste des entrées DATA_DIRECTORY
+        data_directory_entries = pe.OPTIONAL_HEADER.DATA_DIRECTORY
+
+        # Parcourir la liste pour trouver l'entrée du répertoire des ressources
+        for entry in data_directory_entries:
+            if entry.name == "IMAGE_DIRECTORY_ENTRY_RESOURCE":
+                resource_size = entry.Size
+                return resource_size
+    except Exception as e:
+        return f"Erreur d'inspection du fichier {file_path}: {str(e)}"
+
+
+
+def upload_file():
+    file_path = filedialog.askopenfilename()
+    if file_path:
+        pe_info = extract_pe_info(file_path)
+        print(pe_info)
+
+# Création de l'interface graphique
+root = tk.Tk()
+root.title("PE File Info Extractor")
+
+upload_button = tk.Button(root, text="Upload PE File", command=upload_file)
+upload_button.pack(pady=20)
+
+root.mainloop()