#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import graphviz
  import matplotlib
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("graphviz version: {}".format(graphviz.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))

!pip install scikit-learn==1.5.1

# Import necessary libraries
  from sklearn.datasets import load_breast_cancer
  from sklearn.model_selection import train_test_split
  from sklearn.tree import DecisionTreeClassifier
  from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
  
  # Load the Breast Cancer Wisconsin dataset
  data = load_breast_cancer()
  X = data.data
  y = data.target
  
  # Split the dataset into training and testing sets
  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
  
  # Initialize the Decision Tree Classifier
  clf = DecisionTreeClassifier(random_state=42)
  
  # Train the model
  clf.fit(X_train, y_train)
  
  # Make predictions on the test set
  y_pred = clf.predict(X_test)
  
  # Evaluate the model
  accuracy = accuracy_score(y_test, y_pred)
  print(f"Accuracy: {accuracy:.2f}")
  
  print("Classification Report:")
  print(classification_report(y_test, y_pred, target_names=data.target_names))
  
  print("Confusion Matrix:")
  print(confusion_matrix(y_test, y_pred))

#!pip install graphviz==0.20.1 #doesn't seem to work properly on Windows at the moment

!pip install matplotlib==3.9.2

import sklearn
  import graphviz
  import matplotlib
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("graphviz version: {}".format(graphviz.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))

from sklearn.datasets import load_iris
  from sklearn import tree
  iris = load_iris()
  X, y = iris.data, iris.target
  clf = tree.DecisionTreeClassifier()
  clf = clf.fit(X, y)

tree.plot_tree(clf)

import graphviz 
  dot_data = tree.export_graphviz(clf, out_file=None) 
  graph = graphviz.Source(dot_data) 
  graph.render("iris")

dot_data = tree.export_graphviz(clf, out_file=None, 
                       feature_names=iris.feature_names,  
                       class_names=iris.target_names,  
                       filled=True, rounded=True,  
                       special_characters=True)  
  graph = graphviz.Source(dot_data)  
  graph

clf.score(X, y)

from sklearn.model_selection import train_test_split
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
  
  clf = tree.DecisionTreeClassifier(random_state=0)
  clf = clf.fit(X_train, y_train)
  
  clf.score(X_train, y_train)

clf.score(X_test, y_test)

clf.score(X, y)

from sklearn.metrics import confusion_matrix
  y_pred = clf.predict(X_test)
  cm = confusion_matrix(y_test, y_pred)
  cm

tree.plot_tree(clf)

import graphviz 
  dot_data = tree.export_graphviz(clf, out_file=None) 
  graph = graphviz.Source(dot_data) 
  graph.render("iris")

dot_data = tree.export_graphviz(clf, out_file=None, 
                       feature_names=iris.feature_names,  
                       class_names=iris.target_names,  
                       filled=True, rounded=True,  
                       special_characters=True)  
  graph = graphviz.Source(dot_data)  
  graph

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

!pip install scikit-learn==1.5.1

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

from sklearn.datasets import load_iris
  from sklearn.linear_model import LogisticRegression
  X, y = load_iris(return_X_y=True)
  clf = LogisticRegression(random_state=0).fit(X, y)
  clf.predict(X[:2, :])

clf.predict_proba(X[:2, :])

clf.score(X, y)

from sklearn.model_selection import train_test_split
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
  
  clf = LogisticRegression(random_state=0)
  clf = clf.fit(X_train, y_train)
  
  clf.score(X_train, y_train)

clf.score(X_test, y_test)

clf.score(X, y)

from sklearn.metrics import confusion_matrix
  y_pred = clf.predict(X_test)
  cm = confusion_matrix(y_test, y_pred)
  cm

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

!pip install scikit-learn==1.5.1

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

from sklearn.datasets import load_iris
  from sklearn.model_selection import train_test_split
  from sklearn.naive_bayes import GaussianNB
  X, y = load_iris(return_X_y=True)
  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=0)
  gnb = GaussianNB()
  y_pred = gnb.fit(X_train, y_train).predict(X_test)
  print("Number of mislabeled points out of a total %d points : %d" % (X_test.shape[0], (y_test != y_pred).sum()))

gnb.score(X_train, y_train)

gnb.score(X_test, y_test)

gnb.score(X, y)

from sklearn.metrics import confusion_matrix
  y_pred = gnb.predict(X_test)
  cm = confusion_matrix(y_test, y_pred)
  cm

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

!pip install scikit-learn==1.5.1

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

from sklearn import svm
  X = [[0, 0], [1, 1]]
  y = [0, 1]
  clf = svm.SVC()
  clf.fit(X, y)

clf.predict([[2., 2.]])

clf.score(X, y)

from sklearn.model_selection import train_test_split
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
  
  clf = svm.SVC(random_state=0)
  clf = clf.fit(X_train, y_train)
  
  clf.score(X_train, y_train)

X_train

X_test

y_train

y_test

X = [[0, 0], [1, 1], [0, 0], [1, 1], [0, 0], [1, 1]]
  y = [0, 1, 0, 1, 0, 1]

from sklearn.model_selection import train_test_split
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

y_train

clf = svm.SVC(random_state=0)
  clf = clf.fit(X_train, y_train)
  
  clf.score(X_train, y_train)

clf.score(X_test, y_test)

from sklearn.datasets import load_iris
  from sklearn.model_selection import train_test_split
  
  iris = load_iris()
  X, y = iris.data, iris.target
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

X_train[:3]

clf = svm.SVC(random_state=0)
  clf = clf.fit(X_train, y_train)

clf.score(X_test, y_test)

from sklearn.metrics import confusion_matrix
  y_pred = clf.predict(X_test)
  cm = confusion_matrix(y_test, y_pred)
  cm

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

!pip install scikit-learn==1.5.1

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

from sklearn.linear_model import SGDClassifier
  X = [[0., 0.], [1., 1.]]
  y = [0, 1]
  clf = SGDClassifier(loss="hinge", penalty="l2", max_iter=5)
  clf.fit(X, y)

clf.predict([[2., 2.]])

clf.score(X, y)

from sklearn.model_selection import train_test_split
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
  
  clf = SGDClassifier(random_state=0)
  clf = clf.fit(X_train, y_train)
  
  clf.score(X_train, y_train)

X = [[0, 0], [1, 1], [0, 0], [1, 1], [0, 0], [1, 1]]
  y = [0, 1, 0, 1, 0, 1]

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

y_train

clf = SGDClassifier(random_state=0)
  clf = clf.fit(X_train, y_train)
  
  clf.score(X_train, y_train)

clf.score(X_test, y_test)

from sklearn.datasets import load_iris
  
  iris = load_iris()
  X, y = iris.data, iris.target
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

X_train[:3]

clf = SGDClassifier(random_state=0)
  clf = clf.fit(X_train, y_train)

clf.score(X_test, y_test)

from sklearn.metrics import confusion_matrix
  y_pred = clf.predict(X_test)
  cm = confusion_matrix(y_test, y_pred)
  cm

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

!pip install scikit-learn==1.5.1

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

X = [[0], [1], [2], [3]]
  y = [0, 0, 1, 1]
  from sklearn.neighbors import KNeighborsClassifier
  neigh = KNeighborsClassifier(n_neighbors=3)
  neigh.fit(X, y)

print(neigh.predict([[1.1]]))
  print(neigh.predict_proba([[0.9]]))

neigh.score(X, y)

X = [[0], [1], [2], [3]]
  y = [0, 0, 1, 1]
  
  from sklearn.model_selection import train_test_split
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
  
  clf = KNeighborsClassifier(n_neighbors=3)
  clf = clf.fit(X_train, y_train)
  
  clf.score(X_train, y_train)

clf.score(X_test, y_test)

y_train

y_test

print('For {} I predict {} and for real it is {}.'.format(X_train[0],clf.predict([X_train[0]]), y_train[0]))
  print('For {} I predict {} and for real it is {}.'.format(X_train[1],clf.predict([X_train[1]]), y_train[1]))
  print('For {} I predict {} and for real it is {}.'.format(X_train[2],clf.predict([X_train[2]]), y_train[2]))

print('For {} I predict {} and for real it is {}.'.format(X_test[0],clf.predict([X_test[0]]), y_test[0]))

clf.score(X_test, y_test)

print(clf.predict([[1.1]]))
  print(clf.predict_proba([[0.9]]))

print(clf.predict([[3.1]]))
  print(clf.predict_proba([[4.9]]))

from sklearn.datasets import load_iris
  
  iris = load_iris()
  X, y = iris.data, iris.target
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

X_train[:3]

clf = KNeighborsClassifier(n_neighbors=3)
  clf = clf.fit(X_train, y_train)

clf.score(X_test, y_test)

from sklearn.metrics import confusion_matrix
  y_pred = clf.predict(X_test)
  cm = confusion_matrix(y_test, y_pred)
  cm

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

!pip install scikit-learn==1.5.1

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

from sklearn.ensemble import RandomForestClassifier
  from sklearn.datasets import make_classification
  X, y = make_classification(n_samples=1000, n_features=4,
                             n_informative=2, n_redundant=0,
                             random_state=0, shuffle=False)
  clf = RandomForestClassifier(max_depth=2, random_state=0)
  clf.fit(X, y)

print(clf.predict([[0, 0, 0, 0]]))

clf.score(X, y)

help(clf)

from sklearn.model_selection import train_test_split
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
  
  clf = RandomForestClassifier(max_depth=2, random_state=0)
  clf = clf.fit(X_train, y_train)
  
  clf.score(X_train, y_train)

clf.score(X_test, y_test)

from sklearn.datasets import load_iris
  
  iris = load_iris()
  X, y = iris.data, iris.target
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

X_train[:3]

clf = RandomForestClassifier(max_depth=2, random_state=0)
  clf = clf.fit(X_train, y_train)

clf.score(X_test, y_test)

from sklearn.metrics import confusion_matrix
  y_pred = clf.predict(X_test)
  cm = confusion_matrix(y_test, y_pred)
  cm

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

!pip install scikit-learn==1.5.1

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

from sklearn.ensemble import BaggingClassifier
  from sklearn.neighbors import KNeighborsClassifier
  bagging = BaggingClassifier(KNeighborsClassifier(), max_samples=0.5, max_features=0.5)

from sklearn.datasets import load_iris
  X, y = load_iris(return_X_y=True)

from sklearn.model_selection import cross_val_score
  scores = cross_val_score(bagging, X, y, cv=5)
  scores.mean()

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

!pip install scikit-learn==1.5.1

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

from sklearn.datasets import make_hastie_10_2
  from sklearn.ensemble import GradientBoostingClassifier

X, y = make_hastie_10_2(random_state=0)
  X_train, X_test = X[:2000], X[2000:]
  y_train, y_test = y[:2000], y[2000:]

clf = GradientBoostingClassifier(n_estimators=100, learning_rate=1.0,
      max_depth=1, random_state=0).fit(X_train, y_train)

clf.score(X_test, y_test)

from sklearn.datasets import load_iris
  from sklearn.model_selection import train_test_split
  
  iris = load_iris()
  X, y = iris.data, iris.target
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

X_train[:3]

clf = GradientBoostingClassifier(n_estimators=100, learning_rate=1.0,
      max_depth=1, random_state=0).fit(X_train, y_train)

clf.score(X_test, y_test)

from sklearn.metrics import confusion_matrix
  y_pred = clf.predict(X_test)
  cm = confusion_matrix(y_test, y_pred)
  cm

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import xgboost
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("xgboost version: {}".format(xgboost.__version__))

!pip install scikit-learn==1.5.1

!pip install xgboost==2.1.0

import sklearn
  import xgboost
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("xgboost version: {}".format(xgboost.__version__))

from xgboost import XGBClassifier
  # read data
  from sklearn.datasets import load_iris
  from sklearn.model_selection import train_test_split
  data = load_iris()
  X_train, X_test, y_train, y_test = train_test_split(data['data'], data['target'], test_size=.2)
  # create model instance
  bst = XGBClassifier(n_estimators=2, max_depth=2, learning_rate=1, objective='binary:logistic')
  # fit model
  bst.fit(X_train, y_train)
  # make predictions
  preds = bst.predict(X_test)

bst.score(X_test, y_test)

bst = XGBClassifier(n_estimators=20, max_depth=20, learning_rate=1, objective='binary:logistic')
  # fit model
  bst.fit(X_train, y_train)
  # make predictions
  bst.score(X_test, y_test)

from sklearn.metrics import confusion_matrix
  y_pred = bst.predict(X_test)
  cm = confusion_matrix(y_test, y_pred)
  cm

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import lightgbm as lgb
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("lightgbm version: {}".format(lgb.__version__))
  print("numpy version: {}".format(np.__version__))

!pip install scikit-learn==1.5.1

!pip install lightgbm==4.4.0

!pip install numpy==2.0.0

import sklearn
  import lightgbm as lgb
  import numpy as np
  import sys
  
  print("Python version: {}".format(sys.version))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("lightgbm version: {}".format(lgb.__version__))
  print("numpy version: {}".format(np.__version__))

import lightgbm as lgb

import numpy as np

from sklearn.datasets import load_iris
  from sklearn.model_selection import train_test_split
  iris = load_iris()
  X, y = iris.data, iris.target
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

len(X_test)

clf = lgb.LGBMClassifier()

clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)

clf.score(X_test, y_test)

from sklearn.metrics import confusion_matrix
  cm = confusion_matrix(y_test, y_pred)
  cm

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

!pip install scikit-learn==1.5.1

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

from sklearn.ensemble import AdaBoostClassifier
  from sklearn.datasets import make_classification
  X, y = make_classification(n_samples=1000, n_features=4,
                             n_informative=2, n_redundant=0,
                             random_state=0, shuffle=False)
  clf = AdaBoostClassifier(n_estimators=100, random_state=0)
  clf.fit(X, y)

clf.predict([[0, 0, 0, 0]])

clf.score(X, y)

from sklearn.model_selection import cross_val_score
  from sklearn.datasets import load_iris
  from sklearn.ensemble import AdaBoostClassifier
  
  X, y = load_iris(return_X_y=True)
  clf = AdaBoostClassifier(n_estimators=100)
  scores = cross_val_score(clf, X, y, cv=5)
  scores.mean()

X, y = make_classification(n_samples=1000, n_features=4,
                             n_informative=2, n_redundant=0,
                             random_state=0, shuffle=False)
  
  from sklearn.model_selection import train_test_split
  
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
  
  clf = AdaBoostClassifier(n_estimators=100, random_state=0)
  clf = clf.fit(X_train, y_train)
  
  clf.score(X_train, y_train)

clf.score(X_test, y_test)

X, y = load_iris(return_X_y=True)
  
  from sklearn.model_selection import train_test_split
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
  
  clf = AdaBoostClassifier(n_estimators=100, random_state=0)
  clf = clf.fit(X_train, y_train)
  
  clf.score(X_train, y_train)

clf.score(X_test, y_test)

from sklearn.metrics import confusion_matrix
  y_pred = clf.predict(X_test)
  cm = confusion_matrix(y_test, y_pred)
  cm

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import matplotlib
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))

!pip install scikit-learn==1.5.1

!pip install matplotlib==3.9.2

import sklearn
  import matplotlib
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))

from sklearn import datasets
  from sklearn.model_selection import cross_val_score
  from sklearn.linear_model import LogisticRegression
  from sklearn.naive_bayes import GaussianNB
  from sklearn.ensemble import RandomForestClassifier
  from sklearn.ensemble import VotingClassifier
  
  iris = datasets.load_iris()
  X, y = iris.data[:, 1:3], iris.target
  
  clf1 = LogisticRegression(random_state=1)
  clf2 = RandomForestClassifier(n_estimators=50, random_state=1)
  clf3 = GaussianNB()
  
  eclf = VotingClassifier(
       estimators=[('lr', clf1), ('rf', clf2), ('gnb', clf3)],
       voting='hard')
  
  for clf, label in zip([clf1, clf2, clf3, eclf], ['Logistic Regression', 'Random Forest', 'naive Bayes', 'Ensemble']):
      scores = cross_val_score(clf, X, y, scoring='accuracy', cv=5)
      print("Accuracy: %0.2f (+/- %0.2f) [%s]" % (scores.mean(), scores.std(), label))

from itertools import product
  
  import matplotlib.pyplot as plt
  
  from sklearn import datasets
  from sklearn.ensemble import VotingClassifier
  from sklearn.inspection import DecisionBoundaryDisplay
  from sklearn.neighbors import KNeighborsClassifier
  from sklearn.svm import SVC
  from sklearn.tree import DecisionTreeClassifier
  
  # Loading some example data
  iris = datasets.load_iris()
  X = iris.data[:, [0, 2]]
  y = iris.target
  
  # Training classifiers
  clf1 = DecisionTreeClassifier(max_depth=4)
  clf2 = KNeighborsClassifier(n_neighbors=7)
  clf3 = SVC(gamma=0.1, kernel="rbf", probability=True)
  eclf = VotingClassifier(
      estimators=[("dt", clf1), ("knn", clf2), ("svc", clf3)],
      voting="soft",
      weights=[2, 1, 2],
  )
  
  clf1.fit(X, y)
  clf2.fit(X, y)
  clf3.fit(X, y)
  eclf.fit(X, y)
  
  # Plotting decision regions
  f, axarr = plt.subplots(2, 2, sharex="col", sharey="row", figsize=(10, 8))
  for idx, clf, tt in zip(
      product([0, 1], [0, 1]),
      [clf1, clf2, clf3, eclf],
      ["Decision Tree (depth=4)", "KNN (k=7)", "Kernel SVM", "Soft Voting"],
  ):
      DecisionBoundaryDisplay.from_estimator(
          clf, X, alpha=0.4, ax=axarr[idx[0], idx[1]], response_method="predict"
      )
      axarr[idx[0], idx[1]].scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor="k")
      axarr[idx[0], idx[1]].set_title(tt)
  
  plt.show()

for clf, label in zip([clf1, clf2, clf3, eclf], ['Decision Trees', 'KNeighborsClassifier', 'SVC', 'Ensemble']):
      scores = cross_val_score(clf, X, y, scoring='accuracy', cv=5)
      print("Accuracy: %0.2f (+/- %0.2f) [%s]" % (scores.mean(), scores.std(), label))

iris = datasets.load_iris()
  X, y = iris.data[:, 1:3], iris.target
  X.shape

#download dataset
  from sklearn.datasets import load_iris
  from sklearn.model_selection import train_test_split
  
  iris = load_iris()
  X, y = iris.data, iris.target
  
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
  
  X.shape

from sklearn import datasets
  from sklearn.model_selection import cross_val_score
  from sklearn.ensemble import VotingClassifier
  
  #import all machine learning libraries
  from sklearn import tree #Decision Trees
  from sklearn.linear_model import LogisticRegression #Logistic Regression
  from sklearn.naive_bayes import GaussianNB #Naive Bayes
  from sklearn import svm #Support Vector Machine
  from sklearn.linear_model import SGDClassifier #Stochastic Gradient Descent
  from sklearn.neighbors import KNeighborsClassifier #K-Nearest Neighbours
  from sklearn.ensemble import RandomForestClassifier #Random Forest Classifier
  from sklearn.ensemble import BaggingClassifier #Bagging Classifier
  from sklearn.ensemble import GradientBoostingClassifier #Gradient Boosting Classifier
  from sklearn.ensemble import AdaBoostClassifier #AdaBoost Classifier
  #from xgboost import XGBClassifier #XGBoost Classifier
  #import lightgbm as lgb #light GBM
  
  #start all classifiers
  clf1 = tree.DecisionTreeClassifier()
  clf2 = LogisticRegression(random_state=1)
  clf3 = GaussianNB()
  clf4 = svm.SVC(random_state=0)
  clf5 = SGDClassifier(loss="hinge", penalty="l2", max_iter=5)
  clf6 = KNeighborsClassifier(n_neighbors=3)
  clf7 = RandomForestClassifier(n_estimators=50, random_state=1)
  clf8 = BaggingClassifier(KNeighborsClassifier(), max_samples=0.5, max_features=0.5, random_state=0)
  clf9 = GradientBoostingClassifier(n_estimators=100, learning_rate=1.0,
      max_depth=1, random_state=0).fit(X_train, y_train)
  #clf10 = XGBClassifier(n_estimators=20, max_depth=20, learning_rate=1, objective='binary:logistic')
  #clf11 = lgb.LGBMClassifier()
  clf12 = AdaBoostClassifier(n_estimators=100, random_state=0)
  
  
  eclf = VotingClassifier(
       estimators=[('dt', clf1), ('lr', clf2), ('gnb', clf3), ('svc', clf4), ('sgd', clf5), ('knn', clf6), 
                   ('rf', clf7), ('bc', clf8), ('gbc', clf9), ('ada', clf12)],
       voting='hard')
  
  for clf, label in zip([clf1, clf2, clf3, clf4, clf5, clf6, clf7, clf8, clf9, clf12, eclf], 
                        ['Decision Trees', 'Logistic Regression', 'naive Bayes', 'SVC', 'SGD', 'KNN', 'Random Forest',
                         'Bagging', 'Gradient Boosting', 'AdaBoost', 'Ensemble']):
      scores = cross_val_score(clf, X, y, scoring='accuracy', cv=5)
      print("Accuracy: %0.2f (+/- %0.2f) [%s]" % (scores.mean(), scores.std(), label))

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))
  print("numpy version: {}".format(np.__version__))

!pip install scikit-learn==1.5.1

!pip install matplotlib==3.9.2

!pip install numpy==2.0.0

import sklearn
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))
  print("numpy version: {}".format(np.__version__))

from sklearn.datasets import make_classification
  from sklearn.multioutput import MultiOutputClassifier
  from sklearn.ensemble import RandomForestClassifier
  from sklearn.utils import shuffle
  import numpy as np
  X, y1 = make_classification(n_samples=10, n_features=100, n_informative=30, n_classes=3, random_state=1)
  y2 = shuffle(y1, random_state=1)
  y3 = shuffle(y1, random_state=2)
  Y = np.vstack((y1, y2, y3)).T
  n_samples, n_features = X.shape # 10,100
  n_outputs = Y.shape[1] # 3
  n_classes = 3
  forest = RandomForestClassifier(random_state=1)
  multi_target_forest = MultiOutputClassifier(forest, n_jobs=2)
  multi_target_forest.fit(X, Y).predict(X)

import matplotlib.pyplot as plt
  import numpy as np
  
  from sklearn.datasets import fetch_olivetti_faces
  from sklearn.ensemble import ExtraTreesRegressor
  from sklearn.linear_model import LinearRegression, RidgeCV
  from sklearn.neighbors import KNeighborsRegressor
  from sklearn.utils.validation import check_random_state
  
  # Load the faces datasets
  data, targets = fetch_olivetti_faces(return_X_y=True)
  
  train = data[targets < 30]
  test = data[targets >= 30]  # Test on independent people
  
  # Test on a subset of people
  n_faces = 5
  rng = check_random_state(4)
  face_ids = rng.randint(test.shape[0], size=(n_faces,))
  test = test[face_ids, :]
  
  n_pixels = data.shape[1]
  # Upper half of the faces
  X_train = train[:, : (n_pixels + 1) // 2]
  # Lower half of the faces
  y_train = train[:, n_pixels // 2 :]
  X_test = test[:, : (n_pixels + 1) // 2]
  y_test = test[:, n_pixels // 2 :]
  
  # Fit estimators
  ESTIMATORS = {
      "Extra trees": ExtraTreesRegressor(
          n_estimators=10, max_features=32, random_state=0
      ),
      "K-nn": KNeighborsRegressor(),
      "Linear regression": LinearRegression(),
      "Ridge": RidgeCV(),
  }
  
  y_test_predict = dict()
  for name, estimator in ESTIMATORS.items():
      estimator.fit(X_train, y_train)
      y_test_predict[name] = estimator.predict(X_test)
  
  # Plot the completed faces
  image_shape = (64, 64)
  
  n_cols = 1 + len(ESTIMATORS)
  plt.figure(figsize=(2.0 * n_cols, 2.26 * n_faces))
  plt.suptitle("Face completion with multi-output estimators", size=16)
  
  for i in range(n_faces):
      true_face = np.hstack((X_test[i], y_test[i]))
  
      if i:
          sub = plt.subplot(n_faces, n_cols, i * n_cols + 1)
      else:
          sub = plt.subplot(n_faces, n_cols, i * n_cols + 1, title="true faces")
  
      sub.axis("off")
      sub.imshow(
          true_face.reshape(image_shape), cmap=plt.cm.gray, interpolation="nearest"
      )
  
      for j, est in enumerate(sorted(ESTIMATORS)):
          completed_face = np.hstack((X_test[i], y_test_predict[est][i]))
  
          if i:
              sub = plt.subplot(n_faces, n_cols, i * n_cols + 2 + j)
  
          else:
              sub = plt.subplot(n_faces, n_cols, i * n_cols + 2 + j, title=est)
  
          sub.axis("off")
          sub.imshow(
              completed_face.reshape(image_shape),
              cmap=plt.cm.gray,
              interpolation="nearest",
          )
  
  plt.show()

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

!pip install scikit-learn==1.5.1

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

from sklearn.datasets import load_digits
  from sklearn.linear_model import Perceptron
  X, y = load_digits(return_X_y=True)
  clf = Perceptron(tol=1e-3, random_state=0)
  clf.fit(X, y)

clf.score(X, y)

from sklearn.model_selection import train_test_split
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
  
  clf = clf.fit(X_train, y_train)
  
  clf.score(X_train, y_train)

clf.score(X_test, y_test)

clf.score(X, y)

from sklearn.metrics import confusion_matrix
  y_pred = clf.predict(X_test)
  cm = confusion_matrix(y_test, y_pred)
  cm

from sklearn.datasets import load_iris
  
  iris = load_iris()
  X, y = iris.data, iris.target
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

X_train[:3]

clf = Perceptron(tol=1e-3, random_state=0)
  clf = clf.fit(X_train, y_train)
  
  clf.score(X_train, y_train)

clf.score(X_test, y_test)

y_pred = clf.predict(X_test)
  cm = confusion_matrix(y_test, y_pred)
  cm

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

!pip install scikit-learn==1.5.1

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

from sklearn.neural_network import MLPClassifier
  from sklearn.datasets import make_classification
  from sklearn.model_selection import train_test_split
  X, y = make_classification(n_samples=100, random_state=1)
  X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y,
                                                      random_state=1)
  clf = MLPClassifier(random_state=1, max_iter=300).fit(X_train, y_train)

clf.predict_proba(X_test[:1])

clf.predict(X_test[:5, :])

clf.score(X_test, y_test)

from sklearn.datasets import load_iris
  
  iris = load_iris()
  X, y = iris.data, iris.target
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

X_train[:3]

clf = MLPClassifier(random_state=1, max_iter=300).fit(X_train, y_train)

clf.score(X_test, y_test)

from sklearn.metrics import confusion_matrix
  y_pred = clf.predict(X_test)
  cm = confusion_matrix(y_test, y_pred)
  cm

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import tensorflow as tf
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version:", pip.__version__)
  print("TensorFlow version:", tf.__version__)

!pip install tensorflow==2.16.2

import tensorflow as tf
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version:", pip.__version__)
  print("TensorFlow version:", tf.__version__)

tf.config.list_physical_devices('GPU')

tf.test.is_built_with_cuda()

import tensorflow as tf
  print("TensorFlow version:", tf.__version__)

mnist = tf.keras.datasets.mnist
  
  (x_train, y_train), (x_test, y_test) = mnist.load_data()
  x_train, x_test = x_train / 255.0, x_test / 255.0

model = tf.keras.models.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10)
  ])

predictions = model(x_train[:1]).numpy()
  predictions

tf.nn.softmax(predictions).numpy()

loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

loss_fn(y_train[:1], predictions).numpy()

model.compile(optimizer='adam',
                loss=loss_fn,
                metrics=['accuracy'])

model.fit(x_train, y_train, epochs=5)

model.evaluate(x_test,  y_test, verbose=2)

probability_model = tf.keras.Sequential([
    model,
    tf.keras.layers.Softmax()
  ])

probability_model(x_test[:5])

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import torch
  import torchvision
  import matplotlib
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("pytorch version: {}".format(torch.__version__))
  print("torchvision version: {}".format(torchvision.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))

!pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

!pip install matplotlib==3.9.2

import torch
  import torchvision
  import matplotlib
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("pytorch version: {}".format(torch.__version__))
  print("torchvision version: {}".format(torchvision.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

import torch
  from torch import nn
  from torch.utils.data import DataLoader
  from torchvision import datasets
  from torchvision.transforms import ToTensor

# Download training data from open datasets.
  training_data = datasets.FashionMNIST(
      root="data",
      train=True,
      download=True,
      transform=ToTensor(),
  )
  
  # Download test data from open datasets.
  test_data = datasets.FashionMNIST(
      root="data",
      train=False,
      download=True,
      transform=ToTensor(),
  )

batch_size = 64
  
  # Create data loaders.
  train_dataloader = DataLoader(training_data, batch_size=batch_size)
  test_dataloader = DataLoader(test_data, batch_size=batch_size)
  
  for X, y in test_dataloader:
      print(f"Shape of X [N, C, H, W]: {X.shape}")
      print(f"Shape of y: {y.shape} {y.dtype}")
      break

# Get cpu, gpu or mps device for training.
  device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")
  
  # Define model
  class NeuralNetwork(nn.Module):
      def __init__(self):
          super().__init__()
          self.flatten = nn.Flatten()
          self.linear_relu_stack = nn.Sequential(
              nn.Linear(28*28, 512),
              nn.ReLU(),
              nn.Linear(512, 512),
              nn.ReLU(),
              nn.Linear(512, 10)
          )
  
      def forward(self, x):
          x = self.flatten(x)
          logits = self.linear_relu_stack(x)
          return logits
  
  model = NeuralNetwork().to(device)
  print(model)

loss_fn = nn.CrossEntropyLoss()
  optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)

def train(dataloader, model, loss_fn, optimizer):
      size = len(dataloader.dataset)
      model.train()
      for batch, (X, y) in enumerate(dataloader):
          X, y = X.to(device), y.to(device)
  
          # Compute prediction error
          pred = model(X)
          loss = loss_fn(pred, y)
  
          # Backpropagation
          loss.backward()
          optimizer.step()
          optimizer.zero_grad()
  
          if batch % 100 == 0:
              loss, current = loss.item(), (batch + 1) * len(X)
              print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")

def test(dataloader, model, loss_fn):
      size = len(dataloader.dataset)
      num_batches = len(dataloader)
      model.eval()
      test_loss, correct = 0, 0
      with torch.no_grad():
          for X, y in dataloader:
              X, y = X.to(device), y.to(device)
              pred = model(X)
              test_loss += loss_fn(pred, y).item()
              correct += (pred.argmax(1) == y).type(torch.float).sum().item()
      test_loss /= num_batches
      correct /= size
      print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")

epochs = 5
  for t in range(epochs):
      print(f"Epoch {t+1}\n-------------------------------")
      train(train_dataloader, model, loss_fn, optimizer)
      test(test_dataloader, model, loss_fn)
  print("Done!")

torch.save(model.state_dict(), "model.pth")
  print("Saved PyTorch Model State to model.pth")

model = NeuralNetwork().to(device)
  model.load_state_dict(torch.load("model.pth"))

classes = [
      "T-shirt/top",
      "Trouser",
      "Pullover",
      "Dress",
      "Coat",
      "Sandal",
      "Shirt",
      "Sneaker",
      "Bag",
      "Ankle boot",
  ]
  
  model.eval()
  x, y = test_data[0][0], test_data[0][1]
  with torch.no_grad():
      x = x.to(device)
      pred = model(x)
      predicted, actual = classes[pred[0].argmax(0)], classes[y]
      print(f'Predicted: "{predicted}", Actual: "{actual}"')

import matplotlib
  import matplotlib.pyplot as plt

#Check the data: basic description, some examples.
  
  print("""There are {} items in {} classes in the dataset to classify tested data into:\n\n0 = {} \n1 = {} \n2 = {} \n3 = {} \
  \n4 = {} \n5 = {}\n6 = {}\n7 = {}\n8 = {}\n9 = {}""".format((len(training_data)+len(test_data)), len(classes), classes[0], 
                                                              classes[1], classes[2], classes[3], classes[4], classes[5], 
                                                              classes[6], classes[7], classes[8], classes[9]))
  
  #Show an example
  item_to_show = 0 #1
  
  print("\nHere is an example of item number '{}':".format(item_to_show))
  
  image, label = (iter(training_data[item_to_show]))
  plt.imshow(image.squeeze(), cmap="gray")
  print(classes[label])

#Check the model with some examples.
  
  #Choose an item to test
  item_to_test = 0 #7
  
  x, y = test_data[item_to_test][0], test_data[item_to_test][1]
              
  #Test the item
  with torch.no_grad():
      pred = model(x)
      predicted, actual = classes[pred[0].argmax(0)], classes[y]
      print(f'Predicted: "{predicted}", Actual: "{actual}"')
  
  image, label = iter(test_data[item_to_test])
  plt.imshow(image.squeeze(), cmap="gray")
  print(classes[label])

#changed by SuperAIthegod
  item_to_test = 0 #7
  
  device= "cpu"
  model.to(device)
  
  x, y = test_data[item_to_test][0], test_data[item_to_test][1]
              
  #Test the item
  with torch.no_grad():
      pred = model(x)
      predicted, actual = classes[pred[0].argmax(0)], classes[y]
      print(f'Predicted: "{predicted}", Actual: "{actual}"')
  
  image, label = iter(test_data[item_to_test])
  plt.imshow(image.squeeze(), cmap="gray")
  print(classes[label])

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import tensorflow as tf
  import matplotlib
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version:", pip.__version__)
  print("TensorFlow version:", tf.__version__)
  print("matplotlib version:", matplotlib.__version__)

!pip install tensorflow==2.16.2

!pip install matplotlib==3.9.2

import tensorflow as tf
  import matplotlib
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version:", pip.__version__)
  print("TensorFlow version:", tf.__version__)
  print("matplotlib version:", matplotlib.__version__)

tf.config.list_physical_devices('GPU')

tf.test.is_built_with_cuda()

import tensorflow as tf
  
  from tensorflow.keras import datasets, layers, models
  import matplotlib.pyplot as plt

(train_images, train_labels), (test_images, test_labels) = datasets.cifar10.load_data()
  
  # Normalize pixel values to be between 0 and 1
  train_images, test_images = train_images / 255.0, test_images / 255.0

class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
                 'dog', 'frog', 'horse', 'ship', 'truck']
  
  plt.figure(figsize=(10,10))
  for i in range(25):
      plt.subplot(5,5,i+1)
      plt.xticks([])
      plt.yticks([])
      plt.grid(False)
      plt.imshow(train_images[i])
      # The CIFAR labels happen to be arrays, 
      # which is why you need the extra index
      plt.xlabel(class_names[train_labels[i][0]])
  plt.show()

model = models.Sequential()
  model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
  model.add(layers.MaxPooling2D((2, 2)))
  model.add(layers.Conv2D(64, (3, 3), activation='relu'))
  model.add(layers.MaxPooling2D((2, 2)))
  model.add(layers.Conv2D(64, (3, 3), activation='relu'))

model.summary()

model.add(layers.Flatten())
  model.add(layers.Dense(64, activation='relu'))
  model.add(layers.Dense(10))

model.summary()

model.compile(optimizer='adam',
                loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                metrics=['accuracy'])
  
  history = model.fit(train_images, train_labels, epochs=10, 
                      validation_data=(test_images, test_labels))

model.summary()

plt.plot(history.history['accuracy'], label='accuracy')
  plt.plot(history.history['val_accuracy'], label = 'val_accuracy')
  plt.xlabel('Epoch')
  plt.ylabel('Accuracy')
  plt.ylim([0.5, 1])
  plt.legend(loc='lower right')
  
  test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)

print(test_acc)

model2 = models.Sequential()
  model2.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
  model2.add(layers.MaxPooling2D((2, 2)))
  model2.add(layers.Conv2D(64, (3, 3), activation='relu'))
  model2.add(layers.Conv2D(64, (3, 3), activation='relu'))
  model2.add(layers.MaxPooling2D((2, 2)))
  model2.add(layers.Conv2D(64, (3, 3), activation='relu'))
  model2.summary()

model2.add(layers.Flatten())
  model2.add(layers.Dense(64, activation='relu'))
  model2.add(layers.Dense(10))
  model2.summary()

model2.compile(optimizer='adam',
                loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                metrics=['accuracy'])
  
  model2.summary()

history = model2.fit(train_images, train_labels, epochs=10, 
                      validation_data=(test_images, test_labels))

model2.summary()

test_loss, test_acc = model2.evaluate(test_images,  test_labels, verbose=2)

plt.plot(history.history['accuracy'], label='accuracy')
  plt.plot(history.history['val_accuracy'], label = 'val_accuracy')
  plt.xlabel('Epoch')
  plt.ylabel('Accuracy')
  plt.ylim([0.5, 1])
  plt.legend(loc='lower right')
  
  test_loss, test_acc = model2.evaluate(test_images,  test_labels, verbose=2)

print(test_acc)

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import torch
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("pytorch version: {}".format(torch.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))
  print("numpy version: {}".format(np.__version__))

!pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

!pip install matplotlib==3.9.2

#!pip install numpy==2.0.0

import torch
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("pytorch version: {}".format(torch.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))
  print("numpy version: {}".format(np.__version__))

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

import torch
  import torchvision
  import torchvision.transforms as transforms

transform = transforms.Compose(
      [transforms.ToTensor(),
       transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
  
  batch_size = 4
  
  trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                          download=True, transform=transform)
  trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,
                                            shuffle=True, num_workers=2)
  
  testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                         download=True, transform=transform)
  testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,
                                           shuffle=False, num_workers=2)
  
  classes = ('plane', 'car', 'bird', 'cat',
             'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

import matplotlib.pyplot as plt
  import numpy as np
  
  # functions to show an image
  def imshow(img):
      img = img / 2 + 0.5     # unnormalize
      npimg = img.numpy()
      plt.imshow(np.transpose(npimg, (1, 2, 0)))
      plt.show()
  
  
  # get some random training images
  dataiter = iter(trainloader)
  images, labels = next(dataiter)
  
  # show images
  imshow(torchvision.utils.make_grid(images))
  # print labels
  print(' '.join(f'{classes[labels[j]]:5s}' for j in range(batch_size)))

import torch.nn as nn
  import torch.nn.functional as F
  
  
  class Net(nn.Module):
      def __init__(self):
          super().__init__()
          self.conv1 = nn.Conv2d(3, 6, 5)
          self.pool = nn.MaxPool2d(2, 2)
          self.conv2 = nn.Conv2d(6, 16, 5)
          self.fc1 = nn.Linear(16 * 5 * 5, 120)
          self.fc2 = nn.Linear(120, 84)
          self.fc3 = nn.Linear(84, 10)
  
      def forward(self, x):
          x = self.pool(F.relu(self.conv1(x)))
          x = self.pool(F.relu(self.conv2(x)))
          x = torch.flatten(x, 1) # flatten all dimensions except batch
          x = F.relu(self.fc1(x))
          x = F.relu(self.fc2(x))
          x = self.fc3(x)
          return x
  
  
  net = Net()

import torch.optim as optim
  
  criterion = nn.CrossEntropyLoss()
  optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

for epoch in range(2):  # loop over the dataset multiple times
  
      running_loss = 0.0
      for i, data in enumerate(trainloader, 0):
          # get the inputs; data is a list of [inputs, labels]
          inputs, labels = data
  
          # zero the parameter gradients
          optimizer.zero_grad()
  
          # forward + backward + optimize
          outputs = net(inputs)
          loss = criterion(outputs, labels)
          loss.backward()
          optimizer.step()
  
          # print statistics
          running_loss += loss.item()
          if i % 2000 == 1999:    # print every 2000 mini-batches
              print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')
              running_loss = 0.0
  
  print('Finished Training')

PATH = './cifar_net.pth'
  torch.save(net.state_dict(), PATH)

dataiter = iter(testloader)
  images, labels = next(dataiter)
  
  # print images
  imshow(torchvision.utils.make_grid(images))
  print('GroundTruth: ', ' '.join(f'{classes[labels[j]]:5s}' for j in range(4)))

net = Net()
  net.load_state_dict(torch.load(PATH))

outputs = net(images)

correct = 0
  total = 0
  # since we're not training, we don't need to calculate the gradients for our outputs
  with torch.no_grad():
      for data in testloader:
          images, labels = data
          # calculate outputs by running images through the network
          outputs = net(images)
          # the class with the highest energy is what we choose as prediction
          _, predicted = torch.max(outputs.data, 1)
          total += labels.size(0)
          correct += (predicted == labels).sum().item()
  
  print(f'Accuracy of the network on the 10000 test images: {100 * correct // total} %')

# prepare to count predictions for each class
  correct_pred = {classname: 0 for classname in classes}
  total_pred = {classname: 0 for classname in classes}
  
  # again no gradients needed
  with torch.no_grad():
      for data in testloader:
          images, labels = data
          outputs = net(images)
          _, predictions = torch.max(outputs, 1)
          # collect the correct predictions for each class
          for label, prediction in zip(labels, predictions):
              if label == prediction:
                  correct_pred[classes[label]] += 1
              total_pred[classes[label]] += 1
  
  
  # print accuracy for each class
  for classname, correct_count in correct_pred.items():
      accuracy = 100 * float(correct_count) / total_pred[classname]
      print(f'Accuracy for class: {classname:5s} is {accuracy:.1f} %')

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import torch
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("pytorch version: {}".format(torch.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))
  print("numpy version: {}".format(np.__version__))

!pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

!pip install matplotlib==3.9.2

#!pip install numpy==2.0.0

import torch
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("pytorch version: {}".format(torch.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))
  print("numpy version: {}".format(np.__version__))

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

import torch
  model = torch.hub.load('pytorch/vision:v0.10.0', 'resnet18', pretrained=True)
  # or any of these variants
  # model = torch.hub.load('pytorch/vision:v0.10.0', 'resnet34', pretrained=True)
  # model = torch.hub.load('pytorch/vision:v0.10.0', 'resnet50', pretrained=True)
  # model = torch.hub.load('pytorch/vision:v0.10.0', 'resnet101', pretrained=True)
  # model = torch.hub.load('pytorch/vision:v0.10.0', 'resnet152', pretrained=True)
  model.eval()

# Download an example image from the pytorch website
  import urllib
  url, filename = ("https://github.com/pytorch/hub/raw/master/images/dog.jpg", "dog.jpg")
  try: urllib.URLopener().retrieve(url, filename)
  except: urllib.request.urlretrieve(url, filename)

# sample execution (requires torchvision)
  from PIL import Image
  from torchvision import transforms
  input_image = Image.open(filename)
  preprocess = transforms.Compose([
      transforms.Resize(256),
      transforms.CenterCrop(224),
      transforms.ToTensor(),
      transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
  ])
  input_tensor = preprocess(input_image)
  input_batch = input_tensor.unsqueeze(0) # create a mini-batch as expected by the model
  
  # move the input and model to GPU for speed if available
  if torch.cuda.is_available():
      input_batch = input_batch.to('cuda')
      model.to('cuda')
  
  with torch.no_grad():
      output = model(input_batch)
  # Tensor of shape 1000, with confidence scores over Imagenet's 1000 classes
  print(output[0])
  # The output has unnormalized scores. To get probabilities, you can run a softmax on it.
  probabilities = torch.nn.functional.softmax(output[0], dim=0)
  print(probabilities)

# Download ImageNet labels
  !wget https://raw.githubusercontent.com/pytorch/hub/master/imagenet_classes.txt

#Alternative version of downloading without wget
  
  import requests
  URL = "https://raw.githubusercontent.com/pytorch/hub/master/imagenet_classes.txt"
  response = requests.get(URL)
  open("imagenet_classes.txt", "wb").write(response.content)

# Read the categories
  with open("imagenet_classes.txt", "r") as f:
      categories = [s.strip() for s in f.readlines()]
  # Show top categories per image
  top5_prob, top5_catid = torch.topk(probabilities, 5)
  for i in range(top5_prob.size(0)):
      print(categories[top5_catid[i]], top5_prob[i].item())

import matplotlib.pyplot as plt
  
  # show image
  plt.imshow(input_image)
  plt.show()

with open("imagenet_classes.txt", "r") as f:
      categories = [s.strip() for s in f.readlines()]
  print(categories)

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import fastai
  import torch
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("fastai version: {}".format(fastai.__version__))
  print("pytorch version: {}".format(torch.__version__))

!pip install fastai==2.7.15

!pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

import fastai
  import torch
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("fastai version: {}".format(fastai.__version__))
  print("pytorch version: {}".format(torch.__version__))

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

#import fastbook
  #fastbook.setup_book()
  #from fastbook import *

import fastai

#id first_training
  #caption Results from the first training
  # CLICK ME
  from fastai.vision.all import *
  path = untar_data(URLs.PETS)/'images'
  
  def is_cat(x): return x[0].isupper()
  dls = ImageDataLoaders.from_name_func(
      path, get_image_files(path), valid_pct=0.2, seed=42,
      label_func=is_cat, item_tfms=Resize(224))
  
  learn = vision_learner(dls, resnet34, metrics=error_rate)
  learn.fine_tune(1)

#hide_output
  uploader = widgets.FileUpload()
  uploader

uploader = SimpleNamespace(data = ['images/chapter1_cat_example.jpg'])

#Extra code made by SuperAIthegod
  item = 0 
  print("\nHere is an example of an item number '{}':".format(item))
  sample_image = str(path)+"\\"+os.listdir(path)[item]
  uploader = SimpleNamespace(data = [sample_image])
  img = PILImage.create(sample_image)
  img.to_thumb(192)

img = PILImage.create(uploader.data[0])
  is_cat,_,probs = learn.predict(img)
  print(f"Is this a cat?: {is_cat}.")
  print(f"Probability it's a cat: {probs[1].item():.6f}")

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

!pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

import fastai

from fastai.vision.all import *

path = untar_data(URLs.PETS)

path.ls()

files = get_image_files(path/"images")
  len(files)

files[0],files[6]

def label_func(f): return f[0].isupper()

dls = ImageDataLoaders.from_name_func(path, files, label_func, item_tfms=Resize(224))

dls.show_batch()

learn = vision_learner(dls, resnet34, metrics=error_rate)
  learn.fine_tune(1)

learn.predict(files[0])

learn.show_results()

files[0].name

pat = r'^(.*)_\d+.jpg'

dls = ImageDataLoaders.from_name_re(path, files, pat, item_tfms=Resize(224))

dls.show_batch()

dls = ImageDataLoaders.from_name_re(path, files, pat, item_tfms=Resize(460),
                                      batch_tfms=aug_transforms(size=224))

dls.show_batch()

learn = vision_learner(dls, resnet34, metrics=error_rate)

learn.lr_find()

learn.fine_tune(2, 3e-3)

learn.show_results()

interp = Interpretation.from_learner(learn)

interp.plot_top_losses(9, figsize=(15,10))

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

import fastai

from fastai.vision.all import *

path = untar_data(URLs.PASCAL_2007)
  path.ls()

df = pd.read_csv(path/'train.csv')
  df.head()

dls = ImageDataLoaders.from_df(df, path, folder='train', valid_col='is_valid', label_delim=' ',
                                 item_tfms=Resize(460), batch_tfms=aug_transforms(size=224))

dls.show_batch()

f1_macro = F1ScoreMulti(thresh=0.5, average='macro')
  f1_macro.name = 'F1(macro)'
  f1_samples = F1ScoreMulti(thresh=0.5, average='samples')
  f1_samples.name = 'F1(samples)'
  learn = vision_learner(dls, resnet50, metrics=[partial(accuracy_multi, thresh=0.5), f1_macro, f1_samples])

learn.lr_find()

learn.fine_tune(2, 3e-2)

learn.show_results()

learn.predict(path/'train/000005.jpg')

interp = Interpretation.from_learner(learn)
  interp.plot_top_losses(9)

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import fastai
  import torch
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("fastai version: {}".format(fastai.__version__))
  print("pytorch version: {}".format(torch.__version__))

!pip install fastai==2.7.15

!pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

import fastai
  import torch
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("fastai version: {}".format(fastai.__version__))
  print("pytorch version: {}".format(torch.__version__))

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

from fastai.vision.all import *

path = untar_data(URLs.CAMVID_TINY)
  dls = SegmentationDataLoaders.from_label_func(
      path, bs=8, fnames = get_image_files(path/"images"),
      label_func = lambda o: path/'labels'/f'{o.stem}_P{o.suffix}',
      codes = np.loadtxt(path/'codes.txt', dtype=str)
  )
  
  learn = unet_learner(dls, resnet34)
  learn.fine_tune(8)

learn.show_results(max_n=6, figsize=(7,8))

from fastai.vision.all import *

path = untar_data(URLs.CAMVID_TINY)
  path.ls()

codes = np.loadtxt(path/'codes.txt', dtype=str)
  codes

fnames = get_image_files(path/"images")
  fnames[0]

(path/"labels").ls()[0]

def label_func(fn): return path/"labels"/f"{fn.stem}_P{fn.suffix}"

dls = SegmentationDataLoaders.from_label_func(
      path, bs=8, fnames = fnames, label_func = label_func, codes = codes
  )

dls.show_batch(max_n=6)

learn = unet_learner(dls, resnet34)
  learn.fine_tune(6)

learn.show_results(max_n=6, figsize=(7,8))

interp = SegmentationInterpretation.from_learner(learn)
  interp.plot_top_losses(k=3)

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import tensorflow as tf
  import tensorflow_datasets as tfds
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version:", pip.__version__)
  print("TensorFlow version:", tf.__version__)
  print("TensorFlow Datasets version:", tfds.__version__)
  print("matplotlib version:", matplotlib.__version__)
  print("numpy version:", np.__version__)

!pip install tensorflow==2.15.1

!pip install tensorflow-datasets==4.9.6

!pip install matplotlib==3.9.2

import tensorflow as tf
  import tensorflow_datasets as tfds
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version:", pip.__version__)
  print("TensorFlow version:", tf.__version__)
  print("TensorFlow Datasets version:", tfds.__version__)
  print("matplotlib version:", matplotlib.__version__)
  print("numpy version:", np.__version__)

tf.config.list_physical_devices('GPU')

tf.test.is_built_with_cuda()

import numpy as np
  
  import tensorflow_datasets as tfds
  import tensorflow as tf
  
  tfds.disable_progress_bar()

import matplotlib.pyplot as plt
  
  
  def plot_graphs(history, metric):
    plt.plot(history.history[metric])
    plt.plot(history.history['val_'+metric], '')
    plt.xlabel("Epochs")
    plt.ylabel(metric)
    plt.legend([metric, 'val_'+metric])

dataset, info = tfds.load('imdb_reviews', with_info=True,
                            as_supervised=True)
  train_dataset, test_dataset = dataset['train'], dataset['test']
  
  train_dataset.element_spec

for example, label in train_dataset.take(1):
    print('text: ', example.numpy())
    print('label: ', label.numpy())

BUFFER_SIZE = 10000
  BATCH_SIZE = 64

train_dataset = train_dataset.shuffle(BUFFER_SIZE).batch(BATCH_SIZE).prefetch(tf.data.AUTOTUNE)
  test_dataset = test_dataset.batch(BATCH_SIZE).prefetch(tf.data.AUTOTUNE)

for example, label in train_dataset.take(1):
    print('texts: ', example.numpy()[:3])
    print()
    print('labels: ', label.numpy()[:3])

VOCAB_SIZE = 1000
  encoder = tf.keras.layers.TextVectorization(
      max_tokens=VOCAB_SIZE)
  encoder.adapt(train_dataset.map(lambda text, label: text))

vocab = np.array(encoder.get_vocabulary())
  vocab[:20]

encoded_example = encoder(example)[:3].numpy()
  encoded_example

for n in range(3):
    print("Original: ", example[n].numpy())
    print("Round-trip: ", " ".join(vocab[encoded_example[n]]))
    print()

#Change made by SuperAIthegod: changed tf.keras.layers.LSTM(64) to tf.keras.layers.SimpleRNN(64) to use simple RNN
  
  model = tf.keras.Sequential([
      encoder,
      tf.keras.layers.Embedding(
          input_dim=len(encoder.get_vocabulary()),
          output_dim=64,
          # Use masking to handle the variable sequence lengths
          mask_zero=True),
      tf.keras.layers.Bidirectional(tf.keras.layers.SimpleRNN(64)),
      tf.keras.layers.Dense(64, activation='relu'),
      tf.keras.layers.Dense(1)
  ])

print([layer.supports_masking for layer in model.layers])

# predict on a sample text without padding.
  
  sample_text = ('The movie was cool. The animation and the graphics were out of this world. I would recommend this movie.')
  predictions = model.predict(np.array([sample_text]))
  print(predictions[0])

# predict on a sample text with padding
  
  padding = "the " * 2000
  predictions = model.predict(np.array([sample_text, padding]))
  print(predictions[0])

model.compile(loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
                optimizer=tf.keras.optimizers.Adam(1e-4),
                metrics=['accuracy'])

history = model.fit(train_dataset, epochs=10,
                      validation_data=test_dataset,
                      validation_steps=30)

test_loss, test_acc = model.evaluate(test_dataset)
  
  print('Test Loss:', test_loss)
  print('Test Accuracy:', test_acc)

plt.figure(figsize=(16, 8))
  plt.subplot(1, 2, 1)
  plot_graphs(history, 'accuracy')
  plt.ylim(None, 1)
  plt.subplot(1, 2, 2)
  plot_graphs(history, 'loss')
  plt.ylim(0, None)

sample_text = ('The movie was cool. The animation and the graphics '
                 'were out of this world. I would recommend this movie.')
  predictions = model.predict(np.array([sample_text]))

predictions

sample_text2 = ('The movie was bad. The animation and the graphics '
                 'were bad. I would not recommend this movie.')
  predictions2 = model.predict(np.array([sample_text2]))

predictions2

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import torch
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("pytorch version: {}".format(torch.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))
  print("numpy version: {}".format(np.__version__))

!pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

!pip install matplotlib==3.9.2

#!pip install numpy==2.0.0

import torch
  import matplotlib
  import numpy as np
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pytorch version: {}".format(torch.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))
  print("numpy version: {}".format(np.__version__))

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

from io import open
  import glob
  import os
  
  def findFiles(path): return glob.glob(path)
  
  print(findFiles('data/names/*.txt'))
  
  import unicodedata
  import string
  
  all_letters = string.ascii_letters + " .,;'"
  n_letters = len(all_letters)
  
  # Turn a Unicode string to plain ASCII, thanks to https://stackoverflow.com/a/518232/2809427
  def unicodeToAscii(s):
      return ''.join(
          c for c in unicodedata.normalize('NFD', s)
          if unicodedata.category(c) != 'Mn'
          and c in all_letters
      )
  
  print(unicodeToAscii('Ślusàrski'))
  
  # Build the category_lines dictionary, a list of names per language
  category_lines = {}
  all_categories = []
  
  # Read a file and split into lines
  def readLines(filename):
      lines = open(filename, encoding='utf-8').read().strip().split('\n')
      return [unicodeToAscii(line) for line in lines]
  
  for filename in findFiles('data/names/*.txt'):
      category = os.path.splitext(os.path.basename(filename))[0]
      all_categories.append(category)
      lines = readLines(filename)
      category_lines[category] = lines
  
  n_categories = len(all_categories)

print(category_lines['Italian'][:5])

import torch
  
  # Find letter index from all_letters, e.g. "a" = 0
  def letterToIndex(letter):
      return all_letters.find(letter)
  
  # Just for demonstration, turn a letter into a <1 x n_letters> Tensor
  def letterToTensor(letter):
      tensor = torch.zeros(1, n_letters)
      tensor[0][letterToIndex(letter)] = 1
      return tensor
  
  # Turn a line into a <line_length x 1 x n_letters>,
  # or an array of one-hot letter vectors
  def lineToTensor(line):
      tensor = torch.zeros(len(line), 1, n_letters)
      for li, letter in enumerate(line):
          tensor[li][0][letterToIndex(letter)] = 1
      return tensor
  
  print(letterToTensor('J'))
  
  print(lineToTensor('Jones').size())

import torch.nn as nn
  
  class RNN(nn.Module):
      def __init__(self, input_size, hidden_size, output_size):
          super(RNN, self).__init__()
  
          self.hidden_size = hidden_size
  
          self.i2h = nn.Linear(input_size + hidden_size, hidden_size)
          self.h2o = nn.Linear(hidden_size, output_size)
          self.softmax = nn.LogSoftmax(dim=1)
  
      def forward(self, input, hidden):
          combined = torch.cat((input, hidden), 1)
          hidden = self.i2h(combined)
          output = self.h2o(hidden)
          output = self.softmax(output)
          return output, hidden
  
      def initHidden(self):
          return torch.zeros(1, self.hidden_size)
  
  n_hidden = 128
  rnn = RNN(n_letters, n_hidden, n_categories)

input = letterToTensor('A')
  hidden = torch.zeros(1, n_hidden)
  
  output, next_hidden = rnn(input, hidden)

def categoryFromOutput(output):
      top_n, top_i = output.topk(1)
      category_i = top_i[0].item()
      return all_categories[category_i], category_i
  
  print(categoryFromOutput(output))

import random
  
  def randomChoice(l):
      return l[random.randint(0, len(l) - 1)]
  
  def randomTrainingExample():
      category = randomChoice(all_categories)
      line = randomChoice(category_lines[category])
      category_tensor = torch.tensor([all_categories.index(category)], dtype=torch.long)
      line_tensor = lineToTensor(line)
      return category, line, category_tensor, line_tensor
  
  for i in range(10):
      category, line, category_tensor, line_tensor = randomTrainingExample()
      print('category =', category, '/ line =', line)

criterion = nn.NLLLoss()

learning_rate = 0.005 # If you set this too high, it might explode. If too low, it might not learn
  
  def train(category_tensor, line_tensor):
      hidden = rnn.initHidden()
  
      rnn.zero_grad()
  
      for i in range(line_tensor.size()[0]):
          output, hidden = rnn(line_tensor[i], hidden)
  
      loss = criterion(output, category_tensor)
      loss.backward()
  
      # Add parameters' gradients to their values, multiplied by learning rate
      for p in rnn.parameters():
          p.data.add_(p.grad.data, alpha=-learning_rate)
  
      return output, loss.item()

import time
  import math
  
  n_iters = 100000
  print_every = 5000
  plot_every = 1000
  
  # Keep track of losses for plotting
  current_loss = 0
  all_losses = []
  
  def timeSince(since):
      now = time.time()
      s = now - since
      m = math.floor(s / 60)
      s -= m * 60
      return '%dm %ds' % (m, s)
  
  start = time.time()
  
  for iter in range(1, n_iters + 1):
      category, line, category_tensor, line_tensor = randomTrainingExample()
      output, loss = train(category_tensor, line_tensor)
      current_loss += loss
  
      # Print ``iter`` number, loss, name and guess
      if iter % print_every == 0:
          guess, guess_i = categoryFromOutput(output)
          correct = '✓' if guess == category else '✗ (%s)' % category
          print('%d %d%% (%s) %.4f %s / %s %s' % (iter, iter / n_iters * 100, timeSince(start), loss, line, guess, correct))
  
      # Add current loss avg to list of losses
      if iter % plot_every == 0:
          all_losses.append(current_loss / plot_every)
          current_loss = 0

import matplotlib.pyplot as plt
  import matplotlib.ticker as ticker
  
  plt.figure()
  plt.plot(all_losses)

# Keep track of correct guesses in a confusion matrix
  confusion = torch.zeros(n_categories, n_categories)
  n_confusion = 10000
  
  # Just return an output given a line
  def evaluate(line_tensor):
      hidden = rnn.initHidden()
  
      for i in range(line_tensor.size()[0]):
          output, hidden = rnn(line_tensor[i], hidden)
  
      return output
  
  # Go through a bunch of examples and record which are correctly guessed
  for i in range(n_confusion):
      category, line, category_tensor, line_tensor = randomTrainingExample()
      output = evaluate(line_tensor)
      guess, guess_i = categoryFromOutput(output)
      category_i = all_categories.index(category)
      confusion[category_i][guess_i] += 1
  
  # Normalize by dividing every row by its sum
  for i in range(n_categories):
      confusion[i] = confusion[i] / confusion[i].sum()
  
  # Set up plot
  fig = plt.figure()
  ax = fig.add_subplot(111)
  cax = ax.matshow(confusion.numpy())
  fig.colorbar(cax)
  
  # Set up axes
  ax.set_xticklabels([''] + all_categories, rotation=90)
  ax.set_yticklabels([''] + all_categories)
  
  # Force label at every tick
  ax.xaxis.set_major_locator(ticker.MultipleLocator(1))
  ax.yaxis.set_major_locator(ticker.MultipleLocator(1))
  
  # sphinx_gallery_thumbnail_number = 2
  plt.show()

def predict(input_line, n_predictions=3):
      print('\n> %s' % input_line)
      with torch.no_grad():
          output = evaluate(lineToTensor(input_line))
  
          # Get top N categories
          topv, topi = output.topk(n_predictions, 1, True)
          predictions = []
  
          for i in range(n_predictions):
              value = topv[0][i].item()
              category_index = topi[0][i].item()
              print('(%.2f) %s' % (value, all_categories[category_index]))
              predictions.append([value, all_categories[category_index]])
  
  predict('Dovesky')
  predict('Jackson')
  predict('Satoshi')

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import tensorflow as tf
  import tensorflow_datasets as tfds
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version:", pip.__version__)
  print("TensorFlow version:", tf.__version__)
  print("TensorFlow Datasets version:", tfds.__version__)
  print("matplotlib version:", matplotlib.__version__)
  print("numpy version:", np.__version__)

!pip install tensorflow==2.15.1

!pip install tensorflow-datasets==4.9.6

!pip install matplotlib==3.9.2

import tensorflow as tf
  import tensorflow_datasets as tfds
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version:", pip.__version__)
  print("TensorFlow version:", tf.__version__)
  print("TensorFlow Datasets version:", tfds.__version__)
  print("matplotlib version:", matplotlib.__version__)
  print("numpy version:", np.__version__)

tf.config.list_physical_devices('GPU')

tf.test.is_built_with_cuda()

#!pip install ipywidgets

#!pip install protobuf==3.20.1

import numpy as np
  
  import tensorflow_datasets as tfds
  import tensorflow as tf
  
  tfds.disable_progress_bar()

import matplotlib.pyplot as plt
  
  def plot_graphs(history, metric):
    plt.plot(history.history[metric])
    plt.plot(history.history['val_'+metric], '')
    plt.xlabel("Epochs")
    plt.ylabel(metric)
    plt.legend([metric, 'val_'+metric])

dataset, info = tfds.load('imdb_reviews', with_info=True,
                            as_supervised=True)
  train_dataset, test_dataset = dataset['train'], dataset['test']
  
  train_dataset.element_spec

for example, label in train_dataset.take(1):
    print('text: ', example.numpy())
    print('label: ', label.numpy())

BUFFER_SIZE = 10000
  BATCH_SIZE = 64

train_dataset = train_dataset.shuffle(BUFFER_SIZE).batch(BATCH_SIZE).prefetch(tf.data.AUTOTUNE)
  test_dataset = test_dataset.batch(BATCH_SIZE).prefetch(tf.data.AUTOTUNE)

for example, label in train_dataset.take(1):
    print('texts: ', example.numpy()[:3])
    print()
    print('labels: ', label.numpy()[:3])

VOCAB_SIZE = 1000
  encoder = tf.keras.layers.TextVectorization(
      max_tokens=VOCAB_SIZE)
  encoder.adapt(train_dataset.map(lambda text, label: text))

vocab = np.array(encoder.get_vocabulary())
  vocab[:20]

encoded_example = encoder(example)[:3].numpy()
  encoded_example

for n in range(3):
    print("Original: ", example[n].numpy())
    print("Round-trip: ", " ".join(vocab[encoded_example[n]]))
    print()

model = tf.keras.Sequential([
      encoder,
      tf.keras.layers.Embedding(
          input_dim=len(encoder.get_vocabulary()),
          output_dim=64,
          # Use masking to handle the variable sequence lengths
          mask_zero=True),
      tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64)),
      tf.keras.layers.Dense(64, activation='relu'),
      tf.keras.layers.Dense(1)
  ])

print([layer.supports_masking for layer in model.layers])

# predict on a sample text without padding.
  
  sample_text = ('The movie was cool. The animation and the graphics '
                 'were out of this world. I would recommend this movie.')
  predictions = model.predict(np.array([sample_text]))
  print(predictions[0])

# predict on a sample text with padding
  
  padding = "the " * 2000
  predictions = model.predict(np.array([sample_text, padding]))
  print(predictions[0])

model.compile(loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
                optimizer=tf.keras.optimizers.Adam(1e-4),
                metrics=['accuracy'])

history = model.fit(train_dataset, epochs=10,
                      validation_data=test_dataset,
                      validation_steps=30)

test_loss, test_acc = model.evaluate(test_dataset)
  
  print('Test Loss:', test_loss)
  print('Test Accuracy:', test_acc)

plt.figure(figsize=(16, 8))
  plt.subplot(1, 2, 1)
  plot_graphs(history, 'accuracy')
  plt.ylim(None, 1)
  plt.subplot(1, 2, 2)
  plot_graphs(history, 'loss')
  plt.ylim(0, None)

sample_text = ('The movie was cool. The animation and the graphics '
                 'were out of this world. I would recommend this movie.')
  predictions = model.predict(np.array([sample_text]))

predictions

sample_text2 = ('The movie was bad. The animation and the graphics '
                 'were bad. I would not recommend this movie.')
  predictions2 = model.predict(np.array([sample_text2]))

predictions2

history = model.fit(train_dataset, epochs=2,
                      validation_data=test_dataset,
                      validation_steps=30)

test_loss, test_acc = model.evaluate(test_dataset)
  
  print('Test Loss:', test_loss)
  print('Test Accuracy:', test_acc)

plt.figure(figsize=(16, 8))
  plt.subplot(1, 2, 1)
  plot_graphs(history, 'accuracy')
  plt.ylim(None, 1)
  plt.subplot(1, 2, 2)
  plot_graphs(history, 'loss')
  plt.ylim(0, None)

sample_text = ('The movie was cool. The animation and the graphics '
                 'were out of this world. I would recommend this movie.')
  predictions = model.predict(np.array([sample_text]))

predictions

sample_text2 = ('The movie was bad. The animation and the graphics '
                 'were bad. I would not recommend this movie.')
  predictions2 = model.predict(np.array([sample_text2]))

predictions2

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import torch
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("pytorch version: {}".format(torch.__version__))

!pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

import torch
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("pytorch version: {}".format(torch.__version__))

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

# Author: Robert Guthrie
  
  import torch
  import torch.nn as nn
  import torch.nn.functional as F
  import torch.optim as optim
  
  torch.manual_seed(1)

lstm = nn.LSTM(3, 3)  # Input dim is 3, output dim is 3
  inputs = [torch.randn(1, 3) for _ in range(5)]  # make a sequence of length 5
  
  # initialize the hidden state.
  hidden = (torch.randn(1, 1, 3),
            torch.randn(1, 1, 3))
  for i in inputs:
      # Step through the sequence one element at a time.
      # after each step, hidden contains the hidden state.
      out, hidden = lstm(i.view(1, 1, -1), hidden)
  
  # alternatively, we can do the entire sequence all at once.
  # the first value returned by LSTM is all of the hidden states throughout
  # the sequence. the second is just the most recent hidden state
  # (compare the last slice of "out" with "hidden" below, they are the same)
  # The reason for this is that:
  # "out" will give you access to all hidden states in the sequence
  # "hidden" will allow you to continue the sequence and backpropagate,
  # by passing it as an argument  to the lstm at a later time
  # Add the extra 2nd dimension
  inputs = torch.cat(inputs).view(len(inputs), 1, -1)
  hidden = (torch.randn(1, 1, 3), torch.randn(1, 1, 3))  # clean out hidden state
  out, hidden = lstm(inputs, hidden)
  print(out)
  print(hidden)

def prepare_sequence(seq, to_ix):
      idxs = [to_ix[w] for w in seq]
      return torch.tensor(idxs, dtype=torch.long)
  
  
  training_data = [
      # Tags are: DET - determiner; NN - noun; V - verb
      # For example, the word "The" is a determiner
      ("The dog ate the apple".split(), ["DET", "NN", "V", "DET", "NN"]),
      ("Everybody read that book".split(), ["NN", "V", "DET", "NN"])
  ]
  word_to_ix = {}
  # For each words-list (sentence) and tags-list in each tuple of training_data
  for sent, tags in training_data:
      for word in sent:
          if word not in word_to_ix:  # word has not been assigned an index yet
              word_to_ix[word] = len(word_to_ix)  # Assign each word with a unique index
  print(word_to_ix)
  tag_to_ix = {"DET": 0, "NN": 1, "V": 2}  # Assign each tag with a unique index
  
  # These will usually be more like 32 or 64 dimensional.
  # We will keep them small, so we can see how the weights change as we train.
  EMBEDDING_DIM = 6
  HIDDEN_DIM = 6

class LSTMTagger(nn.Module):
  
      def __init__(self, embedding_dim, hidden_dim, vocab_size, tagset_size):
          super(LSTMTagger, self).__init__()
          self.hidden_dim = hidden_dim
  
          self.word_embeddings = nn.Embedding(vocab_size, embedding_dim)
  
          # The LSTM takes word embeddings as inputs, and outputs hidden states
          # with dimensionality hidden_dim.
          self.lstm = nn.LSTM(embedding_dim, hidden_dim)
  
          # The linear layer that maps from hidden state space to tag space
          self.hidden2tag = nn.Linear(hidden_dim, tagset_size)
  
      def forward(self, sentence):
          embeds = self.word_embeddings(sentence)
          lstm_out, _ = self.lstm(embeds.view(len(sentence), 1, -1))
          tag_space = self.hidden2tag(lstm_out.view(len(sentence), -1))
          tag_scores = F.log_softmax(tag_space, dim=1)
          return tag_scores

model = LSTMTagger(EMBEDDING_DIM, HIDDEN_DIM, len(word_to_ix), len(tag_to_ix))
  loss_function = nn.NLLLoss()
  optimizer = optim.SGD(model.parameters(), lr=0.1)
  
  # See what the scores are before training
  # Note that element i,j of the output is the score for tag j for word i.
  # Here we don't need to train, so the code is wrapped in torch.no_grad()
  with torch.no_grad():
      inputs = prepare_sequence(training_data[0][0], word_to_ix)
      tag_scores = model(inputs)
      print(tag_scores)
  
  for epoch in range(300):  # again, normally you would NOT do 300 epochs, it is toy data
      for sentence, tags in training_data:
          # Step 1. Remember that Pytorch accumulates gradients.
          # We need to clear them out before each instance
          model.zero_grad()
  
          # Step 2. Get our inputs ready for the network, that is, turn them into
          # Tensors of word indices.
          sentence_in = prepare_sequence(sentence, word_to_ix)
          targets = prepare_sequence(tags, tag_to_ix)
  
          # Step 3. Run our forward pass.
          tag_scores = model(sentence_in)
  
          # Step 4. Compute the loss, gradients, and update the parameters by
          #  calling optimizer.step()
          loss = loss_function(tag_scores, targets)
          loss.backward()
          optimizer.step()
  
  # See what the scores are after training
  with torch.no_grad():
      inputs = prepare_sequence(training_data[0][0], word_to_ix)
      tag_scores = model(inputs)
  
      # The sentence is "the dog ate the apple".  i,j corresponds to score for tag j
      # for word i. The predicted tag is the maximum scoring tag.
      # Here, we can see the predicted sequence below is 0 1 2 0 1
      # since 0 is index of the maximum value of row 1,
      # 1 is the index of maximum value of row 2, etc.
      # Which is DET NOUN VERB DET NOUN, the correct sequence!
      print(tag_scores)

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import fastai
  import torch
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("fastai version: {}".format(fastai.__version__))
  print("pytorch version: {}".format(torch.__version__))

!pip install fastai==2.7.15

!pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

import fastai
  import torch
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("fastai version: {}".format(fastai.__version__))
  print("pytorch version: {}".format(torch.__version__))

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

from fastai.text.all import *
  
  dls = TextDataLoaders.from_folder(untar_data(URLs.IMDB), valid='test')
  learn = text_classifier_learner(dls, AWD_LSTM, drop_mult=0.5, metrics=accuracy)
  learn.fine_tune(4, 1e-2)

learn.predict("I really liked that movie!")

from fastai.text.all import *
  
  dls = TextDataLoaders.from_folder(untar_data(URLs.IMDB), valid='test')
  learn = text_classifier_learner(dls, AWD_LSTM, drop_mult=0.5, metrics=accuracy)
  learn.fine_tune(4, 1e-2)

learn.predict("I really liked that movie!")

learn.predict("I didn't like that movie!")

learn.predict("I really didn't like that movie!")

learn.predict("I really tried to like that movie!")

learn.predict("I really liked that movie as an example of the worst movie there can be!")

learn.predict("It's the worst movie ever!")

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import fastai
  import torch
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("fastai version: {}".format(fastai.__version__))
  print("pytorch version: {}".format(torch.__version__))

!pip install fastai==2.7.15

!pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

import fastai
  import torch
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("fastai version: {}".format(fastai.__version__))
  print("pytorch version: {}".format(torch.__version__))

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

from fastai.text.all import *

path = untar_data(URLs.IMDB)
  path.ls()

(path/'train').ls()

dls = TextDataLoaders.from_folder(untar_data(URLs.IMDB), valid='test')

dls.show_batch()

learn = text_classifier_learner(dls, AWD_LSTM, drop_mult=0.5, metrics=accuracy)

learn.fine_tune(4, 1e-2)

learn.fine_tune(4, 1e-2)

learn.show_results()

learn.predict("I really liked that movie!")

dls_lm = TextDataLoaders.from_folder(path, is_lm=True, valid_pct=0.1)

dls_lm.show_batch(max_n=5)

learn = language_model_learner(dls_lm, AWD_LSTM, metrics=[accuracy, Perplexity()], path=path, wd=0.1).to_fp16()

learn.fit_one_cycle(1, 1e-2)

learn.save('1epoch')

learn.unfreeze()
  learn.fit_one_cycle(10, 1e-3)

learn.save_encoder('finetuned')

TEXT = "I liked this movie because"
  N_WORDS = 40
  N_SENTENCES = 2
  preds = [learn.predict(TEXT, N_WORDS, temperature=0.75) 
           for _ in range(N_SENTENCES)]

print("\n".join(preds))

dls_clas = TextDataLoaders.from_folder(untar_data(URLs.IMDB), valid='test', text_vocab=dls_lm.vocab)

learn = text_classifier_learner(dls_clas, AWD_LSTM, drop_mult=0.5, metrics=accuracy)

learn = learn.load_encoder('finetuned')

learn.fit_one_cycle(1, 2e-2)

learn.freeze_to(-2)
  learn.fit_one_cycle(1, slice(1e-2/(2.6**4),1e-2))

learn.freeze_to(-3)
  learn.fit_one_cycle(1, slice(5e-3/(2.6**4),5e-3))

learn.unfreeze()
  learn.fit_one_cycle(2, slice(1e-3/(2.6**4),1e-3))

learn.predict("I really liked that movie!")

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import fastai
  import torch
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("fastai version: {}".format(fastai.__version__))
  print("pytorch version: {}".format(torch.__version__))

!pip install fastai==2.7.15

!pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

import fastai
  import torch
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("fastai version: {}".format(fastai.__version__))
  print("pytorch version: {}".format(torch.__version__))

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

from fastai.tabular.all import *
  path = untar_data(URLs.ADULT_SAMPLE)
  
  dls = TabularDataLoaders.from_csv(path/'adult.csv', path=path, y_names="salary",
      cat_names = ['workclass', 'education', 'marital-status', 'occupation',
                   'relationship', 'race'],
      cont_names = ['age', 'fnlwgt', 'education-num'],
      procs = [Categorify, FillMissing, Normalize])
  
  learn = tabular_learner(dls, metrics=accuracy)

learn.fit_one_cycle(3)

from fastai.tabular.all import *

path = untar_data(URLs.ADULT_SAMPLE)
  path.ls()

df = pd.read_csv(path/'adult.csv')
  df.head()

dls = TabularDataLoaders.from_csv(path/'adult.csv', path=path, y_names="salary",
      cat_names = ['workclass', 'education', 'marital-status', 'occupation', 'relationship', 'race'],
      cont_names = ['age', 'fnlwgt', 'education-num'],
      procs = [Categorify, FillMissing, Normalize])

splits = RandomSplitter(valid_pct=0.2)(range_of(df))

to = TabularPandas(df, procs=[Categorify, FillMissing,Normalize],
                     cat_names = ['workclass', 'education', 'marital-status', 'occupation', 'relationship', 'race'],
                     cont_names = ['age', 'fnlwgt', 'education-num'],
                     y_names='salary',
                     splits=splits)

to.xs.iloc[:2]

dls = to.dataloaders(bs=64)

dls.show_batch()

learn = tabular_learner(dls, metrics=accuracy)

learn.fit_one_cycle(1)

learn.show_results()

row, clas, probs = learn.predict(df.iloc[0])

row.show()

clas, probs

test_df = df.copy()
  test_df.drop(['salary'], axis=1, inplace=True)
  dl = learn.dls.test_dl(test_df)

learn.get_preds(dl=dl)

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import torch
  import portalocker
  import torchdata
  import torchtext
  import spacy
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("pytorch version: {}".format(torch.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))
  print("numpy version: {}".format(np.__version__))
  print("torchdata version: {}".format(torchdata.__version__))
  print("torchtext version: {}".format(torchtext.__version__))
  print("portalocker version: {}".format(portalocker.__version__))
  print("spacy version: {}".format(spacy.__version__))

pip install torch==2.3.1 torchvision==0.18.1 torchaudio==2.3.1 --index-url https://download.pytorch.org/whl/cu118

#!pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

!pip install matplotlib==3.9.2

#!pip install numpy==2.0.0

!pip install portalocker==2.10.1

!pip install torchdata==0.7.1

!pip3 install torchtext==0.18.0

!pip install spacy==3.7.5

!python -m spacy download en_core_web_sm
  !python -m spacy download de_core_news_sm

import torch
  import portalocker
  import torchdata
  import torchtext
  import spacy
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("pytorch version: {}".format(torch.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))
  print("numpy version: {}".format(np.__version__))
  print("torchdata version: {}".format(torchdata.__version__))
  print("torchtext version: {}".format(torchtext.__version__))
  print("portalocker version: {}".format(portalocker.__version__))
  print("spacy version: {}".format(spacy.__version__))

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

from torchtext.data.utils import get_tokenizer
  from torchtext.vocab import build_vocab_from_iterator
  from torchtext.datasets import multi30k, Multi30k
  from typing import Iterable, List
  
  
  # We need to modify the URLs for the dataset since the links to the original dataset are broken
  # Refer to https://github.com/pytorch/text/issues/1756#issuecomment-1163664163 for more info
  multi30k.URL["train"] = "https://raw.githubusercontent.com/neychev/small_DL_repo/master/datasets/Multi30k/training.tar.gz"
  multi30k.URL["valid"] = "https://raw.githubusercontent.com/neychev/small_DL_repo/master/datasets/Multi30k/validation.tar.gz"
  
  SRC_LANGUAGE = 'de'
  TGT_LANGUAGE = 'en'
  
  # Place-holders
  token_transform = {}
  vocab_transform = {}

token_transform[SRC_LANGUAGE] = get_tokenizer('spacy', language='de_core_news_sm')
  token_transform[TGT_LANGUAGE] = get_tokenizer('spacy', language='en_core_web_sm')
  
  
  # helper function to yield list of tokens
  def yield_tokens(data_iter: Iterable, language: str) -> List[str]:
      language_index = {SRC_LANGUAGE: 0, TGT_LANGUAGE: 1}
  
      for data_sample in data_iter:
          yield token_transform[language](data_sample[language_index[language]])
  
  # Define special symbols and indices
  UNK_IDX, PAD_IDX, BOS_IDX, EOS_IDX = 0, 1, 2, 3
  # Make sure the tokens are in order of their indices to properly insert them in vocab
  special_symbols = ['<unk>', '<pad>', '<bos>', '<eos>']
  
  for ln in [SRC_LANGUAGE, TGT_LANGUAGE]:
      # Training data Iterator
      train_iter = Multi30k(split='train', language_pair=(SRC_LANGUAGE, TGT_LANGUAGE))
      # Create torchtext's Vocab object
      vocab_transform[ln] = build_vocab_from_iterator(yield_tokens(train_iter, ln),
                                                      min_freq=1,
                                                      specials=special_symbols,
                                                      special_first=True)
  
  # Set ``UNK_IDX`` as the default index. This index is returned when the token is not found.
  # If not set, it throws ``RuntimeError`` when the queried token is not found in the Vocabulary.
  for ln in [SRC_LANGUAGE, TGT_LANGUAGE]:
    vocab_transform[ln].set_default_index(UNK_IDX)

from torch import Tensor
  import torch
  import torch.nn as nn
  from torch.nn import Transformer
  import math
  DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
  
  # helper Module that adds positional encoding to the token embedding to introduce a notion of word order.
  class PositionalEncoding(nn.Module):
      def __init__(self,
                   emb_size: int,
                   dropout: float,
                   maxlen: int = 5000):
          super(PositionalEncoding, self).__init__()
          den = torch.exp(- torch.arange(0, emb_size, 2)* math.log(10000) / emb_size)
          pos = torch.arange(0, maxlen).reshape(maxlen, 1)
          pos_embedding = torch.zeros((maxlen, emb_size))
          pos_embedding[:, 0::2] = torch.sin(pos * den)
          pos_embedding[:, 1::2] = torch.cos(pos * den)
          pos_embedding = pos_embedding.unsqueeze(-2)
  
          self.dropout = nn.Dropout(dropout)
          self.register_buffer('pos_embedding', pos_embedding)
  
      def forward(self, token_embedding: Tensor):
          return self.dropout(token_embedding + self.pos_embedding[:token_embedding.size(0), :])
  
  # helper Module to convert tensor of input indices into corresponding tensor of token embeddings
  class TokenEmbedding(nn.Module):
      def __init__(self, vocab_size: int, emb_size):
          super(TokenEmbedding, self).__init__()
          self.embedding = nn.Embedding(vocab_size, emb_size)
          self.emb_size = emb_size
  
      def forward(self, tokens: Tensor):
          return self.embedding(tokens.long()) * math.sqrt(self.emb_size)
  
  # Seq2Seq Network
  class Seq2SeqTransformer(nn.Module):
      def __init__(self,
                   num_encoder_layers: int,
                   num_decoder_layers: int,
                   emb_size: int,
                   nhead: int,
                   src_vocab_size: int,
                   tgt_vocab_size: int,
                   dim_feedforward: int = 512,
                   dropout: float = 0.1):
          super(Seq2SeqTransformer, self).__init__()
          self.transformer = Transformer(d_model=emb_size,
                                         nhead=nhead,
                                         num_encoder_layers=num_encoder_layers,
                                         num_decoder_layers=num_decoder_layers,
                                         dim_feedforward=dim_feedforward,
                                         dropout=dropout)
          self.generator = nn.Linear(emb_size, tgt_vocab_size)
          self.src_tok_emb = TokenEmbedding(src_vocab_size, emb_size)
          self.tgt_tok_emb = TokenEmbedding(tgt_vocab_size, emb_size)
          self.positional_encoding = PositionalEncoding(
              emb_size, dropout=dropout)
  
      def forward(self,
                  src: Tensor,
                  trg: Tensor,
                  src_mask: Tensor,
                  tgt_mask: Tensor,
                  src_padding_mask: Tensor,
                  tgt_padding_mask: Tensor,
                  memory_key_padding_mask: Tensor):
          src_emb = self.positional_encoding(self.src_tok_emb(src))
          tgt_emb = self.positional_encoding(self.tgt_tok_emb(trg))
          outs = self.transformer(src_emb, tgt_emb, src_mask, tgt_mask, None,
                                  src_padding_mask, tgt_padding_mask, memory_key_padding_mask)
          return self.generator(outs)
  
      def encode(self, src: Tensor, src_mask: Tensor):
          return self.transformer.encoder(self.positional_encoding(
                              self.src_tok_emb(src)), src_mask)
  
      def decode(self, tgt: Tensor, memory: Tensor, tgt_mask: Tensor):
          return self.transformer.decoder(self.positional_encoding(
                            self.tgt_tok_emb(tgt)), memory,
                            tgt_mask)

def generate_square_subsequent_mask(sz):
      mask = (torch.triu(torch.ones((sz, sz), device=DEVICE)) == 1).transpose(0, 1)
      mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))
      return mask
  
  
  def create_mask(src, tgt):
      src_seq_len = src.shape[0]
      tgt_seq_len = tgt.shape[0]
  
      tgt_mask = generate_square_subsequent_mask(tgt_seq_len)
      src_mask = torch.zeros((src_seq_len, src_seq_len),device=DEVICE).type(torch.bool)
  
      src_padding_mask = (src == PAD_IDX).transpose(0, 1)
      tgt_padding_mask = (tgt == PAD_IDX).transpose(0, 1)
      return src_mask, tgt_mask, src_padding_mask, tgt_padding_mask

torch.manual_seed(0)
  
  SRC_VOCAB_SIZE = len(vocab_transform[SRC_LANGUAGE])
  TGT_VOCAB_SIZE = len(vocab_transform[TGT_LANGUAGE])
  EMB_SIZE = 512
  NHEAD = 8
  FFN_HID_DIM = 512
  BATCH_SIZE = 128
  NUM_ENCODER_LAYERS = 3
  NUM_DECODER_LAYERS = 3
  
  transformer = Seq2SeqTransformer(NUM_ENCODER_LAYERS, NUM_DECODER_LAYERS, EMB_SIZE,
                                   NHEAD, SRC_VOCAB_SIZE, TGT_VOCAB_SIZE, FFN_HID_DIM)
  
  for p in transformer.parameters():
      if p.dim() > 1:
          nn.init.xavier_uniform_(p)
  
  transformer = transformer.to(DEVICE)
  
  loss_fn = torch.nn.CrossEntropyLoss(ignore_index=PAD_IDX)
  
  optimizer = torch.optim.Adam(transformer.parameters(), lr=0.0001, betas=(0.9, 0.98), eps=1e-9)

from torch.nn.utils.rnn import pad_sequence
  
  # helper function to club together sequential operations
  def sequential_transforms(*transforms):
      def func(txt_input):
          for transform in transforms:
              txt_input = transform(txt_input)
          return txt_input
      return func
  
  # function to add BOS/EOS and create tensor for input sequence indices
  def tensor_transform(token_ids: List[int]):
      return torch.cat((torch.tensor([BOS_IDX]),
                        torch.tensor(token_ids),
                        torch.tensor([EOS_IDX])))
  
  # ``src`` and ``tgt`` language text transforms to convert raw strings into tensors indices
  text_transform = {}
  for ln in [SRC_LANGUAGE, TGT_LANGUAGE]:
      text_transform[ln] = sequential_transforms(token_transform[ln], #Tokenization
                                                 vocab_transform[ln], #Numericalization
                                                 tensor_transform) # Add BOS/EOS and create tensor
  
  
  # function to collate data samples into batch tensors
  def collate_fn(batch):
      src_batch, tgt_batch = [], []
      for src_sample, tgt_sample in batch:
          src_batch.append(text_transform[SRC_LANGUAGE](src_sample.rstrip("\n")))
          tgt_batch.append(text_transform[TGT_LANGUAGE](tgt_sample.rstrip("\n")))
  
      src_batch = pad_sequence(src_batch, padding_value=PAD_IDX)
      tgt_batch = pad_sequence(tgt_batch, padding_value=PAD_IDX)
      return src_batch, tgt_batch

from torch.utils.data import DataLoader
  
  def train_epoch(model, optimizer):
      model.train()
      losses = 0
      train_iter = Multi30k(split='train', language_pair=(SRC_LANGUAGE, TGT_LANGUAGE))
      train_dataloader = DataLoader(train_iter, batch_size=BATCH_SIZE, collate_fn=collate_fn)
  
      for src, tgt in train_dataloader:
          src = src.to(DEVICE)
          tgt = tgt.to(DEVICE)
  
          tgt_input = tgt[:-1, :]
  
          src_mask, tgt_mask, src_padding_mask, tgt_padding_mask = create_mask(src, tgt_input)
  
          logits = model(src, tgt_input, src_mask, tgt_mask,src_padding_mask, tgt_padding_mask, src_padding_mask)
  
          optimizer.zero_grad()
  
          tgt_out = tgt[1:, :]
          loss = loss_fn(logits.reshape(-1, logits.shape[-1]), tgt_out.reshape(-1))
          loss.backward()
  
          optimizer.step()
          losses += loss.item()
  
      return losses / len(list(train_dataloader))
  
  
  def evaluate(model):
      model.eval()
      losses = 0
  
      val_iter = Multi30k(split='valid', language_pair=(SRC_LANGUAGE, TGT_LANGUAGE))
      val_dataloader = DataLoader(val_iter, batch_size=BATCH_SIZE, collate_fn=collate_fn)
  
      for src, tgt in val_dataloader:
          src = src.to(DEVICE)
          tgt = tgt.to(DEVICE)
  
          tgt_input = tgt[:-1, :]
  
          src_mask, tgt_mask, src_padding_mask, tgt_padding_mask = create_mask(src, tgt_input)
  
          logits = model(src, tgt_input, src_mask, tgt_mask,src_padding_mask, tgt_padding_mask, src_padding_mask)
  
          tgt_out = tgt[1:, :]
          loss = loss_fn(logits.reshape(-1, logits.shape[-1]), tgt_out.reshape(-1))
          losses += loss.item()
  
      return losses / len(list(val_dataloader))

from timeit import default_timer as timer
  NUM_EPOCHS = 18
  
  for epoch in range(1, NUM_EPOCHS+1):
      start_time = timer()
      train_loss = train_epoch(transformer, optimizer)
      end_time = timer()
      val_loss = evaluate(transformer)
      print((f"Epoch: {epoch}, Train loss: {train_loss:.3f}, Val loss: {val_loss:.3f}, "f"Epoch time = {(end_time - start_time):.3f}s"))
  
  
  # function to generate output sequence using greedy algorithm
  def greedy_decode(model, src, src_mask, max_len, start_symbol):
      src = src.to(DEVICE)
      src_mask = src_mask.to(DEVICE)
  
      memory = model.encode(src, src_mask)
      ys = torch.ones(1, 1).fill_(start_symbol).type(torch.long).to(DEVICE)
      for i in range(max_len-1):
          memory = memory.to(DEVICE)
          tgt_mask = (generate_square_subsequent_mask(ys.size(0))
                      .type(torch.bool)).to(DEVICE)
          out = model.decode(ys, memory, tgt_mask)
          out = out.transpose(0, 1)
          prob = model.generator(out[:, -1])
          _, next_word = torch.max(prob, dim=1)
          next_word = next_word.item()
  
          ys = torch.cat([ys,
                          torch.ones(1, 1).type_as(src.data).fill_(next_word)], dim=0)
          if next_word == EOS_IDX:
              break
      return ys
  
  
  # actual function to translate input sentence into target language
  def translate(model: torch.nn.Module, src_sentence: str):
      model.eval()
      src = text_transform[SRC_LANGUAGE](src_sentence).view(-1, 1)
      num_tokens = src.shape[0]
      src_mask = (torch.zeros(num_tokens, num_tokens)).type(torch.bool)
      tgt_tokens = greedy_decode(
          model,  src, src_mask, max_len=num_tokens + 5, start_symbol=BOS_IDX).flatten()
      return " ".join(vocab_transform[TGT_LANGUAGE].lookup_tokens(list(tgt_tokens.cpu().numpy()))).replace("<bos>", "").replace("<eos>", "")

print(translate(transformer, "Eine Gruppe von Menschen steht vor einem Iglu ."))

print(translate(transformer, "Eine Gruppe von Menschen steht vor einem Iglu ."))

print(translate(transformer, "Deine Gruppe von Menschen steht vor einem Iglu ."))

print(translate(transformer, "Meine Gruppe von Menschen steht vor einem Iglu ."))

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import tensorflow as tf
  import official 
  import tensorflow_hub as hub
  import tensorflow_text as text
  import matplotlib
  import pydot
  import graphviz
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version:", pip.__version__)
  print("TensorFlow version:", tf.__version__)
  print("tensorFlow-hub version:", hub.__version__)
  print("official version:", hub.__version__)
  print("tensorflow_text version:", text.__version__)
  print("matplotlib version:", matplotlib.__version__)
  print("pydot version:", pydot.__version__)
  print("graphviz version:", graphviz.__version__)

!pip install tensorflow==2.10

!pip install tensorflow-text==2.10

!pip install tf-models-official==2.10

!pip install tensorflow-hub==0.14

!pip install matplotlib==3.9.2

!pip install pydot==1.4.2

#!pip install graphviz==0.20.1 #doesn't seem to work properly on Windows at the moment

import tensorflow as tf
  import official 
  import tensorflow_hub as hub
  import tensorflow_text as text
  import matplotlib
  import pydot
  import graphviz
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version:", pip.__version__)
  print("TensorFlow version:", tf.__version__)
  print("tensorFlow-hub version:", hub.__version__)
  print("official version:", hub.__version__)
  print("tensorflow_text version:", text.__version__)
  print("matplotlib version:", matplotlib.__version__)
  print("pydot version:", pydot.__version__)
  print("graphviz version:", graphviz.__version__)

tf.config.list_physical_devices('GPU')

tf.test.is_built_with_cuda()

import os
  import shutil
  
  import tensorflow as tf
  import tensorflow_hub as hub
  import tensorflow_text as text
  from official.nlp import optimization  # to create AdamW optimizer
  
  import matplotlib.pyplot as plt
  
  tf.get_logger().setLevel('ERROR')

url = 'https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz'
  
  dataset = tf.keras.utils.get_file('aclImdb_v1.tar.gz', url,
                                    untar=True, cache_dir='.',
                                    cache_subdir='')
  
  dataset_dir = os.path.join(os.path.dirname(dataset), 'aclImdb')
  
  train_dir = os.path.join(dataset_dir, 'train')
  
  # remove unused folders to make it easier to load the data
  remove_dir = os.path.join(train_dir, 'unsup')
  shutil.rmtree(remove_dir)

AUTOTUNE = tf.data.AUTOTUNE
  batch_size = 32
  seed = 42
  
  raw_train_ds = tf.keras.utils.text_dataset_from_directory(
      'aclImdb/train',
      batch_size=batch_size,
      validation_split=0.2,
      subset='training',
      seed=seed)
  
  class_names = raw_train_ds.class_names
  train_ds = raw_train_ds.cache().prefetch(buffer_size=AUTOTUNE)
  
  val_ds = tf.keras.utils.text_dataset_from_directory(
      'aclImdb/train',
      batch_size=batch_size,
      validation_split=0.2,
      subset='validation',
      seed=seed)
  
  val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)
  
  test_ds = tf.keras.utils.text_dataset_from_directory(
      'aclImdb/test',
      batch_size=batch_size)
  
  test_ds = test_ds.cache().prefetch(buffer_size=AUTOTUNE)

for text_batch, label_batch in train_ds.take(1):
    for i in range(3):
      print(f'Review: {text_batch.numpy()[i]}')
      label = label_batch.numpy()[i]
      print(f'Label : {label} ({class_names[label]})')

bert_model_name = 'small_bert/bert_en_uncased_L-4_H-512_A-8' 
  
  map_name_to_handle = {
      'bert_en_uncased_L-12_H-768_A-12':
          'https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3',
      'bert_en_cased_L-12_H-768_A-12':
          'https://tfhub.dev/tensorflow/bert_en_cased_L-12_H-768_A-12/3',
      'bert_multi_cased_L-12_H-768_A-12':
          'https://tfhub.dev/tensorflow/bert_multi_cased_L-12_H-768_A-12/3',
      'small_bert/bert_en_uncased_L-2_H-128_A-2':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-128_A-2/1',
      'small_bert/bert_en_uncased_L-2_H-256_A-4':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-256_A-4/1',
      'small_bert/bert_en_uncased_L-2_H-512_A-8':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-512_A-8/1',
      'small_bert/bert_en_uncased_L-2_H-768_A-12':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-768_A-12/1',
      'small_bert/bert_en_uncased_L-4_H-128_A-2':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-128_A-2/1',
      'small_bert/bert_en_uncased_L-4_H-256_A-4':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-256_A-4/1',
      'small_bert/bert_en_uncased_L-4_H-512_A-8':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-512_A-8/1',
      'small_bert/bert_en_uncased_L-4_H-768_A-12':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-768_A-12/1',
      'small_bert/bert_en_uncased_L-6_H-128_A-2':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-128_A-2/1',
      'small_bert/bert_en_uncased_L-6_H-256_A-4':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-256_A-4/1',
      'small_bert/bert_en_uncased_L-6_H-512_A-8':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-512_A-8/1',
      'small_bert/bert_en_uncased_L-6_H-768_A-12':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-768_A-12/1',
      'small_bert/bert_en_uncased_L-8_H-128_A-2':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-128_A-2/1',
      'small_bert/bert_en_uncased_L-8_H-256_A-4':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-256_A-4/1',
      'small_bert/bert_en_uncased_L-8_H-512_A-8':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-512_A-8/1',
      'small_bert/bert_en_uncased_L-8_H-768_A-12':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-768_A-12/1',
      'small_bert/bert_en_uncased_L-10_H-128_A-2':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-128_A-2/1',
      'small_bert/bert_en_uncased_L-10_H-256_A-4':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-256_A-4/1',
      'small_bert/bert_en_uncased_L-10_H-512_A-8':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-512_A-8/1',
      'small_bert/bert_en_uncased_L-10_H-768_A-12':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-768_A-12/1',
      'small_bert/bert_en_uncased_L-12_H-128_A-2':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-128_A-2/1',
      'small_bert/bert_en_uncased_L-12_H-256_A-4':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-256_A-4/1',
      'small_bert/bert_en_uncased_L-12_H-512_A-8':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-512_A-8/1',
      'small_bert/bert_en_uncased_L-12_H-768_A-12':
          'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-768_A-12/1',
      'albert_en_base':
          'https://tfhub.dev/tensorflow/albert_en_base/2',
      'electra_small':
          'https://tfhub.dev/google/electra_small/2',
      'electra_base':
          'https://tfhub.dev/google/electra_base/2',
      'experts_pubmed':
          'https://tfhub.dev/google/experts/bert/pubmed/2',
      'experts_wiki_books':
          'https://tfhub.dev/google/experts/bert/wiki_books/2',
      'talking-heads_base':
          'https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_base/1',
  }
  
  map_model_to_preprocess = {
      'bert_en_uncased_L-12_H-768_A-12':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'bert_en_cased_L-12_H-768_A-12':
          'https://tfhub.dev/tensorflow/bert_en_cased_preprocess/3',
      'small_bert/bert_en_uncased_L-2_H-128_A-2':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-2_H-256_A-4':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-2_H-512_A-8':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-2_H-768_A-12':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-4_H-128_A-2':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-4_H-256_A-4':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-4_H-512_A-8':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-4_H-768_A-12':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-6_H-128_A-2':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-6_H-256_A-4':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-6_H-512_A-8':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-6_H-768_A-12':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-8_H-128_A-2':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-8_H-256_A-4':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-8_H-512_A-8':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-8_H-768_A-12':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-10_H-128_A-2':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-10_H-256_A-4':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-10_H-512_A-8':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-10_H-768_A-12':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-12_H-128_A-2':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-12_H-256_A-4':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-12_H-512_A-8':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'small_bert/bert_en_uncased_L-12_H-768_A-12':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'bert_multi_cased_L-12_H-768_A-12':
          'https://tfhub.dev/tensorflow/bert_multi_cased_preprocess/3',
      'albert_en_base':
          'https://tfhub.dev/tensorflow/albert_en_preprocess/3',
      'electra_small':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'electra_base':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'experts_pubmed':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'experts_wiki_books':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
      'talking-heads_base':
          'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3',
  }
  
  tfhub_handle_encoder = map_name_to_handle[bert_model_name]
  tfhub_handle_preprocess = map_model_to_preprocess[bert_model_name]
  
  print(f'BERT model selected           : {tfhub_handle_encoder}')
  print(f'Preprocess model auto-selected: {tfhub_handle_preprocess}')

bert_preprocess_model = hub.KerasLayer(tfhub_handle_preprocess)

text_test = ['this is such an amazing movie!']
  text_preprocessed = bert_preprocess_model(text_test)
  
  print(f'Keys       : {list(text_preprocessed.keys())}')
  print(f'Shape      : {text_preprocessed["input_word_ids"].shape}')
  print(f'Word Ids   : {text_preprocessed["input_word_ids"][0, :12]}')
  print(f'Input Mask : {text_preprocessed["input_mask"][0, :12]}')
  print(f'Type Ids   : {text_preprocessed["input_type_ids"][0, :12]}')

bert_model = hub.KerasLayer(tfhub_handle_encoder)

bert_results = bert_model(text_preprocessed)
  
  print(f'Loaded BERT: {tfhub_handle_encoder}')
  print(f'Pooled Outputs Shape:{bert_results["pooled_output"].shape}')
  print(f'Pooled Outputs Values:{bert_results["pooled_output"][0, :12]}')
  print(f'Sequence Outputs Shape:{bert_results["sequence_output"].shape}')
  print(f'Sequence Outputs Values:{bert_results["sequence_output"][0, :12]}')

def build_classifier_model():
    text_input = tf.keras.layers.Input(shape=(), dtype=tf.string, name='text')
    preprocessing_layer = hub.KerasLayer(tfhub_handle_preprocess, name='preprocessing')
    encoder_inputs = preprocessing_layer(text_input)
    encoder = hub.KerasLayer(tfhub_handle_encoder, trainable=True, name='BERT_encoder')
    outputs = encoder(encoder_inputs)
    net = outputs['pooled_output']
    net = tf.keras.layers.Dropout(0.1)(net)
    net = tf.keras.layers.Dense(1, activation=None, name='classifier')(net)
    return tf.keras.Model(text_input, net)

classifier_model = build_classifier_model()
  bert_raw_result = classifier_model(tf.constant(text_test))
  print(tf.sigmoid(bert_raw_result))

tf.keras.utils.plot_model(classifier_model)

loss = tf.keras.losses.BinaryCrossentropy(from_logits=True)
  metrics = tf.metrics.BinaryAccuracy()

epochs = 5
  
  steps_per_epoch = tf.data.experimental.cardinality(train_ds).numpy()
  num_train_steps = steps_per_epoch * epochs
  num_warmup_steps = int(0.1*num_train_steps)
  
  init_lr = 3e-5
  optimizer = optimization.create_optimizer(init_lr=init_lr,
                                            num_train_steps=num_train_steps,
                                            num_warmup_steps=num_warmup_steps,
                                            optimizer_type='adamw')

classifier_model.compile(optimizer=optimizer,
                           loss=loss,
                           metrics=metrics)

print(f'Training model with {tfhub_handle_encoder}')
  history = classifier_model.fit(x=train_ds,
                                 validation_data=val_ds,
                                 epochs=epochs)

loss, accuracy = classifier_model.evaluate(test_ds)
  
  print(f'Loss: {loss}')
  print(f'Accuracy: {accuracy}')

history_dict = history.history
  print(history_dict.keys())
  
  acc = history_dict['binary_accuracy']
  val_acc = history_dict['val_binary_accuracy']
  loss = history_dict['loss']
  val_loss = history_dict['val_loss']
  
  epochs = range(1, len(acc) + 1)
  fig = plt.figure(figsize=(10, 6))
  fig.tight_layout()
  
  plt.subplot(2, 1, 1)
  # r is for "solid red line"
  plt.plot(epochs, loss, 'r', label='Training loss')
  # b is for "solid blue line"
  plt.plot(epochs, val_loss, 'b', label='Validation loss')
  plt.title('Training and validation loss')
  # plt.xlabel('Epochs')
  plt.ylabel('Loss')
  plt.legend()
  
  plt.subplot(2, 1, 2)
  plt.plot(epochs, acc, 'r', label='Training acc')
  plt.plot(epochs, val_acc, 'b', label='Validation acc')
  plt.title('Training and validation accuracy')
  plt.xlabel('Epochs')
  plt.ylabel('Accuracy')
  plt.legend(loc='lower right')

dataset_name = 'imdb'
  saved_model_path = './{}_bert'.format(dataset_name.replace('/', '_'))
  
  classifier_model.save(saved_model_path, include_optimizer=False)

reloaded_model = tf.saved_model.load(saved_model_path)

def print_my_examples(inputs, results):
    result_for_printing = \
      [f'input: {inputs[i]:<30} : score: {results[i][0]:.6f}'
                           for i in range(len(inputs))]
    print(*result_for_printing, sep='\n')
    print()
  
  
  examples = [
      'this is such an amazing movie!',  # this is the same sentence tried earlier
      'The movie was great!',
      'The movie was meh.',
      'The movie was okish.',
      'The movie was terrible...'
  ]
  
  reloaded_results = tf.sigmoid(reloaded_model(tf.constant(examples)))
  original_results = tf.sigmoid(classifier_model(tf.constant(examples)))
  
  print('Results from the saved model:')
  print_my_examples(examples, reloaded_results)
  print('Results from the model in memory:')
  print_my_examples(examples, original_results)

serving_results = reloaded_model \
              .signatures['serving_default'](tf.constant(examples))
  
  serving_results = tf.sigmoid(serving_results['classifier'])
  
  print_my_examples(examples, serving_results)

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import fastai
  import transformers
  import torch
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("fastai version: {}".format(fastai.__version__))
  print("transformers version: {}".format(transformers.__version__))
  print("pytorch version: {}".format(torch.__version__))

!pip install fastai==2.7.15

!pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

!pip install transformers==4.41.2

import fastai
  import transformers
  import torch
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("fastai version: {}".format(fastai.__version__))
  print("transformers version: {}".format(transformers.__version__))
  print("pytorch version: {}".format(torch.__version__))

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

from transformers import GPT2LMHeadModel, GPT2TokenizerFast

pretrained_weights = 'gpt2'
  tokenizer = GPT2TokenizerFast.from_pretrained(pretrained_weights)
  model = GPT2LMHeadModel.from_pretrained(pretrained_weights)

ids = tokenizer.encode('This is an example of text, and')
  ids

tokenizer.decode(ids)

import torch

t = torch.LongTensor(ids)[None]
  preds = model.generate(t)

preds.shape,preds[0]

from fastai.text.all import *

path = untar_data(URLs.WIKITEXT_TINY)
  path.ls()

df_train = pd.read_csv(path/'train.csv', header=None)
  df_valid = pd.read_csv(path/'test.csv', header=None)
  df_train.head()

all_texts = np.concatenate([df_train[0].values, df_valid[0].values])

class TransformersTokenizer(Transform):
      def __init__(self, tokenizer): self.tokenizer = tokenizer
      def encodes(self, x): 
          toks = self.tokenizer.tokenize(x)
          return tensor(self.tokenizer.convert_tokens_to_ids(toks))
      def decodes(self, x): return TitledStr(self.tokenizer.decode(x.cpu().numpy()))

splits = [range_of(df_train), list(range(len(df_train), len(all_texts)))]
  tls = TfmdLists(all_texts, TransformersTokenizer(tokenizer), splits=splits, dl_type=LMDataLoader)

tls.train[0],tls.valid[0]

tls.tfms(tls.train.items[0]).shape, tls.tfms(tls.valid.items[0]).shape

show_at(tls.train, 0)

show_at(tls.valid, 0)

bs,sl = 4,256
  dls = tls.dataloaders(bs=bs, seq_len=sl)

dls.show_batch(max_n=2)

def tokenize(text):
      toks = tokenizer.tokenize(text)
      return tensor(tokenizer.convert_tokens_to_ids(toks))
  
  tokenized = [tokenize(t) for t in progress_bar(all_texts)]

class TransformersTokenizer(Transform):
      def __init__(self, tokenizer): self.tokenizer = tokenizer
      def encodes(self, x): 
          return x if isinstance(x, Tensor) else tokenize(x)
          
      def decodes(self, x): return TitledStr(self.tokenizer.decode(x.cpu().numpy()))

tls = TfmdLists(tokenized, TransformersTokenizer(tokenizer), splits=splits, dl_type=LMDataLoader)
  dls = tls.dataloaders(bs=bs, seq_len=sl)

dls.show_batch(max_n=2)

class DropOutput(Callback):
      def after_pred(self): self.learn.pred = self.pred[0]

learn = Learner(dls, model, loss_func=CrossEntropyLossFlat(), cbs=[DropOutput], metrics=Perplexity()).to_fp16()

learn.validate()

learn.lr_find()

learn.fit_one_cycle(1, 1e-4)

df_valid.head(1)

prompt = "\n = Unicorn = \n \n A unicorn is a magical creature with a rainbow tail and a horn"

prompt_ids = tokenizer.encode(prompt)
  inp = tensor(prompt_ids)[None].cuda()
  inp.shape

preds = learn.model.generate(inp, max_length=40, num_beams=5, temperature=1.5)

tokenizer.decode(preds[0].cpu().numpy())

prompt = "\n = Transformer = \n \n A transformer is a magical creature with a head and a head"

prompt_ids = tokenizer.encode(prompt)
  inp = tensor(prompt_ids)[None].cuda()
  inp.shape

preds = learn.model.generate(inp, max_length=40, num_beams=5, temperature=1.5)

tokenizer.decode(preds[0].cpu().numpy())

prompt = "\n = Human = \n \n A human is a mythical creature with a head and a torso"

prompt_ids = tokenizer.encode(prompt)
  inp = tensor(prompt_ids)[None].cuda()
  inp.shape

preds = learn.model.generate(inp, max_length=40, num_beams=5, temperature=1.5)

tokenizer.decode(preds[0].cpu().numpy())

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))
  print("numpy version: {}".format(np.__version__))

!pip install scikit-learn==1.5.1

!pip install matplotlib==3.9.2

!pip install numpy==2.0.0

import sklearn
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))
  print("numpy version: {}".format(np.__version__))

from sklearn import tree
  X = [[0, 0], [2, 2]]
  y = [0.5, 2.5]
  clf = tree.DecisionTreeRegressor()
  clf = clf.fit(X, y)
  clf.predict([[1, 1]])

# Import the necessary modules and libraries
  import matplotlib.pyplot as plt
  import numpy as np
  
  from sklearn.tree import DecisionTreeRegressor
  
  # Create a random dataset
  rng = np.random.RandomState(1)
  X = np.sort(5 * rng.rand(80, 1), axis=0)
  y = np.sin(X).ravel()
  y[::5] += 3 * (0.5 - rng.rand(16))
  
  # Fit regression model
  regr_1 = DecisionTreeRegressor(max_depth=2)
  regr_2 = DecisionTreeRegressor(max_depth=5)
  regr_1.fit(X, y)
  regr_2.fit(X, y)
  
  # Predict
  X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]
  y_1 = regr_1.predict(X_test)
  y_2 = regr_2.predict(X_test)
  
  # Plot the results
  plt.figure()
  plt.scatter(X, y, s=20, edgecolor="black", c="darkorange", label="data")
  plt.plot(X_test, y_1, color="cornflowerblue", label="max_depth=2", linewidth=2)
  plt.plot(X_test, y_2, color="yellowgreen", label="max_depth=5", linewidth=2)
  plt.xlabel("data")
  plt.ylabel("target")
  plt.title("Decision Tree Regression")
  plt.legend()
  plt.show()

import sklearn.datasets

help(sklearn.datasets)

from sklearn.datasets import load_diabetes
  
  diabetes_dataset = load_diabetes()
  X = diabetes_dataset.data
  y = diabetes_dataset.target
  print('Number of examples:', len(diabetes_dataset.target))
  print('\nFeatures\n', diabetes_dataset.feature_names)
  print('\nData\n', X)
  print('\nTarget\n', y)

print(diabetes_dataset.DESCR)

from sklearn.model_selection import train_test_split
  
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 0)
  print("Training examples: {}, Test examples: {}.".format(len(X_train), len(X_test)))

from sklearn import tree
  
  reg = tree.DecisionTreeRegressor(max_depth=2, random_state=0)
  reg = reg.fit(X_train, y_train)
  
  y_pred = reg.predict(X_test)
  y_pred

reg.score(X_test, y_test)

from sklearn.metrics import mean_squared_error, r2_score
  r2_score(y_test, y_pred)

mean_squared_error(y_test, y_pred)

print(X_test[0])
  reg.predict([X_test[0]])

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("numpy version: {}".format(np.__version__))

!pip install scikit-learn==1.5.1

!pip install numpy==2.0.0

import sklearn
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("numpy version: {}".format(np.__version__))

from sklearn import linear_model
  reg = linear_model.LinearRegression()
  reg.fit([[0, 0], [1, 1], [2, 2]], [0, 1, 2])
  reg.coef_

import numpy as np
  from sklearn.linear_model import LinearRegression
  X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
  # y = 1 * x_0 + 2 * x_1 + 3
  y = np.dot(X, np.array([1, 2])) + 3
  reg = LinearRegression().fit(X, y)
  reg.score(X, y)

reg.coef_

reg.intercept_

reg.predict(np.array([[3, 5]]))

from sklearn.datasets import load_diabetes
  
  diabetes_dataset = load_diabetes()
  X = diabetes_dataset.data
  y = diabetes_dataset.target

from sklearn.model_selection import train_test_split
  
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 0)
  print("Training examples: {}, Test examples: {}.".format(len(X_train), len(X_test)))

from sklearn.linear_model import LinearRegression
  
  reg = LinearRegression()
  reg = reg.fit(X_train, y_train)
  
  y_pred = reg.predict(X_test)

reg.score(X_test, y_test)

from sklearn.metrics import mean_squared_error, r2_score
  r2_score(y_test, y_pred)

mean_squared_error(y_test, y_pred)

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))
  print("numpy version: {}".format(np.__version__))

!pip install scikit-learn==1.5.1

!pip install matplotlib==3.9.2

!pip install numpy==2.0.0

import sklearn
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))
  print("numpy version: {}".format(np.__version__))

from sklearn import svm
  X = [[0, 0], [2, 2]]
  y = [0.5, 2.5]
  regr = svm.SVR()
  regr.fit(X, y)
  regr.predict([[1, 1]])

import matplotlib.pyplot as plt
  import numpy as np
  
  from sklearn.svm import SVR

X = np.sort(5 * np.random.rand(40, 1), axis=0)
  y = np.sin(X).ravel()
  
  # add noise to targets
  y[::5] += 3 * (0.5 - np.random.rand(8))

svr_rbf = SVR(kernel="rbf", C=100, gamma=0.1, epsilon=0.1)
  svr_lin = SVR(kernel="linear", C=100, gamma="auto")
  svr_poly = SVR(kernel="poly", C=100, gamma="auto", degree=3, epsilon=0.1, coef0=1)

lw = 2
  
  svrs = [svr_rbf, svr_lin, svr_poly]
  kernel_label = ["RBF", "Linear", "Polynomial"]
  model_color = ["m", "c", "g"]
  
  fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(15, 10), sharey=True)
  for ix, svr in enumerate(svrs):
      axes[ix].plot(
          X,
          svr.fit(X, y).predict(X),
          color=model_color[ix],
          lw=lw,
          label="{} model".format(kernel_label[ix]),
      )
      axes[ix].scatter(
          X[svr.support_],
          y[svr.support_],
          facecolor="none",
          edgecolor=model_color[ix],
          s=50,
          label="{} support vectors".format(kernel_label[ix]),
      )
      axes[ix].scatter(
          X[np.setdiff1d(np.arange(len(X)), svr.support_)],
          y[np.setdiff1d(np.arange(len(X)), svr.support_)],
          facecolor="none",
          edgecolor="k",
          s=50,
          label="other training data",
      )
      axes[ix].legend(
          loc="upper center",
          bbox_to_anchor=(0.5, 1.1),
          ncol=1,
          fancybox=True,
          shadow=True,
      )
  
  fig.text(0.5, 0.04, "data", ha="center", va="center")
  fig.text(0.06, 0.5, "target", ha="center", va="center", rotation="vertical")
  fig.suptitle("Support Vector Regression", fontsize=14)
  plt.show()

from sklearn.datasets import load_diabetes
  
  diabetes_dataset = load_diabetes()
  X = diabetes_dataset.data
  y = diabetes_dataset.target

from sklearn.model_selection import train_test_split
  
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 0)
  print("Training examples: {}, Test examples: {}.".format(len(X_train), len(X_test)))

from sklearn.svm import SVR
  from sklearn.metrics import mean_squared_error, r2_score
  
  svr_rbf = SVR(kernel="rbf", C=100, gamma=0.1, epsilon=0.1)
  svr_lin = SVR(kernel="linear", C=100, gamma="auto")
  svr_poly = SVR(kernel="poly", C=100, gamma="auto", degree=3, epsilon=0.1, coef0=1)
  svrs = [svr_rbf, svr_lin, svr_poly]
  
  for svr in svrs:
      print("\nLearning with {}".format(svr))
      reg = svr
      reg = reg.fit(X_train, y_train)
      y_pred = reg.predict(X_test)
      
      print("Score: ", reg.score(X_test, y_test))
      print("R2_score:", r2_score(y_test, y_pred))
      print("Mean Squared Error:", mean_squared_error(y_test, y_pred))

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

!pip install scikit-learn==1.5.1

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

from sklearn.ensemble import RandomForestRegressor
  from sklearn.datasets import make_regression
  X, y = make_regression(n_features=4, n_informative=2,random_state=0, shuffle=False)
  regr = RandomForestRegressor(max_depth=2, random_state=0)
  regr.fit(X, y)
  print(regr.predict([[0, 0, 0, 0]]))

from sklearn.datasets import load_diabetes
  
  diabetes_dataset = load_diabetes()
  X = diabetes_dataset.data
  y = diabetes_dataset.target

from sklearn.model_selection import train_test_split
  
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 0)
  print("Training examples: {}, Test examples: {}.".format(len(X_train), len(X_test)))

from sklearn.ensemble import RandomForestRegressor
  
  reg = RandomForestRegressor(max_depth=2, random_state=0)
  reg = reg.fit(X_train, y_train)
  
  y_pred = reg.predict(X_test)

reg.score(X_test, y_test)

from sklearn.metrics import mean_squared_error, r2_score
  r2_score(y_test, y_pred)

mean_squared_error(y_test, y_pred)

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

!pip install scikit-learn==1.5.1

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

from sklearn.ensemble import AdaBoostRegressor
  from sklearn.datasets import make_regression
  X, y = make_regression(n_features=4, n_informative=2, random_state=0, shuffle=False)
  regr = AdaBoostRegressor(random_state=0, n_estimators=100)
  regr.fit(X, y)
  regr.predict([[0, 0, 0, 0]])
  regr.score(X, y)

from sklearn.datasets import load_diabetes
  
  diabetes_dataset = load_diabetes()
  X = diabetes_dataset.data
  y = diabetes_dataset.target

from sklearn.model_selection import train_test_split
  
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 0)
  print("Training examples: {}, Test examples: {}.".format(len(X_train), len(X_test)))

from sklearn.ensemble import AdaBoostRegressor
  
  reg = AdaBoostRegressor(random_state=0, n_estimators=100)
  reg = reg.fit(X_train, y_train)
  
  y_pred = reg.predict(X_test)

reg.score(X_test, y_test)

from sklearn.metrics import mean_squared_error, r2_score
  r2_score(y_test, y_pred)

mean_squared_error(y_test, y_pred)

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

!pip install scikit-learn==1.5.1

import sklearn
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))

from sklearn.datasets import make_regression
  from sklearn.ensemble import GradientBoostingRegressor
  from sklearn.model_selection import train_test_split
  X, y = make_regression(random_state=0)
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
  reg = GradientBoostingRegressor(random_state=0)
  reg.fit(X_train, y_train)
  reg.predict(X_test[1:2])
  reg.score(X_test, y_test)

from sklearn.datasets import load_diabetes
  
  diabetes_dataset = load_diabetes()
  X = diabetes_dataset.data
  y = diabetes_dataset.target

from sklearn.model_selection import train_test_split
  
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 0)
  print("Training examples: {}, Test examples: {}.".format(len(X_train), len(X_test)))

from sklearn.ensemble import GradientBoostingRegressor
  
  reg = GradientBoostingRegressor(random_state=0)
  reg = reg.fit(X_train, y_train)
  
  y_pred = reg.predict(X_test)

reg.score(X_test, y_test)

from sklearn.metrics import mean_squared_error, r2_score
  r2_score(y_test, y_pred)

mean_squared_error(y_test, y_pred)

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import matplotlib
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))

!pip install scikit-learn==1.5.1

!pip install matplotlib==3.9.2

import sklearn
  import matplotlib
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))

import matplotlib.pyplot as plt
  
  from sklearn.datasets import load_diabetes
  from sklearn.ensemble import (
      GradientBoostingRegressor,
      RandomForestRegressor,
      VotingRegressor,
  )
  from sklearn.linear_model import LinearRegression

X, y = load_diabetes(return_X_y=True)
  
  # Train classifiers
  reg1 = GradientBoostingRegressor(random_state=1)
  reg2 = RandomForestRegressor(random_state=1)
  reg3 = LinearRegression()
  
  reg1.fit(X, y)
  reg2.fit(X, y)
  reg3.fit(X, y)
  
  ereg = VotingRegressor([("gb", reg1), ("rf", reg2), ("lr", reg3)])
  ereg.fit(X, y)

xt = X[:20]
  
  pred1 = reg1.predict(xt)
  pred2 = reg2.predict(xt)
  pred3 = reg3.predict(xt)
  pred4 = ereg.predict(xt)

plt.figure()
  plt.plot(pred1, "gd", label="GradientBoostingRegressor")
  plt.plot(pred2, "b^", label="RandomForestRegressor")
  plt.plot(pred3, "ys", label="LinearRegression")
  plt.plot(pred4, "r*", ms=10, label="VotingRegressor")
  
  plt.tick_params(axis="x", which="both", bottom=False, top=False, labelbottom=False)
  plt.ylabel("predicted")
  plt.xlabel("training samples")
  plt.legend(loc="best")
  plt.title("Regressor predictions and their average")
  
  plt.show()

import matplotlib.pyplot as plt
  
  from sklearn.datasets import load_diabetes
  from sklearn.ensemble import (
      GradientBoostingRegressor,
      RandomForestRegressor,
      VotingRegressor,
  )
  from sklearn.linear_model import LinearRegression

from sklearn.model_selection import train_test_split
  
  X, y = load_diabetes(return_X_y=True)
  
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 0)
  print("Training examples: {}, Test examples: {}.".format(len(X_train), len(X_test)))

# Train classifiers
  reg1 = GradientBoostingRegressor(random_state=1)
  reg2 = RandomForestRegressor(random_state=1)
  reg3 = LinearRegression()
  
  reg1.fit(X_train, y_train)
  reg2.fit(X_train, y_train)
  reg3.fit(X_train, y_train)
  
  ereg = VotingRegressor([("gb", reg1), ("rf", reg2), ("lr", reg3)])
  ereg.fit(X_train, y_train)

pred1 = reg1.predict(X_test)
  pred2 = reg2.predict(X_test)
  pred3 = reg3.predict(X_test)
  pred4 = ereg.predict(X_test)

plt.figure()
  plt.plot(pred1, "gd", label="GradientBoostingRegressor")
  plt.plot(pred2, "b^", label="RandomForestRegressor")
  plt.plot(pred3, "ys", label="LinearRegression")
  plt.plot(pred4, "r*", ms=10, label="VotingRegressor")
  
  plt.tick_params(axis="x", which="both", bottom=False, top=False, labelbottom=False)
  plt.ylabel("predicted")
  plt.xlabel("training samples")
  plt.legend(loc="best")
  plt.title("Regressor predictions and their average")
  
  plt.show()

print("GradientBoostingRegressor:", reg1.score(X_test, y_test))
  print("RandomForrestRegressor:", reg2.score(X_test, y_test))
  print("LinearRegression:", reg3.score(X_test, y_test))
  print("VotingRegressor:", ereg.score(X_test, y_test))

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("numpy version: {}".format(np.__version__))

!pip install scikit-learn==1.5.1

!pip install numpy==2.0.0

import sklearn
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("numpy version: {}".format(np.__version__))

import numpy as np

y = np.array([[31.4, 94], [40.5, 109], [25.0, 30]])
  print(y)

from sklearn.datasets import make_regression
  from sklearn.multioutput import MultiOutputRegressor
  from sklearn.ensemble import GradientBoostingRegressor
  X, y = make_regression(n_samples=10, n_targets=3, random_state=1)
  MultiOutputRegressor(GradientBoostingRegressor(random_state=0)).fit(X, y).predict(X)

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import tensorflow as tf
  import matplotlib
  import numpy as np
  import pandas as pd
  import seaborn as sns
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version:", pip.__version__)
  print("TensorFlow version:", tf.__version__)
  print("matplotlib version:", matplotlib.__version__)
  print("numpy version:", np.__version__)
  print("pandas version:", pd.__version__)
  print("seaborn version:", sns.__version__)

!pip install tensorflow==2.16.2

!pip install matplotlib==3.9.2

!pip install pandas==2.2.2

!pip install seaborn==0.13.2

import tensorflow as tf
  import matplotlib
  import numpy as np
  import pandas as pd
  import seaborn as sns
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version:", pip.__version__)
  print("TensorFlow version:", tf.__version__)
  print("matplotlib version:", matplotlib.__version__)
  print("numpy version:", np.__version__)
  print("pandas version:", pd.__version__)
  print("seaborn version:", sns.__version__)

tf.config.list_physical_devices('GPU')

tf.test.is_built_with_cuda()

import matplotlib.pyplot as plt
  import numpy as np
  import pandas as pd
  import seaborn as sns
  
  # Make NumPy printouts easier to read.
  np.set_printoptions(precision=3, suppress=True)

import tensorflow as tf
  
  from tensorflow import keras
  from tensorflow.keras import layers
  
  print(tf.__version__)

url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data'
  column_names = ['MPG', 'Cylinders', 'Displacement', 'Horsepower', 'Weight',
                  'Acceleration', 'Model Year', 'Origin']
  
  raw_dataset = pd.read_csv(url, names=column_names,
                            na_values='?', comment='\t',
                            sep=' ', skipinitialspace=True)

dataset = raw_dataset.copy()
  dataset.tail()

dataset.isna().sum()

dataset = dataset.dropna()

dataset['Origin'] = dataset['Origin'].map({1: 'USA', 2: 'Europe', 3: 'Japan'})

dataset = pd.get_dummies(dataset, columns=['Origin'], prefix='', prefix_sep='')
  dataset.tail()

train_dataset = dataset.sample(frac=0.8, random_state=0)
  test_dataset = dataset.drop(train_dataset.index)

sns.pairplot(train_dataset[['MPG', 'Cylinders', 'Displacement', 'Weight']], diag_kind='kde')

train_dataset.describe().transpose()

train_features = train_dataset.copy()
  test_features = test_dataset.copy()
  
  train_labels = train_features.pop('MPG')
  test_labels = test_features.pop('MPG')

train_dataset.describe().transpose()[['mean', 'std']]

normalizer = tf.keras.layers.Normalization(axis=-1)

normalizer.adapt(np.array(train_features))

#Cell added by SuperAIthegod
  train_features_array = np.asarray(train_features).astype('float32')

#Cell added by SuperAIthegod
  normalizer.adapt(np.array(train_features_array))

print(normalizer.mean.numpy())

first = np.array(train_features[:1])
  
  with np.printoptions(precision=2, suppress=True):
    print('First example:', first)
    print()
    print('Normalized:', normalizer(first).numpy())

#Cell added by SuperAIthegod
  first = np.array(train_features_array[:1])
  
  with np.printoptions(precision=2, suppress=True):
    print('First example:', first)
    print()
    print('Normalized:', normalizer(first).numpy())

horsepower = np.array(train_features['Horsepower'])
  
  horsepower_normalizer = layers.Normalization(input_shape=[1,], axis=None)
  horsepower_normalizer.adapt(horsepower)

horsepower_model = tf.keras.Sequential([
      horsepower_normalizer,
      layers.Dense(units=1)
  ])
  
  horsepower_model.summary()

horsepower_model.predict(horsepower[:10])

horsepower_model.compile(
      optimizer=tf.keras.optimizers.Adam(learning_rate=0.1),
      loss='mean_absolute_error')

%%time
  history = horsepower_model.fit(
      train_features['Horsepower'],
      train_labels,
      epochs=100,
      # Suppress logging.
      verbose=0,
      # Calculate validation results on 20% of the training data.
      validation_split = 0.2)

hist = pd.DataFrame(history.history)
  hist['epoch'] = history.epoch
  hist.tail()

def plot_loss(history):
    plt.plot(history.history['loss'], label='loss')
    plt.plot(history.history['val_loss'], label='val_loss')
    plt.ylim([0, 10])
    plt.xlabel('Epoch')
    plt.ylabel('Error [MPG]')
    plt.legend()
    plt.grid(True)

plot_loss(history)

test_results = {}
  
  test_results['horsepower_model'] = horsepower_model.evaluate(
      test_features['Horsepower'],
      test_labels, verbose=0)

x = tf.linspace(0.0, 250, 251)
  y = horsepower_model.predict(x)

def plot_horsepower(x, y):
    plt.scatter(train_features['Horsepower'], train_labels, label='Data')
    plt.plot(x, y, color='k', label='Predictions')
    plt.xlabel('Horsepower')
    plt.ylabel('MPG')
    plt.legend()

plot_horsepower(x, y)

linear_model = tf.keras.Sequential([
      normalizer,
      layers.Dense(units=1)
  ])

linear_model.predict(train_features[:10])

#Cell added by SuperAIthegod
  linear_model.predict(train_features_array[:10])

linear_model.layers[1].kernel

linear_model.compile(
      optimizer=tf.keras.optimizers.Adam(learning_rate=0.1),
      loss='mean_absolute_error')

%%time
  history = linear_model.fit(
      train_features,
      train_labels,
      epochs=100,
      # Suppress logging.
      verbose=0,
      # Calculate validation results on 20% of the training data.
      validation_split = 0.2)

%%time
  #Cell added by SuperAIthegod
  
  history = linear_model.fit(
      train_features_array,
      train_labels,
      epochs=100,
      # Suppress logging.
      verbose=0,
      # Calculate validation results on 20% of the training data.
      validation_split = 0.2)

plot_loss(history)

test_results['linear_model'] = linear_model.evaluate(
      test_features, test_labels, verbose=0)

#Cell added by SuperAIthegod
  test_features_array = np.asarray(test_features).astype('float32')

#Cell added by SuperAIthegod
  test_results['linear_model'] = linear_model.evaluate(
      test_features_array, test_labels, verbose=0)

def build_and_compile_model(norm):
    model = keras.Sequential([
        norm,
        layers.Dense(64, activation='relu'),
        layers.Dense(64, activation='relu'),
        layers.Dense(1)
    ])
  
    model.compile(loss='mean_absolute_error',
                  optimizer=tf.keras.optimizers.Adam(0.001))
    return model

dnn_horsepower_model = build_and_compile_model(horsepower_normalizer)

dnn_horsepower_model.summary()

%%time
  history = dnn_horsepower_model.fit(
      train_features['Horsepower'],
      train_labels,
      validation_split=0.2,
      verbose=0, epochs=100)

plot_loss(history)

x = tf.linspace(0.0, 250, 251)
  y = dnn_horsepower_model.predict(x)

plot_horsepower(x, y)

test_results['dnn_horsepower_model'] = dnn_horsepower_model.evaluate(
      test_features['Horsepower'], test_labels,
      verbose=0)

dnn_model = build_and_compile_model(normalizer)
  dnn_model.summary()

%%time
  history = dnn_model.fit(
      train_features,
      train_labels,
      validation_split=0.2,
      verbose=0, epochs=100)

%%time
  #Cell added by SuperAIthegod
  
  history = dnn_model.fit(
      train_features_array,
      train_labels,
      validation_split=0.2,
      verbose=0, epochs=100)

plot_loss(history)

test_results['dnn_model'] = dnn_model.evaluate(test_features, test_labels, verbose=0)

#Cell added by SuperAIthegod
  test_results['dnn_model'] = dnn_model.evaluate(test_features_array, test_labels, verbose=0)

pd.DataFrame(test_results, index=['Mean absolute error [MPG]']).T

test_predictions = dnn_model.predict(test_features).flatten()
  
  a = plt.axes(aspect='equal')
  plt.scatter(test_labels, test_predictions)
  plt.xlabel('True Values [MPG]')
  plt.ylabel('Predictions [MPG]')
  lims = [0, 50]
  plt.xlim(lims)
  plt.ylim(lims)
  _ = plt.plot(lims, lims)

#Cell added by SuperAIthegod
  test_predictions = dnn_model.predict(test_features_array).flatten()
  
  a = plt.axes(aspect='equal')
  plt.scatter(test_labels, test_predictions)
  plt.xlabel('True Values [MPG]')
  plt.ylabel('Predictions [MPG]')
  lims = [0, 50]
  plt.xlim(lims)
  plt.ylim(lims)
  _ = plt.plot(lims, lims)

error = test_predictions - test_labels
  plt.hist(error, bins=25)
  plt.xlabel('Prediction Error [MPG]')
  _ = plt.ylabel('Count')

dnn_model.save('dnn_model.keras')

reloaded = tf.keras.models.load_model('dnn_model.keras')
  
  test_results['reloaded'] = reloaded.evaluate(
      test_features_array, test_labels, verbose=0)

pd.DataFrame(test_results, index=['Mean absolute error [MPG]']).T

# MIT License
  #
  # Copyright (c) 2017 François Chollet
  #
  # 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.

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))
  print("numpy version: {}".format(np.__version__))

!pip install scikit-learn==1.5.1

!pip install matplotlib==3.9.2

!pip install numpy==2.0.0

import sklearn
  import matplotlib
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("matplotlib version: {}".format(matplotlib.__version__))
  print("numpy version: {}".format(np.__version__))

import numpy as np
  
  from sklearn.datasets import load_digits
  
  data, labels = load_digits(return_X_y=True)
  (n_samples, n_features), n_digits = data.shape, np.unique(labels).size
  
  print(f"# digits: {n_digits}; # samples: {n_samples}; # features {n_features}")

from time import time
  
  from sklearn import metrics
  from sklearn.pipeline import make_pipeline
  from sklearn.preprocessing import StandardScaler
  
  
  def bench_k_means(kmeans, name, data, labels):
      """Benchmark to evaluate the KMeans initialization methods.
  
      Parameters
      ----------
      kmeans : KMeans instance
          A :class:`~sklearn.cluster.KMeans` instance with the initialization
          already set.
      name : str
          Name given to the strategy. It will be used to show the results in a
          table.
      data : ndarray of shape (n_samples, n_features)
          The data to cluster.
      labels : ndarray of shape (n_samples,)
          The labels used to compute the clustering metrics which requires some
          supervision.
      """
      t0 = time()
      estimator = make_pipeline(StandardScaler(), kmeans).fit(data)
      fit_time = time() - t0
      results = [name, fit_time, estimator[-1].inertia_]
  
      # Define the metrics which require only the true labels and estimator
      # labels
      clustering_metrics = [
          metrics.homogeneity_score,
          metrics.completeness_score,
          metrics.v_measure_score,
          metrics.adjusted_rand_score,
          metrics.adjusted_mutual_info_score,
      ]
      results += [m(labels, estimator[-1].labels_) for m in clustering_metrics]
  
      # The silhouette score requires the full dataset
      results += [
          metrics.silhouette_score(
              data,
              estimator[-1].labels_,
              metric="euclidean",
              sample_size=300,
          )
      ]
  
      # Show the results
      formatter_result = (
          "{:9s}\t{:.3f}s\t{:.0f}\t{:.3f}\t{:.3f}\t{:.3f}\t{:.3f}\t{:.3f}\t{:.3f}"
      )
      print(formatter_result.format(*results))

from sklearn.cluster import KMeans
  from sklearn.decomposition import PCA
  
  print(82 * "_")
  print("init\t\ttime\tinertia\thomo\tcompl\tv-meas\tARI\tAMI\tsilhouette")
  
  kmeans = KMeans(init="k-means++", n_clusters=n_digits, n_init=4, random_state=0)
  bench_k_means(kmeans=kmeans, name="k-means++", data=data, labels=labels)
  
  kmeans = KMeans(init="random", n_clusters=n_digits, n_init=4, random_state=0)
  bench_k_means(kmeans=kmeans, name="random", data=data, labels=labels)
  
  pca = PCA(n_components=n_digits).fit(data)
  kmeans = KMeans(init=pca.components_, n_clusters=n_digits, n_init=1)
  bench_k_means(kmeans=kmeans, name="PCA-based", data=data, labels=labels)
  
  print(82 * "_")

import matplotlib.pyplot as plt
  
  reduced_data = PCA(n_components=2).fit_transform(data)
  kmeans = KMeans(init="k-means++", n_clusters=n_digits, n_init=4)
  kmeans.fit(reduced_data)
  
  # Step size of the mesh. Decrease to increase the quality of the VQ.
  h = 0.02  # point in the mesh [x_min, x_max]x[y_min, y_max].
  
  # Plot the decision boundary. For that, we will assign a color to each
  x_min, x_max = reduced_data[:, 0].min() - 1, reduced_data[:, 0].max() + 1
  y_min, y_max = reduced_data[:, 1].min() - 1, reduced_data[:, 1].max() + 1
  xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
  
  # Obtain labels for each point in mesh. Use last trained model.
  Z = kmeans.predict(np.c_[xx.ravel(), yy.ravel()])
  
  # Put the result into a color plot
  Z = Z.reshape(xx.shape)
  plt.figure(1)
  plt.clf()
  plt.imshow(
      Z,
      interpolation="nearest",
      extent=(xx.min(), xx.max(), yy.min(), yy.max()),
      cmap=plt.cm.Paired,
      aspect="auto",
      origin="lower",
  )
  
  plt.plot(reduced_data[:, 0], reduced_data[:, 1], "k.", markersize=2)
  # Plot the centroids as a white X
  centroids = kmeans.cluster_centers_
  plt.scatter(
      centroids[:, 0],
      centroids[:, 1],
      marker="x",
      s=169,
      linewidths=3,
      color="w",
      zorder=10,
  )
  plt.title(
      "K-means clustering on the digits dataset (PCA-reduced data)\n"
      "Centroids are marked with white cross"
  )
  plt.xlim(x_min, x_max)
  plt.ylim(y_min, y_max)
  plt.xticks(())
  plt.yticks(())
  plt.show()

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sklearn
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("numpy version: {}".format(np.__version__))

!pip install scikit-learn==1.5.1

!pip install numpy==2.0.0

import sklearn
  import numpy as np
  import pip
  import sys
  
  print("Python version: {}".format(sys.version))
  print("pip version: {}".format(pip.__version__))
  print("scikit-learn version: {}".format(sklearn.__version__))
  print("numpy version: {}".format(np.__version__))

import numpy as np
  from sklearn import datasets
  from sklearn.semi_supervised import LabelSpreading
  label_prop_model = LabelSpreading()
  iris = datasets.load_iris()
  rng = np.random.RandomState(42)
  random_unlabeled_points = rng.rand(len(iris.target)) < 0.3
  labels = np.copy(iris.target)
  labels[random_unlabeled_points] = -1
  label_prop_model.fit(iris.data, labels)

label_prop_model.score(iris.data, labels)

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import sys
  import gymnasium
  import numpy as np
  import pandas
  import cv2
  import matplotlib
  import pygame
  import torch
  import stable_baselines3
  
  print("Python version: should be: 3.10.5 and the imported version is {}".format(sys.version))
  print("gymnasium version: should be: 0.29.1 and the imported version is {}".format(gymnasium.__version__))
  print("numpy version: should be: 1.25.2 and the imported version is {}".format(np.__version__))
  print("pandas version: should be: 2.0.3 and the imported version is {}".format(pandas.__version__))
  print("cv2 version: should be: 4.7.0.72 and the imported version is {}".format(cv2.__version__))
  print("matplotlib version: should be: 3.7.2 and the imported version is {}".format(matplotlib.__version__))
  print("pygame version: should be: 2.4.0 and the imported version is {}".format(pygame.__version__))
  print("pytorch version: should be: 2.2.1+cu118 and the imported version is {}".format(torch.__version__))
  print("stable_baselines3 version: should be: 2.2.1 and the imported version is {}".format(stable_baselines3.__version__))

!pip install gymnasium==0.29.1

!pip install gymnasium[classic-control]

#!pip install gymnasium[box2d] #doesn't work for Windows at the moment

!pip install gymnasium[atari]

!pip install gymnasium[accept-rom-license]

!pip install numpy==1.25.2

!pip install pandas==2.0.3

!pip install matplotlib==3.7.2

!pip install opencv-python==4.7.0.72

!pip install torch==2.2.1 torchvision==0.17.1 torchaudio==2.2.1 --index-url https://download.pytorch.org/whl/cu118

!pip install stable-baselines3[extra]==2.2.1

!pip install stable-baselines3==2.2.1

import sys
  import gymnasium
  import numpy as np
  import pandas
  import cv2
  import matplotlib
  import pygame
  import torch
  import stable_baselines3
  
  print("Python version: should be: 3.10.5 and the imported version is {}".format(sys.version))
  print("gymnasium version: should be: 0.29.1 and the imported version is {}".format(gymnasium.__version__))
  print("numpy version: should be: 1.25.2 and the imported version is {}".format(np.__version__))
  print("pandas version: should be: 2.0.3 and the imported version is {}".format(pandas.__version__))
  print("cv2 version: should be: 4.7.0.72 and the imported version is {}".format(cv2.__version__))
  print("matplotlib version: should be: 3.7.2 and the imported version is {}".format(matplotlib.__version__))
  print("pygame version: should be: 2.4.0 and the imported version is {}".format(pygame.__version__))
  print("pytorch version: should be: 2.2.1+cu118 and the imported version is {}".format(torch.__version__))
  print("stable_baselines3 version: should be: 2.2.1 and the imported version is {}".format(stable_baselines3.__version__))

import warnings
  warnings.filterwarnings('ignore')
  
  import gymnasium as gym
  env = gym.make("CartPole-v1", render_mode="human")
  env.action_space.seed(42)
  observation, info = env.reset(seed=42)
  score = 0
  all_rewards = []
  
  for _ in range(500):
      env.render()
      action = env.action_space.sample() # your agent here (this takes random actions)
      observation, reward, terminated, truncated, info = env.step(action)
      score += reward
      
      if terminated or truncated:
          all_rewards.append(score)
          score = 0
          observation, info = env.reset()
  
  env.close()
  
  print("All rewards: {}".format(all_rewards))
  print("\nMean reward: {}".format(sum(all_rewards)/len(all_rewards)))

#Check the basic data
  print("Observation shape: \n", observation.shape)
  print("\n",'*'*100)
  print("\nAction space: \b:", env.action_space)
  print("\n",'*'*100)
  print("\nObservation space: \n:", observation)

import warnings
  warnings.filterwarnings('ignore')
  import gymnasium as gym
  
  env = gym.make("LunarLander-v2", render_mode="human")
  
  #env.action_space.seed(42)
  
  observation, info = env.reset()
  
  score = 0
  all_rewards = []
  
  for _ in range(500):
      env.render()
      action = env.action_space.sample() # your agent here (this takes random actions)
      observation, reward, terminated, truncated, info = env.step(action)
      score += reward
      
      if terminated or truncated:
          all_rewards.append(score)
          score = 0
          observation, info = env.reset()
  
  env.close()
  
  print("All rewards: {}".format(all_rewards))
  print("\nMean reward: {}".format(sum(all_rewards)/len(all_rewards)))

#Check the basic data
  print("Observation shape: \n", observation.shape)
  print("\n",'*'*100)
  print("\nAction space: \b:", env.action_space)
  print("\n",'*'*100)
  print("\nObservation space: \n:", observation)

import warnings
  warnings.filterwarnings('ignore')
  
  import gymnasium as gym
  
  env = gym.make("CarRacing-v2", domain_randomize=True, render_mode="human")
  #env.action_space.seed(42)
  observation, info = env.reset(seed=42)
  score = 0
  
  for _ in range(500):
      env.render()
      action = env.action_space.sample() # your agent here (this takes random actions)
      observation, reward, terminated, truncated, info = env.step(action)
      score += reward
      
      if terminated or truncated:
          observation, info = env.reset()
  
  env.close()
  
  print("Score: {}".format(score))

#Check the basic data
  print("Observation shape: \n", observation.shape)
  print("\n",'*'*100)
  print("\nAction space: \b:", env.action_space)
  print("\n",'*'*100)
  print("\nObservation space: \n:", observation)

import warnings
  warnings.filterwarnings('ignore')
  import gymnasium as gym
  
  env = gym.make("ALE/Pong-v5", render_mode="human")
  #env.action_space.seed(42)
  observation, info = env.reset(seed=42)
  score = 0
  
  for _ in range(500):
      env.render()
      action = env.action_space.sample() # your agent here (this takes random actions)
      observation, reward, terminated, truncated, info = env.step(action)
      score += reward
      
      if terminated or truncated:
          observation, info = env.reset()
  
  env.close()
  
  print("Score: {}".format(score))

#Check the basic data
  print("Observation shape: \n", observation.shape)
  print("\n",'*'*100)
  print("\nAction space: \b:", env.action_space)
  print("\n",'*'*100)
  print("\nObservation space: \n:", observation)

import warnings
  warnings.filterwarnings('ignore')
  import gymnasium as gym
  
  env = gym.make("ALE/Breakout-v5", render_mode="human")
  #env.action_space.seed(42)
  observation, info = env.reset()
  
  score = 0
  all_rewards = []
  
  for _ in range(500):
      env.render()
      action = env.action_space.sample() # your agent here (this takes random actions)
      observation, reward, terminated, truncated, info = env.step(action)
      score += reward
      
      if terminated or truncated:
          all_rewards.append(score)
          score = 0
          observation, info = env.reset()
  
  env.close()
  
  print("All rewards: {}".format(all_rewards))
  print("\nMean reward: {}".format(sum(all_rewards)/len(all_rewards)))

#Check the basic data
  print("Observation shape: \n", observation.shape)
  print("\n",'*'*100)
  print("\nAction space: \b:", env.action_space)
  print("\n",'*'*100)
  print("\nObservation space: \n:", observation)

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

import sys
  import gymnasium
  import numpy as np
  import pandas
  import cv2
  import matplotlib
  import pygame
  import torch
  import stable_baselines3
  
  print("Python version: should be: 3.10.5 and the imported version is {}".format(sys.version))
  print("gymnasium version: should be: 0.29.1 and the imported version is {}".format(gymnasium.__version__))
  print("numpy version: should be: 1.25.2 and the imported version is {}".format(np.__version__))
  print("pandas version: should be: 2.0.3 and the imported version is {}".format(pandas.__version__))
  print("cv2 version: should be: 4.7.0.72 and the imported version is {}".format(cv2.__version__))
  print("matplotlib version: should be: 3.7.2 and the imported version is {}".format(matplotlib.__version__))
  print("pygame version: should be: 2.4.0 and the imported version is {}".format(pygame.__version__))
  print("pytorch version: should be: 2.2.1+cu118 and the imported version is {}".format(torch.__version__))
  print("stable_baselines3 version: should be: 2.2.1 and the imported version is {}".format(stable_baselines3.__version__))

!pip install gymnasium==0.29.1

!pip install gymnasium[classic-control]

#!pip install gymnasium[box2d] #doesn't work for Windows at the moment

!pip install gymnasium[atari]

!pip install gymnasium[accept-rom-license]

!pip install numpy==1.25.2

!pip install pandas==2.0.3

!pip install matplotlib==3.7.2

!pip install opencv-python==4.7.0.72

!pip install torch==2.2.1 torchvision==0.17.1 torchaudio==2.2.1 --index-url https://download.pytorch.org/whl/cu118

!pip install stable-baselines3[extra]==2.2.1

!pip install stable-baselines3==2.2.1

import sys
  import gymnasium
  import numpy as np
  import pandas
  import cv2
  import matplotlib
  import pygame
  import torch
  import stable_baselines3
  
  print("Python version: should be: 3.10.5 and the imported version is {}".format(sys.version))
  print("gymnasium version: should be: 0.29.1 and the imported version is {}".format(gymnasium.__version__))
  print("numpy version: should be: 1.25.2 and the imported version is {}".format(np.__version__))
  print("pandas version: should be: 2.0.3 and the imported version is {}".format(pandas.__version__))
  print("cv2 version: should be: 4.7.0.72 and the imported version is {}".format(cv2.__version__))
  print("matplotlib version: should be: 3.7.2 and the imported version is {}".format(matplotlib.__version__))
  print("pygame version: should be: 2.4.0 and the imported version is {}".format(pygame.__version__))
  print("pytorch version: should be: 2.2.1+cu118 and the imported version is {}".format(torch.__version__))
  print("stable_baselines3 version: should be: 2.2.1 and the imported version is {}".format(stable_baselines3.__version__))

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

import gymnasium as gym
  
  from stable_baselines3 import A2C
  from stable_baselines3.common.evaluation import evaluate_policy
  
  env = gym.make("CartPole-v1", render_mode="rgb_array")
  
  model = A2C("MlpPolicy", env, verbose=1)
  #model.learn(total_timesteps=10_000) #Original line from the tutorial hashed out by SuperAIthegod
  
  vec_env = model.get_env()
  obs = vec_env.reset()
  for i in range(1000):
      action, _state = model.predict(obs, deterministic=True)
      obs, reward, done, info = vec_env.step(action)
      vec_env.render("human")
      # VecEnv resets automatically
      # if done:
      #   obs = vec_env.reset()

for i in range(1000):
      action, _state = model.predict(obs, deterministic=True)
      obs, reward, done, info = vec_env.step(action)
      vec_env.render("human")
      
  # Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=10)
  
  untrained_mean_reward = mean_reward
  
  print("\nMean reward of untrained model: {}".format(untrained_mean_reward))

# Now we train for 10000 timesteps
  
  model.learn(total_timesteps=10_000)

# And we check the results
  
  vec_env = model.get_env()
  obs = vec_env.reset()
  for i in range(1000):
      action, _state = model.predict(obs, deterministic=True)
      obs, reward, done, info = vec_env.step(action)
      vec_env.render("human")
      # VecEnv resets automatically
      # if done:
      #   obs = vec_env.reset()
  
  # Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=10)
  
  print("\nMean reward of untrained model: {}".format(untrained_mean_reward))
  print("\nMean reward of trained model: {}".format(mean_reward))

# Now we train for 1_000_000 timesteps
  
  model.learn(total_timesteps=1_000_000)

# And we check the results
  
  vec_env = model.get_env()
  obs = vec_env.reset()
  for i in range(1000):
      action, _state = model.predict(obs, deterministic=True)
      obs, reward, done, info = vec_env.step(action)
      vec_env.render("human")
      # VecEnv resets automatically
      # if done:
      #   obs = vec_env.reset()
  
  # Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=10)
  
  print("\nMean reward of untrained model: {}".format(untrained_mean_reward))
  print("\nMean reward of trained model: {}".format(mean_reward))

# if the window with rendered game didn't close itself, we can try doing something like this:
  
  import cv2
  cv2.destroyAllWindows()

import sys
  import gymnasium
  import numpy as np
  import pandas
  import cv2
  import matplotlib
  import pygame
  import torch
  import stable_baselines3
  
  print("Python version: should be: 3.10.5 and the imported version is {}".format(sys.version))
  print("gymnasium version: should be: 0.29.1 and the imported version is {}".format(gymnasium.__version__))
  print("numpy version: should be: 1.25.2 and the imported version is {}".format(np.__version__))
  print("pandas version: should be: 2.0.3 and the imported version is {}".format(pandas.__version__))
  print("cv2 version: should be: 4.7.0.72 and the imported version is {}".format(cv2.__version__))
  print("matplotlib version: should be: 3.7.2 and the imported version is {}".format(matplotlib.__version__))
  print("pygame version: should be: 2.4.0 and the imported version is {}".format(pygame.__version__))
  print("pytorch version: should be: 2.2.1+cu118 and the imported version is {}".format(torch.__version__))
  print("stable_baselines3 version: should be: 2.2.1 and the imported version is {}".format(stable_baselines3.__version__))

!pip install gymnasium==0.29.1

!pip install gymnasium[classic-control]

#!pip install gymnasium[box2d] #doesn't work for Windows at the moment

!pip install gymnasium[atari]

!pip install gymnasium[accept-rom-license]

!pip install numpy==1.25.2

!pip install pandas==2.0.3

!pip install matplotlib==3.7.2

!pip install opencv-python==4.7.0.72

!pip install torch==2.2.1 torchvision==0.17.1 torchaudio==2.2.1 --index-url https://download.pytorch.org/whl/cu118

!pip install stable-baselines3[extra]==2.2.1

!pip install stable-baselines3==2.2.1

import sys
  import gymnasium
  import numpy as np
  import pandas
  import cv2
  import matplotlib
  import pygame
  import torch
  import stable_baselines3
  
  print("Python version: should be: 3.10.5 and the imported version is {}".format(sys.version))
  print("gymnasium version: should be: 0.29.1 and the imported version is {}".format(gymnasium.__version__))
  print("numpy version: should be: 1.25.2 and the imported version is {}".format(np.__version__))
  print("pandas version: should be: 2.0.3 and the imported version is {}".format(pandas.__version__))
  print("cv2 version: should be: 4.7.0.72 and the imported version is {}".format(cv2.__version__))
  print("matplotlib version: should be: 3.7.2 and the imported version is {}".format(matplotlib.__version__))
  print("pygame version: should be: 2.4.0 and the imported version is {}".format(pygame.__version__))
  print("pytorch version: should be: 2.2.1+cu118 and the imported version is {}".format(torch.__version__))
  print("stable_baselines3 version: should be: 2.2.1 and the imported version is {}".format(stable_baselines3.__version__))

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import gymnasium as gym
  
  from stable_baselines3 import DQN
  from stable_baselines3.common.evaluation import evaluate_policy
  
  
  # Create environment
  env = gym.make("LunarLander-v2", render_mode="rgb_array")
  
  # Instantiate the agent
  model = DQN("MlpPolicy", env, verbose=1)
  # Train the agent and display a progress bar
  #model.learn(total_timesteps=int(2e5), progress_bar=True) #Original line from the example hashed out by SuperAIthegod

# Save the agent
  model.save("dqn_lunar")
  del model  # delete trained model to demonstrate loading

# Load the trained agent
  # NOTE: if you have loading issue, you can pass `print_system_info=True`
  # to compare the system on which the model was trained vs the current one
  # model = DQN.load("dqn_lunar", env=env, print_system_info=True)
  model = DQN.load("dqn_lunar", env=env)
  
  # Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=10)
  
  # Enjoy trained agent
  vec_env = model.get_env()
  obs = vec_env.reset()
  for i in range(1000):
      action, _states = model.predict(obs, deterministic=True)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

untrained_mean_reward = mean_reward
  print("\nMean reward of untrained model: {}".format(untrained_mean_reward))

model.learn(total_timesteps=int(2e5), progress_bar=True)
  
  # Save the agent
  model.save("dqn_lunar")
  del model  # delete trained model to demonstrate loading
  
  # Load the trained agent
  # NOTE: if you have loading issue, you can pass `print_system_info=True`
  # to compare the system on which the model was trained vs the current one
  # model = DQN.load("dqn_lunar", env=env, print_system_info=True)
  model = DQN.load("dqn_lunar", env=env)
  
  # Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=10)
  
  # Enjoy trained agent
  vec_env = model.get_env()
  obs = vec_env.reset()
  for i in range(1000):
      action, _states = model.predict(obs, deterministic=True)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

# Enjoy trained agent
  vec_env = model.get_env()
  obs = vec_env.reset()
  for i in range(1000):
      action, _states = model.predict(obs, deterministic=True)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

print("\nMean reward of untrained model: {}".format(untrained_mean_reward))
  
  print("\nMean reward of trained model: {}".format(mean_reward))

model.learn(total_timesteps=int(1e6), progress_bar=True)
  
  # Save the agent
  model.save("dqn_lunar_1e6")
  del model  # delete trained model to demonstrate loading
  
  # Load the trained agent
  # NOTE: if you have loading issue, you can pass `print_system_info=True`
  # to compare the system on which the model was trained vs the current one
  # model = DQN.load("dqn_lunar", env=env, print_system_info=True)
  model = DQN.load("dqn_lunar_1e6", env=env)
  
  # Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=10)
  
  # Enjoy trained agent
  vec_env = model.get_env()
  obs = vec_env.reset()
  for i in range(1000):
      action, _states = model.predict(obs, deterministic=True)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

# Enjoy trained agent
  vec_env = model.get_env()
  obs = vec_env.reset()
  for i in range(10000):
      action, _states = model.predict(obs, deterministic=True)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

print("\nMean reward of untrained model: {}".format(untrained_mean_reward))
  
  print("\nMean reward of trained model: {}".format(mean_reward))

# if the window with rendered game didn't close itself, we can try doing something like this:
  
  import cv2
  cv2.destroyAllWindows()

import sys
  import gymnasium
  import numpy as np
  import pandas
  import cv2
  import matplotlib
  import pygame
  import torch
  import stable_baselines3
  
  print("Python version: should be: 3.10.5 and the imported version is {}".format(sys.version))
  print("gymnasium version: should be: 0.29.1 and the imported version is {}".format(gymnasium.__version__))
  print("numpy version: should be: 1.25.2 and the imported version is {}".format(np.__version__))
  print("pandas version: should be: 2.0.3 and the imported version is {}".format(pandas.__version__))
  print("cv2 version: should be: 4.7.0.72 and the imported version is {}".format(cv2.__version__))
  print("matplotlib version: should be: 3.7.2 and the imported version is {}".format(matplotlib.__version__))
  print("pygame version: should be: 2.4.0 and the imported version is {}".format(pygame.__version__))
  print("pytorch version: should be: 2.2.1+cu118 and the imported version is {}".format(torch.__version__))
  print("stable_baselines3 version: should be: 2.2.1 and the imported version is {}".format(stable_baselines3.__version__))

!pip install gymnasium==0.29.1

!pip install gymnasium[classic-control]

#!pip install gymnasium[box2d] #doesn't work for Windows at the moment

!pip install gymnasium[atari]

!pip install gymnasium[accept-rom-license]

!pip install numpy==1.25.2

!pip install pandas==2.0.3

!pip install matplotlib==3.7.2

!pip install opencv-python==4.7.0.72

!pip install torch==2.2.1 torchvision==0.17.1 torchaudio==2.2.1 --index-url https://download.pytorch.org/whl/cu118

!pip install stable-baselines3[extra]==2.2.1

!pip install stable-baselines3==2.2.1

import sys
  import gymnasium
  import numpy as np
  import pandas
  import cv2
  import matplotlib
  import pygame
  import torch
  import stable_baselines3
  
  print("Python version: should be: 3.10.5 and the imported version is {}".format(sys.version))
  print("gymnasium version: should be: 0.29.1 and the imported version is {}".format(gymnasium.__version__))
  print("numpy version: should be: 1.25.2 and the imported version is {}".format(np.__version__))
  print("pandas version: should be: 2.0.3 and the imported version is {}".format(pandas.__version__))
  print("cv2 version: should be: 4.7.0.72 and the imported version is {}".format(cv2.__version__))
  print("matplotlib version: should be: 3.7.2 and the imported version is {}".format(matplotlib.__version__))
  print("pygame version: should be: 2.4.0 and the imported version is {}".format(pygame.__version__))
  print("pytorch version: should be: 2.2.1+cu118 and the imported version is {}".format(torch.__version__))
  print("stable_baselines3 version: should be: 2.2.1 and the imported version is {}".format(stable_baselines3.__version__))

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import gymnasium as gym
  
  from stable_baselines3 import PPO
  from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv
  from stable_baselines3.common.env_util import make_vec_env
  from stable_baselines3.common.utils import set_random_seed
  
  def make_env(env_id: str, rank: int, seed: int = 0):
      """
      Utility function for multiprocessed env.
  
      :param env_id: the environment ID
      :param num_env: the number of environments you wish to have in subprocesses
      :param seed: the inital seed for RNG
      :param rank: index of the subprocess
      """
      def _init():
          env = gym.make(env_id, render_mode="human")
          env.reset(seed=seed + rank)
          return env
      set_random_seed(seed)
      return _init
  
  if __name__ == "__main__":
      env_id = "CartPole-v1"
      num_cpu = 4
      # Create the vectorized environment
      vec_env = SubprocVecEnv([make_env(env_id, i) for i in range(num_cpu)])
  
      # Stable Baselines provides you with make_vec_env() helper
      # which does exactly the previous steps for you.
      # You can choose between `DummyVecEnv` (usually faster) and `SubprocVecEnv`
      # env = make_vec_env(env_id, n_envs=num_cpu, seed=0, vec_env_cls=SubprocVecEnv)
  
      model = PPO("MlpPolicy", vec_env, verbose=1)
      #model.learn(total_timesteps=25_000) #Original line from the example hashed out by SuperAIthegod
  
      obs = vec_env.reset()
      for _ in range(1000):
          action, _states = model.predict(obs)
          obs, rewards, dones, info = vec_env.step(action)
          vec_env.render()

from stable_baselines3.common.evaluation import evaluate_policy
  
  # Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=10)
  
  untrained_mean_reward = mean_reward
  print("\nMean reward of untrained model: {}".format(untrained_mean_reward))

if __name__ == "__main__":
      env_id = "CartPole-v1"
      num_cpu = 4
      # Create the vectorized environment
      vec_env = SubprocVecEnv([make_env(env_id, i) for i in range(num_cpu)])
  
      # Stable Baselines provides you with make_vec_env() helper
      # which does exactly the previous steps for you.
      # You can choose between `DummyVecEnv` (usually faster) and `SubprocVecEnv`
      # env = make_vec_env(env_id, n_envs=num_cpu, seed=0, vec_env_cls=SubprocVecEnv)
  
      model = PPO("MlpPolicy", vec_env, verbose=1)
      model.learn(total_timesteps=24_000) #Changed to 24_000 by SuperAIthegod
  
      obs = vec_env.reset()
      for _ in range(1000):
          action, _states = model.predict(obs)
          obs, rewards, dones, info = vec_env.step(action)
          vec_env.render()

# Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=10)
  
  print("\nMean reward of untrained model: {}".format(untrained_mean_reward))
  
  print("\nMean reward of trained model: {}".format(mean_reward))

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

if __name__ == "__main__":
      env_id = "CartPole-v1"
      num_cpu = 4
      # Create the vectorized environment
      vec_env = SubprocVecEnv([make_env(env_id, i) for i in range(num_cpu)])
  
      # Stable Baselines provides you with make_vec_env() helper
      # which does exactly the previous steps for you.
      # You can choose between `DummyVecEnv` (usually faster) and `SubprocVecEnv`
      # env = make_vec_env(env_id, n_envs=num_cpu, seed=0, vec_env_cls=SubprocVecEnv)
  
      model = PPO("MlpPolicy", vec_env, verbose=1)
      model.learn(total_timesteps=1_000_000) #Changed to 1_000_000 by SuperAIthegod
  
      obs = vec_env.reset()
      for _ in range(1000):
          action, _states = model.predict(obs)
          obs, rewards, dones, info = vec_env.step(action)
          vec_env.render()

# Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=10)
  
  print("\nMean reward of untrained model: {}".format(untrained_mean_reward))
  
  print("\nMean reward of trained model: {}".format(mean_reward))

import sys
  import gymnasium
  import numpy as np
  import pandas
  import cv2
  import matplotlib
  import pygame
  import torch
  import stable_baselines3
  
  print("Python version: should be: 3.10.5 and the imported version is {}".format(sys.version))
  print("gymnasium version: should be: 0.29.1 and the imported version is {}".format(gymnasium.__version__))
  print("numpy version: should be: 1.25.2 and the imported version is {}".format(np.__version__))
  print("pandas version: should be: 2.0.3 and the imported version is {}".format(pandas.__version__))
  print("cv2 version: should be: 4.7.0.72 and the imported version is {}".format(cv2.__version__))
  print("matplotlib version: should be: 3.7.2 and the imported version is {}".format(matplotlib.__version__))
  print("pygame version: should be: 2.4.0 and the imported version is {}".format(pygame.__version__))
  print("pytorch version: should be: 2.2.1+cu118 and the imported version is {}".format(torch.__version__))
  print("stable_baselines3 version: should be: 2.2.1 and the imported version is {}".format(stable_baselines3.__version__))

!pip install gymnasium==0.29.1

!pip install gymnasium[classic-control]

#!pip install gymnasium[box2d] #doesn't work for Windows at the moment

!pip install gymnasium[atari]

!pip install gymnasium[accept-rom-license]

!pip install numpy==1.25.2

!pip install pandas==2.0.3

!pip install matplotlib==3.7.2

!pip install opencv-python==4.7.0.72

!pip install torch==2.2.1 torchvision==0.17.1 torchaudio==2.2.1 --index-url https://download.pytorch.org/whl/cu118

!pip install stable-baselines3[extra]==2.2.1

!pip install stable-baselines3==2.2.1

import sys
  import gymnasium
  import numpy as np
  import pandas
  import cv2
  import matplotlib
  import pygame
  import torch
  import stable_baselines3
  
  print("Python version: should be: 3.10.5 and the imported version is {}".format(sys.version))
  print("gymnasium version: should be: 0.29.1 and the imported version is {}".format(gymnasium.__version__))
  print("numpy version: should be: 1.25.2 and the imported version is {}".format(np.__version__))
  print("pandas version: should be: 2.0.3 and the imported version is {}".format(pandas.__version__))
  print("cv2 version: should be: 4.7.0.72 and the imported version is {}".format(cv2.__version__))
  print("matplotlib version: should be: 3.7.2 and the imported version is {}".format(matplotlib.__version__))
  print("pygame version: should be: 2.4.0 and the imported version is {}".format(pygame.__version__))
  print("pytorch version: should be: 2.2.1+cu118 and the imported version is {}".format(torch.__version__))
  print("stable_baselines3 version: should be: 2.2.1 and the imported version is {}".format(stable_baselines3.__version__))

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import gymnasium as gym
  
  from stable_baselines3 import PPO
  from stable_baselines3.common.evaluation import evaluate_policy
  
  # Create environment
  env = gym.make("CarRacing-v2", domain_randomize=True, render_mode="human")
  
  # Instantiate the agent
  model = PPO("CnnPolicy", env, verbose=1, device="cuda")
  # Train the agent and display a progress bar
  #model.learn(total_timesteps=int(2e5), progress_bar=True) #Original line from the example hashed out by SuperAIthegod
  
  # Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=1)
  print("\nMean reward of trained model: {}".format(mean_reward))
  
  # Enjoy trained agent
  vec_env = model.get_env()
  obs = vec_env.reset()
  for i in range(500):
      action, _states = model.predict(obs, deterministic=True)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

import gymnasium as gym
  
  from stable_baselines3 import PPO
  from stable_baselines3.common.evaluation import evaluate_policy
  
  # Create environment
  env = gym.make("CarRacing-v2", domain_randomize=True, render_mode="human")
  
  # Instantiate the agent
  model = PPO("CnnPolicy", env, verbose=1)
  # Train the agent and display a progress bar
  model.learn(total_timesteps=int(10_000), progress_bar=True) #Original line from the example changed by SuperAIthegod
  
  # Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=2)
  print("\nMean reward of trained model: {}".format(mean_reward))
  
  # Enjoy trained agent
  vec_env = model.get_env()
  obs = vec_env.reset()
  for i in range(500):
      action, _states = model.predict(obs, deterministic=True)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

model.save('PPO_car_racing_1e4')

model = PPO.load('PPO_car_racing_1e4', env)

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import gymnasium as gym
  
  from stable_baselines3 import PPO
  from stable_baselines3.common.evaluation import evaluate_policy
  
  # Create environment
  env = gym.make("CarRacing-v2", domain_randomize=True)#, render_mode="human")
  
  # Instantiate the agent
  #model = PPO("CnnPolicy", env, verbose=1) #Original line from the example hashed out by SuperAIthegod
  model = PPO.load('PPO_car_racing_1e4', env) #Original line from the example changed by SuperAIthegod

# Train the agent and display a progress bar
  model.learn(total_timesteps=int(1e6), progress_bar=True) 
  
  # Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=1)
  print("\nMean reward of trained model: {}".format(mean_reward))

model.save('PPO_car_racing_1e6')

model = PPO.load('PPO_car_racing_1e6', env)

# Create environment
  env = gym.make("CarRacing-v2", domain_randomize=True, render_mode="human")
  
  #Load the model
  model = PPO.load('PPO_car_racing_1e6', env)
  
  # Enjoy trained agent
  vec_env = model.get_env()
  obs = vec_env.reset()
  for i in range(500):
      action, _states = model.predict(obs, deterministic=True)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import gymnasium as gym
  
  from stable_baselines3 import PPO
  from stable_baselines3.common.evaluation import evaluate_policy
  
  # Create environment
  env = gym.make("CarRacing-v2", domain_randomize=True)#, render_mode="human")
  
  # Instantiate the agent
  model = PPO("CnnPolicy", env, verbose=1)

# Train the agent and display a progress bar
  model.learn(total_timesteps=int(2e6), progress_bar=True) 
  
  # Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=1)
  print("\nMean reward of trained model: {}".format(mean_reward))

model.save('PPO_car_racing_2e6')

# Create environment
  env = gym.make("CarRacing-v2", domain_randomize=True, render_mode="human")

model = PPO.load('PPO_car_racing_2e6', env)

# Enjoy trained agent
  vec_env = model.get_env()
  obs = vec_env.reset()
  for i in range(500):
      action, _states = model.predict(obs, deterministic=True)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import gymnasium as gym
  
  from stable_baselines3 import PPO
  from stable_baselines3.common.evaluation import evaluate_policy
  
  # Create environment
  env = gym.make("CarRacing-v2", domain_randomize=True)#, render_mode="human")
  
  # Instantiate the agent
  model = PPO("CnnPolicy", env, verbose=1)

# Train the agent and display a progress bar
  model.learn(total_timesteps=int(5e6), progress_bar=True) 
  
  # Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=1)
  print("\nMean reward of trained model: {}".format(mean_reward))

model.save('PPO_car_racing_5e6')

# Create environment
  env = gym.make("CarRacing-v2", domain_randomize=True, render_mode="human")

model = PPO.load('PPO_car_racing_5e6', env)

# Enjoy trained agent
  vec_env = model.get_env()
  obs = vec_env.reset()
  for i in range(500):
      action, _states = model.predict(obs, deterministic=True)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import gymnasium as gym
  
  from stable_baselines3 import PPO
  from stable_baselines3.common.evaluation import evaluate_policy
  
  # Create environment
  env = gym.make("CarRacing-v2", domain_randomize=True, render_mode="human")
  
  # Instantiate the agent
  model = PPO("CnnPolicy", env, verbose=1)

model = PPO.load('PPO_car_racing_1e4', env)

model = PPO.load('PPO_car_racing_1e6', env)

model = PPO.load('PPO_car_racing_2e6', env)

model = PPO.load('PPO_car_racing_5e6', env)

# Enjoy trained agent
  vec_env = model.get_env()
  obs = vec_env.reset()
  for i in range(1000):
      action, _states = model.predict(obs, deterministic=True)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import gymnasium as gym
  
  from stable_baselines3 import PPO
  from stable_baselines3.common.evaluation import evaluate_policy
  
  # Create environment
  env = gym.make("CarRacing-v2", domain_randomize=True, render_mode="human")
  
  # Instantiate the agent
  model = PPO("CnnPolicy", env, verbose=1)

# Create environment
  env = gym.make("CarRacing-v2", domain_randomize=True, render_mode="human")

model = PPO.load('PPO_car_racing_4e5', env)

# Enjoy trained agent
  vec_env = model.get_env()
  obs = vec_env.reset()
  for i in range(1000):
      action, _states = model.predict(obs, deterministic=True)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

# Enjoy trained agent
  vec_env = model.get_env()
  obs = vec_env.reset()
  for i in range(1000):
      action, _states = model.predict(obs, deterministic=True)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

# Enjoy trained agent
  vec_env = model.get_env()
  obs = vec_env.reset()
  for i in range(1000):
      action, _states = model.predict(obs, deterministic=True)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

import sys
  import gymnasium
  import numpy as np
  import pandas
  import cv2
  import matplotlib
  import pygame
  import torch
  import stable_baselines3
  
  print("Python version: should be: 3.10.5 and the imported version is {}".format(sys.version))
  print("gymnasium version: should be: 0.29.1 and the imported version is {}".format(gymnasium.__version__))
  print("numpy version: should be: 1.25.2 and the imported version is {}".format(np.__version__))
  print("pandas version: should be: 2.0.3 and the imported version is {}".format(pandas.__version__))
  print("cv2 version: should be: 4.7.0.72 and the imported version is {}".format(cv2.__version__))
  print("matplotlib version: should be: 3.7.2 and the imported version is {}".format(matplotlib.__version__))
  print("pygame version: should be: 2.4.0 and the imported version is {}".format(pygame.__version__))
  print("pytorch version: should be: 2.2.1+cu118 and the imported version is {}".format(torch.__version__))
  print("stable_baselines3 version: should be: 2.2.1 and the imported version is {}".format(stable_baselines3.__version__))

!pip install gymnasium==0.29.1

!pip install gymnasium[classic-control]

#!pip install gymnasium[box2d] #doesn't work for Windows at the moment

!pip install gymnasium[atari]

!pip install gymnasium[accept-rom-license]

!pip install numpy==1.25.2

!pip install pandas==2.0.3

!pip install matplotlib==3.7.2

!pip install opencv-python==4.7.0.72

!pip install torch==2.2.1 torchvision==0.17.1 torchaudio==2.2.1 --index-url https://download.pytorch.org/whl/cu118

!pip install stable-baselines3[extra]==2.2.1

!pip install stable-baselines3==2.2.1

import sys
  import gymnasium
  import numpy as np
  import pandas
  import cv2
  import matplotlib
  import pygame
  import torch
  import stable_baselines3
  
  print("Python version: should be: 3.10.5 and the imported version is {}".format(sys.version))
  print("gymnasium version: should be: 0.29.1 and the imported version is {}".format(gymnasium.__version__))
  print("numpy version: should be: 1.25.2 and the imported version is {}".format(np.__version__))
  print("pandas version: should be: 2.0.3 and the imported version is {}".format(pandas.__version__))
  print("cv2 version: should be: 4.7.0.72 and the imported version is {}".format(cv2.__version__))
  print("matplotlib version: should be: 3.7.2 and the imported version is {}".format(matplotlib.__version__))
  print("pygame version: should be: 2.4.0 and the imported version is {}".format(pygame.__version__))
  print("pytorch version: should be: 2.2.1+cu118 and the imported version is {}".format(torch.__version__))
  print("stable_baselines3 version: should be: 2.2.1 and the imported version is {}".format(stable_baselines3.__version__))

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import gymnasium as gym
  
  from stable_baselines3 import TD3
  from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv
  from stable_baselines3.common.env_util import make_vec_env
  from stable_baselines3.common.utils import set_random_seed
  
  def make_env(env_id: str, rank: int, seed: int = 0):
      """
      Utility function for multiprocessed env.
  
      :param env_id: the environment ID
      :param num_env: the number of environments you wish to have in subprocesses
      :param seed: the inital seed for RNG
      :param rank: index of the subprocess
      """
      def _init():
          env = gym.make(env_id, render_mode="human")
          env.reset(seed=seed + rank)
          return env
      set_random_seed(seed)
      return _init
  
  if __name__ == "__main__":
      env_id = "LunarLanderContinuous-v2"
      num_cpu = 1  # Number of processes to use
      # Create the vectorized environment
      vec_env = SubprocVecEnv([make_env(env_id, i) for i in range(num_cpu)])
  
      # Stable Baselines provides you with make_vec_env() helper
      # which does exactly the previous steps for you.
      # You can choose between `DummyVecEnv` (usually faster) and `SubprocVecEnv`
      # env = make_vec_env(env_id, n_envs=num_cpu, seed=0, vec_env_cls=SubprocVecEnv)
  
      model = TD3("MlpPolicy", vec_env, verbose=1)
      #model.learn(total_timesteps=25_000) #Original line from the example hashed out by SuperAIthegod
  
      obs = vec_env.reset()
      for _ in range(1000):
          action, _states = model.predict(obs)
          obs, rewards, dones, info = vec_env.step(action)
          vec_env.render()

from stable_baselines3.common.evaluation import evaluate_policy
  
  # Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=10)
  
  untrained_mean_reward = mean_reward
  
  print("\nMean reward of untrained model: {}".format(untrained_mean_reward))

import gymnasium as gym
  
  from stable_baselines3 import TD3
  from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv
  from stable_baselines3.common.env_util import make_vec_env
  from stable_baselines3.common.utils import set_random_seed
  
  def make_env(env_id: str, rank: int, seed: int = 0):
      """
      Utility function for multiprocessed env.
  
      :param env_id: the environment ID
      :param num_env: the number of environments you wish to have in subprocesses
      :param seed: the inital seed for RNG
      :param rank: index of the subprocess
      """
      def _init():
          env = gym.make(env_id, render_mode="human")
          env.reset(seed=seed + rank)
          return env
      set_random_seed(seed)
      return _init
  
  if __name__ == "__main__":
      env_id = "LunarLanderContinuous-v2"
      num_cpu = 1  # Number of processes to use
      # Create the vectorized environment
      vec_env = SubprocVecEnv([make_env(env_id, i) for i in range(num_cpu)])
  
      # Stable Baselines provides you with make_vec_env() helper
      # which does exactly the previous steps for you.
      # You can choose between `DummyVecEnv` (usually faster) and `SubprocVecEnv`
      # env = make_vec_env(env_id, n_envs=num_cpu, seed=0, vec_env_cls=SubprocVecEnv)
  
      model = TD3("MlpPolicy", vec_env, verbose=1)
      model.learn(total_timesteps=25_000) 
  
      obs = vec_env.reset()
      for _ in range(1000):
          action, _states = model.predict(obs)
          obs, rewards, dones, info = vec_env.step(action)
          vec_env.render()

# Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=10)
  
  print("\nMean reward of untrained model: {}".format(untrained_mean_reward))
  
  print("\nMean reward of trained model: {}".format(mean_reward))

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import gymnasium as gym
  
  from stable_baselines3 import TD3
  from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv
  from stable_baselines3.common.env_util import make_vec_env
  from stable_baselines3.common.utils import set_random_seed
  
  def make_env(env_id: str, rank: int, seed: int = 0):
      """
      Utility function for multiprocessed env.
  
      :param env_id: the environment ID
      :param num_env: the number of environments you wish to have in subprocesses
      :param seed: the inital seed for RNG
      :param rank: index of the subprocess
      """
      def _init():
          env = gym.make(env_id, render_mode="human")
          env.reset(seed=seed + rank)
          return env
      set_random_seed(seed)
      return _init
  
  if __name__ == "__main__":
      env_id = "LunarLanderContinuous-v2"
      num_cpu = 1  # Number of processes to use
      # Create the vectorized environment
      vec_env = SubprocVecEnv([make_env(env_id, i) for i in range(num_cpu)])
  
      # Stable Baselines provides you with make_vec_env() helper
      # which does exactly the previous steps for you.
      # You can choose between `DummyVecEnv` (usually faster) and `SubprocVecEnv`
      # env = make_vec_env(env_id, n_envs=num_cpu, seed=0, vec_env_cls=SubprocVecEnv)
  
      model = TD3("MlpPolicy", vec_env, verbose=1)
      model.learn(total_timesteps=1_000_000) 
  
      obs = vec_env.reset()
      for _ in range(1000):
          action, _states = model.predict(obs)
          obs, rewards, dones, info = vec_env.step(action)
          vec_env.render()

model.save('td3_lunar_lander_continous_1e6')

model.load('td3_lunar_lander_continous_1e6')

obs = vec_env.reset()
  for _ in range(1000):
      action, _states = model.predict(obs)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render()

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

import gymnasium as gym
  
  from stable_baselines3 import TD3
  from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv
  from stable_baselines3.common.env_util import make_vec_env
  from stable_baselines3.common.utils import set_random_seed
  
  def make_env(env_id: str, rank: int, seed: int = 0):
      """
      Utility function for multiprocessed env.
  
      :param env_id: the environment ID
      :param num_env: the number of environments you wish to have in subprocesses
      :param seed: the inital seed for RNG
      :param rank: index of the subprocess
      """
      def _init():
          env = gym.make(env_id, render_mode="human")
          env.reset(seed=seed + rank)
          return env
      set_random_seed(seed)
      return _init
  
  if __name__ == "__main__":
      env_id = "LunarLanderContinuous-v2"
      num_cpu = 1  # Number of processes to use
      # Create the vectorized environment
      vec_env = SubprocVecEnv([make_env(env_id, i) for i in range(num_cpu)])
  
      # Stable Baselines provides you with make_vec_env() helper
      # which does exactly the previous steps for you.
      # You can choose between `DummyVecEnv` (usually faster) and `SubprocVecEnv`
      # env = make_vec_env(env_id, n_envs=num_cpu, seed=0, vec_env_cls=SubprocVecEnv)
  
      model = TD3("MlpPolicy", vec_env, verbose=1)

model = model.load('td3_lunar_lander_continous_1e6')

obs = vec_env.reset()
  for _ in range(1000):
      action, _states = model.predict(obs)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render()

import sys
  import gymnasium
  import numpy as np
  import pandas
  import cv2
  import matplotlib
  import pygame
  import torch
  import stable_baselines3
  
  print("Python version: should be: 3.10.5 and the imported version is {}".format(sys.version))
  print("gymnasium version: should be: 0.29.1 and the imported version is {}".format(gymnasium.__version__))
  print("numpy version: should be: 1.25.2 and the imported version is {}".format(np.__version__))
  print("pandas version: should be: 2.0.3 and the imported version is {}".format(pandas.__version__))
  print("cv2 version: should be: 4.7.0.72 and the imported version is {}".format(cv2.__version__))
  print("matplotlib version: should be: 3.7.2 and the imported version is {}".format(matplotlib.__version__))
  print("pygame version: should be: 2.4.0 and the imported version is {}".format(pygame.__version__))
  print("pytorch version: should be: 2.2.1+cu118 and the imported version is {}".format(torch.__version__))
  print("stable_baselines3 version: should be: 2.2.1 and the imported version is {}".format(stable_baselines3.__version__))

!pip install gymnasium==0.29.1

!pip install gymnasium[classic-control]

#!pip install gymnasium[box2d] #doesn't work for Windows at the moment

!pip install gymnasium[atari]

!pip install gymnasium[accept-rom-license]

!pip install numpy==1.25.2

!pip install pandas==2.0.3

!pip install matplotlib==3.7.2

!pip install opencv-python==4.7.0.72

!pip install torch==2.2.1 torchvision==0.17.1 torchaudio==2.2.1 --index-url https://download.pytorch.org/whl/cu118

!pip install stable-baselines3[extra]==2.2.1

!pip install stable-baselines3==2.2.1

import sys
  import gymnasium
  import numpy as np
  import pandas
  import cv2
  import matplotlib
  import pygame
  import torch
  import stable_baselines3
  
  print("Python version: should be: 3.10.5 and the imported version is {}".format(sys.version))
  print("gymnasium version: should be: 0.29.1 and the imported version is {}".format(gymnasium.__version__))
  print("numpy version: should be: 1.25.2 and the imported version is {}".format(np.__version__))
  print("pandas version: should be: 2.0.3 and the imported version is {}".format(pandas.__version__))
  print("cv2 version: should be: 4.7.0.72 and the imported version is {}".format(cv2.__version__))
  print("matplotlib version: should be: 3.7.2 and the imported version is {}".format(matplotlib.__version__))
  print("pygame version: should be: 2.4.0 and the imported version is {}".format(pygame.__version__))
  print("pytorch version: should be: 2.2.1+cu118 and the imported version is {}".format(torch.__version__))
  print("stable_baselines3 version: should be: 2.2.1 and the imported version is {}".format(stable_baselines3.__version__))

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

from stable_baselines3.common.env_util import make_atari_env
  from stable_baselines3.common.vec_env import VecFrameStack
  from stable_baselines3 import A2C
  
  # There already exists an environment generator
  # that will make and wrap atari environments correctly.
  # Here we are also multi-worker training (n_envs=4 => 4 environments)
  vec_env = make_atari_env("PongNoFrameskip-v4", n_envs=4, seed=0)
  # Frame-stacking with 4 frames
  vec_env = VecFrameStack(vec_env, n_stack=4)
  
  model = A2C("CnnPolicy", vec_env, verbose=1)
  #model.learn(total_timesteps=25_000) Original line from the example hashed out by SuperAIthegod
  
  obs = vec_env.reset()
  #while True: #ORIGINAL LINE FROM THE EXAMPLE
  for _ in range(1000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

from stable_baselines3.common.evaluation import evaluate_policy
  
  # Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=10)
  
  untrained_mean_reward = mean_reward
  
  print("\nMean reward of untrained model: {}".format(untrained_mean_reward))

from stable_baselines3.common.env_util import make_atari_env
  from stable_baselines3.common.vec_env import VecFrameStack
  from stable_baselines3 import A2C
  
  # There already exists an environment generator
  # that will make and wrap atari environments correctly.
  # Here we are also multi-worker training (n_envs=4 => 4 environments)
  vec_env = make_atari_env("PongNoFrameskip-v4", n_envs=4, seed=0)
  # Frame-stacking with 4 frames
  vec_env = VecFrameStack(vec_env, n_stack=4)
  
  model = A2C("CnnPolicy", vec_env, verbose=1)
  model.learn(total_timesteps=25_000)
  
  obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(1000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

# Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=10)
  
  print("\nMean reward of untrained model: {}".format(untrained_mean_reward))
  
  print("\nMean reward of trained model: {}".format(mean_reward))

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

from stable_baselines3.common.env_util import make_atari_env
  from stable_baselines3.common.vec_env import VecFrameStack
  from stable_baselines3 import A2C
  
  # There already exists an environment generator
  # that will make and wrap atari environments correctly.
  # Here we are also multi-worker training (n_envs=4 => 4 environments)
  vec_env = make_atari_env("PongNoFrameskip-v4", n_envs=4, seed=0)
  # Frame-stacking with 4 frames
  vec_env = VecFrameStack(vec_env, n_stack=4)
  
  model = A2C("CnnPolicy", vec_env, verbose=1)

model.learn(total_timesteps=1_000_000)
  
  obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(1000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

model.save('pong_1e6')

model.load('pong_1e6')

obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(1000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

from stable_baselines3.common.env_util import make_atari_env
  from stable_baselines3.common.vec_env import VecFrameStack
  from stable_baselines3 import A2C
  
  # There already exists an environment generator
  # that will make and wrap atari environments correctly.
  # Here we are also multi-worker training (n_envs=4 => 4 environments)
  vec_env = make_atari_env("PongNoFrameskip-v4", n_envs=16, seed=0)
  # Frame-stacking with 4 frames
  vec_env = VecFrameStack(vec_env, n_stack=4)
  
  model = A2C("CnnPolicy", vec_env, verbose=1)

model.learn(total_timesteps=10_000_000)
  
  obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(1000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

model.save('pong_1e7')

model.load('pong_1e7')

obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(1000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

from stable_baselines3.common.env_util import make_atari_env
  from stable_baselines3.common.vec_env import VecFrameStack
  from stable_baselines3 import A2C
  
  # There already exists an environment generator
  # that will make and wrap atari environments correctly.
  # Here we are also multi-worker training (n_envs=4 => 4 environments)
  vec_env = make_atari_env("PongNoFrameskip-v4", n_envs=16, seed=0)
  # Frame-stacking with 4 frames
  vec_env = VecFrameStack(vec_env, n_stack=4)
  
  model = A2C("CnnPolicy", vec_env, verbose=1)

model.learn(total_timesteps=10_000_000)
  
  obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(1000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

model.save('pong_1e7less')

model.load('pong_1e7less')

obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(1000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

from stable_baselines3.common.env_util import make_atari_env
  from stable_baselines3.common.vec_env import VecFrameStack
  from stable_baselines3 import A2C
  
  # There already exists an environment generator
  # that will make and wrap atari environments correctly.
  # Here we are also multi-worker training (n_envs=4 => 4 environments)
  vec_env = make_atari_env("PongNoFrameskip-v4", n_envs=16, seed=0)
  # Frame-stacking with 4 frames
  vec_env = VecFrameStack(vec_env, n_stack=4)
  
  model = A2C("CnnPolicy", vec_env, verbose=1)

model = model.load('pong_1e6')

obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(2000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

model = model.load('pong_1e7')

obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(2000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

model = model.load('pong_1e7less')

obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(2000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

import sys
  import gymnasium
  import numpy as np
  import pandas
  import cv2
  import matplotlib
  import pygame
  import torch
  import stable_baselines3
  
  print("Python version: should be: 3.10.5 and the imported version is {}".format(sys.version))
  print("gymnasium version: should be: 0.29.1 and the imported version is {}".format(gymnasium.__version__))
  print("numpy version: should be: 1.25.2 and the imported version is {}".format(np.__version__))
  print("pandas version: should be: 2.0.3 and the imported version is {}".format(pandas.__version__))
  print("cv2 version: should be: 4.7.0.72 and the imported version is {}".format(cv2.__version__))
  print("matplotlib version: should be: 3.7.2 and the imported version is {}".format(matplotlib.__version__))
  print("pygame version: should be: 2.4.0 and the imported version is {}".format(pygame.__version__))
  print("pytorch version: should be: 2.2.1+cu118 and the imported version is {}".format(torch.__version__))
  print("stable_baselines3 version: should be: 2.2.1 and the imported version is {}".format(stable_baselines3.__version__))

!pip install gymnasium==0.29.1

!pip install gymnasium[classic-control]

#!pip install gymnasium[box2d] #doesn't work for Windows at the moment

!pip install gymnasium[atari]

!pip install gymnasium[accept-rom-license]

!pip install numpy==1.25.2

!pip install pandas==2.0.3

!pip install matplotlib==3.7.2

!pip install opencv-python==4.7.0.72

!pip install torch==2.2.1 torchvision==0.17.1 torchaudio==2.2.1 --index-url https://download.pytorch.org/whl/cu118

!pip install stable-baselines3[extra]==2.2.1

!pip install stable-baselines3==2.2.1

import sys
  import gymnasium
  import numpy as np
  import pandas
  import cv2
  import matplotlib
  import pygame
  import torch
  import stable_baselines3
  
  print("Python version: should be: 3.10.5 and the imported version is {}".format(sys.version))
  print("gymnasium version: should be: 0.29.1 and the imported version is {}".format(gymnasium.__version__))
  print("numpy version: should be: 1.25.2 and the imported version is {}".format(np.__version__))
  print("pandas version: should be: 2.0.3 and the imported version is {}".format(pandas.__version__))
  print("cv2 version: should be: 4.7.0.72 and the imported version is {}".format(cv2.__version__))
  print("matplotlib version: should be: 3.7.2 and the imported version is {}".format(matplotlib.__version__))
  print("pygame version: should be: 2.4.0 and the imported version is {}".format(pygame.__version__))
  print("pytorch version: should be: 2.2.1+cu118 and the imported version is {}".format(torch.__version__))
  print("stable_baselines3 version: should be: 2.2.1 and the imported version is {}".format(stable_baselines3.__version__))

import torch

torch.cuda.is_available()

device = (
      "cuda"
      if torch.cuda.is_available()
      else "mps"
      if torch.backends.mps.is_available()
      else "cpu"
  )
  print(f"Using {device} device")

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

from stable_baselines3.common.env_util import make_atari_env
  from stable_baselines3.common.vec_env import VecFrameStack
  from stable_baselines3 import A2C
  
  # There already exists an environment generator
  # that will make and wrap atari environments correctly.
  # Here we are also multi-worker training (n_envs=4 => 4 environments)
  vec_env = make_atari_env("BreakoutNoFrameskip-v4", n_envs=4, seed=0)
  # Frame-stacking with 4 frames
  vec_env = VecFrameStack(vec_env, n_stack=4)
  
  model = A2C("CnnPolicy", vec_env, verbose=1)
  #model.learn(total_timesteps=25_000) #Original line from the example hashed out by SuperAIthegod
  
  obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(1000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

from stable_baselines3.common.evaluation import evaluate_policy
  
  # Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=10)
  
  untrained_mean_reward = mean_reward
  
  print("\nMean reward of untrained model: {}".format(untrained_mean_reward))

from stable_baselines3.common.env_util import make_atari_env
  from stable_baselines3.common.vec_env import VecFrameStack
  from stable_baselines3 import A2C
  
  # There already exists an environment generator
  # that will make and wrap atari environments correctly.
  # Here we are also multi-worker training (n_envs=4 => 4 environments)
  vec_env = make_atari_env("BreakoutNoFrameskip-v4", n_envs=4, seed=0)
  # Frame-stacking with 4 frames
  vec_env = VecFrameStack(vec_env, n_stack=4)
  
  model = A2C("CnnPolicy", vec_env, verbose=1)
  model.learn(total_timesteps=25_000)
  
  obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(1000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

# Evaluate the agent
  # NOTE: If you use wrappers with your environment that modify rewards,
  #       this will be reflected here. To evaluate with original rewards,
  #       wrap environment in a "Monitor" wrapper before other wrappers.
  
  mean_reward, std_reward = evaluate_policy(model, model.get_env(), n_eval_episodes=10)
  
  print("\nMean reward of untrained model: {}".format(untrained_mean_reward))
  
  print("\nMean reward of trained model: {}".format(mean_reward))

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

from stable_baselines3.common.env_util import make_atari_env
  from stable_baselines3.common.vec_env import VecFrameStack
  from stable_baselines3 import A2C
  
  # There already exists an environment generator
  # that will make and wrap atari environments correctly.
  # Here we are also multi-worker training (n_envs=4 => 4 environments)
  vec_env = make_atari_env("BreakoutNoFrameskip-v4", n_envs=4, seed=0)
  # Frame-stacking with 4 frames
  vec_env = VecFrameStack(vec_env, n_stack=4)
  
  model = A2C("CnnPolicy", vec_env, verbose=1)

model.learn(total_timesteps=1_000_000) #Original line from the example changed by SuperAIthegod
  
  obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(1000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

model.save('breakout_1e6')

model.load('breakout_1e6')

obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(1000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

from stable_baselines3.common.env_util import make_atari_env
  from stable_baselines3.common.vec_env import VecFrameStack
  from stable_baselines3 import A2C
  
  # There already exists an environment generator
  # that will make and wrap atari environments correctly.
  # Here we are also multi-worker training (n_envs=4 => 4 environments)
  vec_env = make_atari_env("BreakoutNoFrameskip-v4", n_envs=4, seed=0)
  # Frame-stacking with 4 frames
  vec_env = VecFrameStack(vec_env, n_stack=4)
  
  model = A2C("CnnPolicy", vec_env, verbose=1)

model.learn(total_timesteps=5_000_000) #Original line from the example changed by SuperAIthegod
  
  obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(1000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

model.save('breakout_5e6')

model.load('breakout_5e6')

obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(1000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

from stable_baselines3.common.env_util import make_atari_env
  from stable_baselines3.common.vec_env import VecFrameStack
  from stable_baselines3 import A2C
  
  # There already exists an environment generator
  # that will make and wrap atari environments correctly.
  # Here we are also multi-worker training (n_envs=4 => 4 environments)
  vec_env = make_atari_env("BreakoutNoFrameskip-v4", n_envs=16, seed=0)
  # Frame-stacking with 4 frames
  vec_env = VecFrameStack(vec_env, n_stack=4)
  
  model = A2C("CnnPolicy", vec_env, verbose=1)

model.learn(total_timesteps=10_000_000) #Original line from the example changed by SuperAIthegod
  
  obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(1000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

model.save('breakout_1e7')

model.load('breakout_1e7')

obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(10000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

#0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques. 
  #0A. Open Anaconda.
  #0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
  #0C. Open Jupyter Notebook.
  #0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
  import warnings
  warnings.filterwarnings('ignore')

from stable_baselines3.common.env_util import make_atari_env
  from stable_baselines3.common.vec_env import VecFrameStack
  from stable_baselines3 import A2C
  
  # There already exists an environment generator
  # that will make and wrap atari environments correctly.
  # Here we are also multi-worker training (n_envs=4 => 4 environments)
  vec_env = make_atari_env("BreakoutNoFrameskip-v4", n_envs=1, seed=0)
  # Frame-stacking with 4 frames
  vec_env = VecFrameStack(vec_env, n_stack=4)
  
  model = A2C("CnnPolicy", vec_env, verbose=1)

model = model.load('breakout_1e6')

obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(1000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

model = model.load('breakout_5e6')

obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(1000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

model = model.load('breakout_1e7')

obs = vec_env.reset()
  #while True: #Original line from the example hashed out by SuperAIthegod
  for _ in range(1000): #Line added by SuperAIthegod
      action, _states = model.predict(obs, deterministic=False)
      obs, rewards, dones, info = vec_env.step(action)
      vec_env.render("human")

Can AI create a trading bot?
Alpaca
Task by	Claude Anthropic (US)	Llama Meta (US)	Mistral AI (EU)	Gemini Google (US)	ChatGPT OpenAI (US)	Copilot Microsoft (US)	Perplexity (US)	DeepSeek AI (CN)
Score	2 / 5	0 / 5	0 / 5	0 / 5	1 / 5	0 / 5	1 / 5	3 / 5
1. Connecting to Alpaca API Using alpaca-py Library Create a bot that connects to Alpaca: Write a Python program that connects to the Alpaca API using the alpaca-py library. Ensure it retrieves and prints paper trading account information for verification. Do not use alpaca-trade-api.
2. Implementing Buy and Sell Functions for BTC Add functionality for buying and selling BTC: Write a Python program. Implement functions to place buy and sell orders for BTC using API. Use paper trading mode to simulate real trades. Buy 0.1 BTC. Wait for 15 seconds. Check if you have BTC to sell. Sell all the BTC you have. Include logic to determine your current BTC balance before placing the sell order. Take into account the trading fees and sell appropriately. Remember to use proper parameters for crypto, like: time_in_force.
3. Fetching Current BTC Price Using Alpaca API Write a Python program. Use an API and alpaca-py to fetch the current price of BTC. Implement a loop that runs every 15 seconds to retrieve and print the BTC price. Do not use asynchronous programming.
4. Implementing RSI Calculation with vectorbt Write a Python script that fetches the current price of Bitcoin (BTC) from Alpaca API, stores the latest prices in a list (keeping a maximum of 15 prices), and calculates the Relative Strength Index (RSI) using the vectorbt library. The script should continuously fetch the BTC price every 5 seconds and print the current BTC price along with the calculated RSI. If the RSI is less than 30, print a "Buy signal" message, and if the RSI is greater than 70, print a "Sell signal" message. Include detailed comments and print statements for intermediate values. Do not use asynchronous programming.
5. Implementing BTC Trading Strategy with RSI Indicator Write a Python program. Use the RSI indicator from the previous code with standard thresholds (buy when RSI < 30, sell when RSI > 70) to implement a trading strategy for Bitcoin (BTC) using the Alpaca API. The strategy should include fetching the current BTC price using the Alpaca API via e.g. a separate CryptoHistoricalDataClient, which will specifically handle requests for the latest quotes using CryptoLatestQuoteRequest. Additionally, utilize the TradingClient for executing orders: buy 0.1 BTC when RSI is below 30 if you don't have any bitcoins and sell all BTC holdings when RSI is over 70. Do not use alpaca_trade_api. Implement the strategy in paper trading mode to simulate trades, keep track of BTC holdings and account balance, and print the current BTC price, RSI value, and any trade actions taken. Do not use asynchronous programming.
Binance
Task by	Claude Anthropic (US)	Llama Meta (US)	Mistral AI (EU)	Gemini Google (US)	ChatGPT OpenAI (US)	Copilot Microsoft (US)	Perplexity (US)	DeepSeek AI (CN)
1. Connecting to Binance API Create a bot that connects to Binance: Write a Python program that connects to the Binance API using the proper library. Ensure it retrieves and prints paper trading account information for verification.
2. Implementing Buy and Sell Functions for BTC Add functionality for buying and selling BTC: Write a Python program. Implement functions to place buy and sell orders for BTC using API. Use paper trading mode to simulate real trades. Buy 0.1 BTC. Wait for 15 seconds. Check if you have BTC to sell. Sell all the BTC you have. Include logic to determine your current BTC balance before placing the sell order. Take into account the trading fees and sell appropriately.
Interactive Brokers
Task by	Claude Anthropic (US)	Llama Meta (US)	Mistral AI (EU)	Gemini Google (US)	ChatGPT OpenAI (US)	Copilot Microsoft (US)	Perplexity (US)	DeepSeek AI (CN)
1. Connecting to Interactive Brokers API Create a bot that connects to Interactive Brokers: Write a Python program that connects to the IB API using the proper library. Ensure it retrieves and prints paper trading account information for verification.
2. Implementing Buy and Sell Functions for BTC Add functionality for buying and selling BTC: Write a Python program. Implement functions to place buy and sell orders for BTC using API. Use paper trading mode to simulate real trades. Buy 0.1 BTC. Wait for 15 seconds. Check if you have BTC to sell. Sell all the BTC you have. Include logic to determine your current BTC balance before placing the sell order. Take into account the trading fees and sell appropriately.

0. Setup the environment for training, testing, and using SuperAI with chosen machine learning techniques.
0A. Open Anaconda.
0B. Create and set (if you want) the environment to work in. It must be done only once per preffered settings.
0C. Open Jupyter Notebook.
0D. Import and use (if you want) the 'warnings' library that is preinstalled with Anaconda to make the ouput cleaner.
1. Copy the preferred model from the chosen location.

From Chat GPT to Decision Trees and back - introduction to AI and machine learning in Python¶

INTRODUCTION

ADVANCED LARGE LANGUAGE MODELS AND MULTIMODAL MODELS - LLMs AND LMMs)

SUPERVISED LEARNING

CLASSIFICATION¶

REGRESSION¶

UNSUPERVISED LEARNING

SEMI-SUPERVISED LEARNING

REINFORCEMENT LEARNING

AND BACK AND BEYOND...

INTRODUCTION AND THEORY (SKIP IT IF YOU WANT)¶

A LITTLE BIT OF THEORY

BASIC CONCEPTS OF ARTIFICIAL INTELLIGENCE AND MACHINE LEARNING

"Can we create friendly artificial superintelligence in next 50 years?"

MACHINE LEARNING - BASIC CONCEPTS

A LOT OF PRACTICE

0. Chat GPT (from OpenAI), Gemini (from Google), Copilot (from Microsoft), Claude (from Anthropic), Llama (from Meta), Mistral (from Mistral AI), Grok (from X), Smaug (from Abacus AI), ...¶

ADVANCED LARGE LANGUAGE MODELS AND MULTIMODAL MODELS - LLMs AND LMMs)

BASIC MODEL FROM EXAMPLES

Basic steps in testing examples of different machine learning models¶

Basic steps in creating a helpful AI that uses machine learning techniques¶

SUPERVISED LEARNING

CLASSIFICATION¶

Classification with non-neural networks, non-deep learning algorithms¶

1. Decision Trees Classifier with Scikit-Learn¶

Environment: scikit-learn-env

BASIC COPY - PASTE¶

BASIC IMPROVEMENTS¶

2. Logistic Regression with Scikit-Learn¶

Environment: scikit-learn-env

BASIC COPY - PASTE¶

BASIC IMPROVEMENTS¶

3. Naive Bayes with Scikit-Learn¶

Environment: scikit-learn-env

BASIC COPY - PASTE¶

BASIC IMPROVEMENTS¶

4. Support Vector Classifier (SVC) with Scikit-Learn¶

Environment: scikit-learn-env

BASIC COPY - PASTE¶

BASIC IMPROVEMENTS¶

5. SGD with Scikit-Learn¶

Environment: scikit-learn-env

BASIC COPY - PASTE¶

BASIC IMPROVEMENTS¶

6. k-nearest neighbors (KNN) with Scikit-Learn¶

Environment: scikit-learn-env

BASIC COPY - PASTE¶

BASIC IMPROVEMENTS¶

7. Random Forest Classifier with Scikit-Learn¶

Environment: scikit-learn-env

BASIC COPY - PASTE¶

BASIC IMPROVEMENTS¶

8. Bagging with Scikit-Learn¶

Environment: scikit-learn-env

BASIC COPY - PASTE¶

BASIC IMPROVEMENTS¶

9. Gradient Boosting Classifier with Scikit-Learn¶

Environment: scikit-learn-env

BASIC COPY - PASTE¶

BASIC IMPROVEMENTS¶

10. Gradient Boosted Tree (GBT) with XGBoost¶

Environment: scikit-learn-env

BASIC COPY - PASTE¶

BASIC IMPROVEMENTS¶

11. Light GBM with lightgbm¶

Environment: scikit-learn-env

BASIC COPY - PASTE¶

BASIC IMPROVEMENTS¶

12. AdaBoost with Scikit-Learn¶

Environment: scikit-learn-env

BASIC COPY - PASTE¶

Version 1: basic copy - paste¶

Version 2: basic copy - paste¶

BASIC IMPROVEMENTS¶

Version 1: basic improvements¶

Version 2: basic improvements¶

13. Voting (Hard and Soft) Classifiers (Ensamble Method) with Scikit-Learn¶

Environment: scikit-learn-env

BASIC COPY - PASTE¶

Version 1: Hard Voting¶