testing code.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__CUDNN VERSION: 8700\n",
      "__Number CUDA Devices: 1\n",
      "__CUDA Device Name: NVIDIA GeForce GTX 1650\n",
      "__CUDA Device Total Memory [GB]: 4.294639616\n"
     ]
    }
   ],
   "source": [
    "import GPUtil\n",
    "GPUtil.getAvailable()\n",
    "import torch\n",
    "use_cuda = torch.cuda.is_available()\n",
    "if use_cuda:\n",
    "    print('__CUDNN VERSION:', torch.backends.cudnn.version())\n",
    "    print('__Number CUDA Devices:', torch.cuda.device_count())\n",
    "    print('__CUDA Device Name:',torch.cuda.get_device_name(0))\n",
    "    print('__CUDA Device Total Memory [GB]:',torch.cuda.get_device_properties(0).total_memory/1e9)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "tf.config.list_physical_devices('GPU')\n",
    "\n",
    "config = tf.compat.v1.ConfigProto()\n",
    "config.gpu_options.allow_growth = True  \n",
    "config.gpu_options.visible_device_list = \"0\" \n",
    "\n",
    "session = tf.compat.v1.Session(config=config)\n",
    "tf.compat.v1.keras.backend.set_session(session)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Selected device: cuda\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "\n",
    "torch.cuda.is_available()\n",
    "\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(\"Selected device:\", device)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.15.0\n",
      "Num GPUs Available:  0\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "print(tf.version.VERSION)\n",
    "\n",
    "print(\"Num GPUs Available: \", len(tf.config.list_physical_devices('GPU')))\n",
    "\n",
    "gpus = tf.config.list_physical_devices('GPU')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pathlib\n",
    "import textwrap\n",
    "\n",
    "import google.generativeai as genai\n",
    "\n",
    "# Used to securely store your API key\n",
    "#from google.colab import userdata\n",
    "\n",
    "from IPython.display import display\n",
    "from IPython.display import Markdown\n",
    "\n",
    "\n",
    "def to_markdown(text):\n",
    "  text = text.replace('•', '  *')\n",
    "  return Markdown(textwrap.indent(text, '> ', predicate=lambda _: True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Or use `os.getenv('GOOGLE_API_KEY')` to fetch an environment variable.\n",
    "GOOGLE_API_KEY='AIzaSyBT8sq4Qpu7ftDbbhiqXZ7rNTFsDcD_S-U'\n",
    "\n",
    "genai.configure(api_key=GOOGLE_API_KEY)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "models/gemini-pro\n",
      "models/gemini-pro-vision\n"
     ]
    }
   ],
   "source": [
    "for m in genai.list_models():\n",
    "  if 'generateContent' in m.supported_generation_methods:\n",
    "    print(m.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = genai.GenerativeModel('gemini-pro')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "response = model.generate_content(\"What is the meaning of life?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "> There is no single, universally accepted answer to the question of the meaning of life. Different people have different beliefs and values, and as a result, they may have different interpretations of what gives their lives meaning.\n",
       "> \n",
       "> Some people believe that the meaning of life is to find happiness and fulfillment. They may pursue this goal through personal relationships, career success, hobbies, or other activities that bring them joy. Others believe that the meaning of life is to make a difference in the world. They may volunteer their time to help others, work to promote social justice, or create art or music that inspires people.\n",
       "> \n",
       "> Still, others believe that the meaning of life is to connect with something greater than themselves. They may find meaning through religion, spirituality, or nature. They may believe that their lives are part of a larger plan or purpose, and that they are here to learn and grow and evolve.\n",
       "> \n",
       "> Ultimately, the meaning of life is a personal question that each individual must answer for themselves. There is no right or wrong answer, and what gives one person meaning may not give another person meaning. The important thing is to find something that gives your life purpose and direction, and to live your life in a way that is true to yourself.\n",
       "> \n",
       "> Here are some additional perspectives on the meaning of life:\n",
       "> \n",
       "> * The ancient Greek philosopher Aristotle believed that the meaning of life is to live in accordance with virtue. He believed that people should strive to develop their rational faculties and to live a life of reason and moderation.\n",
       "> * The Buddha believed that the meaning of life is to end suffering. He taught that the root of all suffering is attachment, and that the way to end suffering is to let go of our attachments.\n",
       "> * The Christian theologian Augustine believed that the meaning of life is to love God and to love others. He believed that God created us to love and be loved, and that our purpose in life is to fulfill that love.\n",
       "> * The modern philosopher Jean-Paul Sartre believed that the meaning of life is to create our own meaning. He believed that we are all free to choose our own values and to live our lives in accordance with those values.\n",
       "> * The contemporary philosopher Kwame Anthony Appiah believes that the meaning of life is to find a way to contribute to the flourishing of our communities. He believes that we should all strive to make the world a better place for everyone.\n",
       "> \n",
       "> These are just a few of the many different perspectives on the meaning of life. There is no one right answer, and what gives one person meaning may not give another person meaning. The important thing is to find something that gives your life purpose and direction, and to live your life in a way that is true to yourself."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "to_markdown(response.text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pandas Lib Version: 2.1.2\n",
      "Numpy Lib Version: 1.24.3\n",
      "matPlotlib Lib Version: 3.8.1\n",
      "Science Kit Learn Lib Version: 1.3.2\n",
      "imbLearn SMOTE Version: 0.11.0\n",
      "tensorFlow Version: 2.15.0\n",
      "Keras Version: 2.15.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SHAP Version: 0.44.0\n",
      "Seaborn Version: 0.13.0\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "print(\"Pandas Lib Version: {}\".format(pd.__version__))\n",
    "import numpy as np\n",
    "print(\"Numpy Lib Version: {}\".format(np.__version__))\n",
    "import matplotlib\n",
    "print(\"matPlotlib Lib Version: {}\".format(matplotlib.__version__))\n",
    "import matplotlib.pyplot as mplot\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as patches\n",
    "\n",
    "from matplotlib.colors import ListedColormap\n",
    "import os\n",
    "import subprocess\n",
    "import sklearn\n",
    "\n",
    "print(\"Science Kit Learn Lib Version: {}\".format(sklearn.__version__))\n",
    "\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.datasets import load_files\n",
    "from sklearn.feature_extraction.text import TfidfTransformer\n",
    "from sklearn.model_selection import train_test_split, KFold\n",
    "from sklearn.metrics import classification_report, confusion_matrix, ConfusionMatrixDisplay, accuracy_score, f1_score, precision_score, recall_score,  precision_recall_fscore_support\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.metrics import roc_curve\n",
    " \n",
    "import random\n",
    " \n",
    "\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "\n",
    "import imblearn\n",
    "from imblearn.under_sampling import RandomUnderSampler\n",
    "from imblearn.over_sampling import SMOTE\n",
    "\n",
    "print(\"imbLearn SMOTE Version: {}\".format(imblearn.__version__))\n",
    "\n",
    "import tensorflow as tf\n",
    "print(\"tensorFlow Version: {}\".format(tf.__version__))\n",
    "import keras\n",
    "print(\"Keras Version: {}\".format(keras.__version__))\n",
    "from keras import Sequential\n",
    "from keras.layers import Dense, Dropout\n",
    "from keras.utils import to_categorical\n",
    "from keras.datasets import mnist\n",
    "from keras.utils import plot_model\n",
    "\n",
    "\n",
    "import pickle \n",
    "\n",
    "\n",
    "import shap\n",
    "print(\"SHAP Version: {}\".format(shap.__version__))\n",
    "\n",
    "import lime\n",
    "from lime import lime_tabular\n",
    "import random\n",
    "\n",
    "import dalex as dx \n",
    "\n",
    "from sklearn.tree import export_graphviz\n",
    "import pydotplus\n",
    "import seaborn as sns\n",
    "print(\"Seaborn Version: {}\".format(sns.__version__))\n",
    " \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}