Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data_X.csv filter=lfs diff=lfs merge=lfs -text
+swig/Doc/Manual/SWIGDocumentation.pdf filter=lfs diff=lfs merge=lfs -text
+swig/swig.exe filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/Box2D/_Box2D.cp38-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/OffsetCorrection.iml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/venv" />
+    </content>
+    <orderEntry type="jdk" jdkName="Python 3.8 (3)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.8 (3)" project-jdk-type="Python SDK" />
+  <component name="PythonCompatibilityInspectionAdvertiser">
+    <option name="version" value="3" />
+  </component>
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/OffsetCorrection.iml" filepath="$PROJECT_DIR$/.idea/OffsetCorrection.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
+  </component>
+</project>

.idea/workspace.xml

@@ -0,0 +1,198 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AutoImportSettings">
+    <option name="autoReloadType" value="SELECTIVE" />
+  </component>
+  <component name="ChangeListManager">
+    <list default="true" id="dfea19b1-4908-4385-95c7-1034aa4a3734" name="Changes" comment="" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="FileTemplateManagerImpl">
+    <option name="RECENT_TEMPLATES">
+      <list>
+        <option value="Python Script" />
+      </list>
+    </option>
+  </component>
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$/../.." />
+  </component>
+  <component name="MarkdownSettingsMigration">
+    <option name="stateVersion" value="1" />
+  </component>
+  <component name="ProjectId" id="2R5tSkfENsWTRYKIGSNHXfkC3Ne" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent">{
+  &quot;keyToString&quot;: {
+    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
+    &quot;ToolWindowRun.ShowToolbar&quot;: &quot;false&quot;,
+    &quot;git-widget-placeholder&quot;: &quot;master&quot;,
+    &quot;settings.editor.selected.configurable&quot;: &quot;com.jetbrains.python.configuration.PyActiveSdkModuleConfigurable&quot;
+  }
+}</component>
+  <component name="RunManager" selected="Python.data_visualization">
+    <configuration name="Oreilly_Ensamble_RandomForest" type="PythonConfigurationType" factoryName="Python" temporary="true" nameIsGenerated="true">
+      <module name="OffsetCorrection" />
+      <option name="INTERPRETER_OPTIONS" value="" />
+      <option name="PARENT_ENVS" value="true" />
+      <envs>
+        <env name="PYTHONUNBUFFERED" value="1" />
+      </envs>
+      <option name="SDK_HOME" value="" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+      <option name="IS_MODULE_SDK" value="true" />
+      <option name="ADD_CONTENT_ROOTS" value="true" />
+      <option name="ADD_SOURCE_ROOTS" value="true" />
+      <option name="SCRIPT_NAME" value="$PROJECT_DIR$/Oreilly_Ensamble_RandomForest.py" />
+      <option name="PARAMETERS" value="" />
+      <option name="SHOW_COMMAND_LINE" value="false" />
+      <option name="EMULATE_TERMINAL" value="false" />
+      <option name="MODULE_MODE" value="false" />
+      <option name="REDIRECT_INPUT" value="false" />
+      <option name="INPUT_FILE" value="" />
+      <method v="2" />
+    </configuration>
+    <configuration name="Oreilly_Example1" type="PythonConfigurationType" factoryName="Python" temporary="true" nameIsGenerated="true">
+      <module name="OffsetCorrection" />
+      <option name="INTERPRETER_OPTIONS" value="" />
+      <option name="PARENT_ENVS" value="true" />
+      <envs>
+        <env name="PYTHONUNBUFFERED" value="1" />
+      </envs>
+      <option name="SDK_HOME" value="" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+      <option name="IS_MODULE_SDK" value="true" />
+      <option name="ADD_CONTENT_ROOTS" value="true" />
+      <option name="ADD_SOURCE_ROOTS" value="true" />
+      <option name="SCRIPT_NAME" value="$PROJECT_DIR$/Oreilly_Example1.py" />
+      <option name="PARAMETERS" value="" />
+      <option name="SHOW_COMMAND_LINE" value="false" />
+      <option name="EMULATE_TERMINAL" value="false" />
+      <option name="MODULE_MODE" value="false" />
+      <option name="REDIRECT_INPUT" value="false" />
+      <option name="INPUT_FILE" value="" />
+      <method v="2" />
+    </configuration>
+    <configuration name="Oreilly_LogisticReg" type="PythonConfigurationType" factoryName="Python" temporary="true" nameIsGenerated="true">
+      <module name="OffsetCorrection" />
+      <option name="INTERPRETER_OPTIONS" value="" />
+      <option name="PARENT_ENVS" value="true" />
+      <envs>
+        <env name="PYTHONUNBUFFERED" value="1" />
+      </envs>
+      <option name="SDK_HOME" value="" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+      <option name="IS_MODULE_SDK" value="true" />
+      <option name="ADD_CONTENT_ROOTS" value="true" />
+      <option name="ADD_SOURCE_ROOTS" value="true" />
+      <option name="SCRIPT_NAME" value="$PROJECT_DIR$/Oreilly_LogisticReg.py" />
+      <option name="PARAMETERS" value="" />
+      <option name="SHOW_COMMAND_LINE" value="false" />
+      <option name="EMULATE_TERMINAL" value="false" />
+      <option name="MODULE_MODE" value="false" />
+      <option name="REDIRECT_INPUT" value="false" />
+      <option name="INPUT_FILE" value="" />
+      <method v="2" />
+    </configuration>
+    <configuration name="Oreilly_SVM" type="PythonConfigurationType" factoryName="Python" temporary="true" nameIsGenerated="true">
+      <module name="OffsetCorrection" />
+      <option name="INTERPRETER_OPTIONS" value="" />
+      <option name="PARENT_ENVS" value="true" />
+      <envs>
+        <env name="PYTHONUNBUFFERED" value="1" />
+      </envs>
+      <option name="SDK_HOME" value="" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+      <option name="IS_MODULE_SDK" value="true" />
+      <option name="ADD_CONTENT_ROOTS" value="true" />
+      <option name="ADD_SOURCE_ROOTS" value="true" />
+      <option name="SCRIPT_NAME" value="$PROJECT_DIR$/Oreilly_SVM.py" />
+      <option name="PARAMETERS" value="" />
+      <option name="SHOW_COMMAND_LINE" value="false" />
+      <option name="EMULATE_TERMINAL" value="false" />
+      <option name="MODULE_MODE" value="false" />
+      <option name="REDIRECT_INPUT" value="false" />
+      <option name="INPUT_FILE" value="" />
+      <method v="2" />
+    </configuration>
+    <configuration name="data_visualization" type="PythonConfigurationType" factoryName="Python" temporary="true" nameIsGenerated="true">
+      <module name="OffsetCorrection" />
+      <option name="INTERPRETER_OPTIONS" value="" />
+      <option name="PARENT_ENVS" value="true" />
+      <envs>
+        <env name="PYTHONUNBUFFERED" value="1" />
+      </envs>
+      <option name="SDK_HOME" value="" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+      <option name="IS_MODULE_SDK" value="true" />
+      <option name="ADD_CONTENT_ROOTS" value="true" />
+      <option name="ADD_SOURCE_ROOTS" value="true" />
+      <option name="SCRIPT_NAME" value="$PROJECT_DIR$/data_visualization.py" />
+      <option name="PARAMETERS" value="" />
+      <option name="SHOW_COMMAND_LINE" value="false" />
+      <option name="EMULATE_TERMINAL" value="false" />
+      <option name="MODULE_MODE" value="false" />
+      <option name="REDIRECT_INPUT" value="false" />
+      <option name="INPUT_FILE" value="" />
+      <method v="2" />
+    </configuration>
+    <configuration name="main" type="PythonConfigurationType" factoryName="Python" nameIsGenerated="true">
+      <module name="OffsetCorrection" />
+      <option name="INTERPRETER_OPTIONS" value="" />
+      <option name="PARENT_ENVS" value="true" />
+      <envs>
+        <env name="PYTHONUNBUFFERED" value="1" />
+      </envs>
+      <option name="SDK_HOME" value="" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+      <option name="IS_MODULE_SDK" value="true" />
+      <option name="ADD_CONTENT_ROOTS" value="true" />
+      <option name="ADD_SOURCE_ROOTS" value="true" />
+      <option name="SCRIPT_NAME" value="$PROJECT_DIR$/main.py" />
+      <option name="PARAMETERS" value="" />
+      <option name="SHOW_COMMAND_LINE" value="false" />
+      <option name="EMULATE_TERMINAL" value="false" />
+      <option name="MODULE_MODE" value="false" />
+      <option name="REDIRECT_INPUT" value="false" />
+      <option name="INPUT_FILE" value="" />
+      <method v="2" />
+    </configuration>
+    <recent_temporary>
+      <list>
+        <item itemvalue="Python.data_visualization" />
+        <item itemvalue="Python.Oreilly_Ensamble_RandomForest" />
+        <item itemvalue="Python.Oreilly_Example1" />
+        <item itemvalue="Python.Oreilly_SVM" />
+        <item itemvalue="Python.Oreilly_LogisticReg" />
+      </list>
+    </recent_temporary>
+  </component>
+  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="dfea19b1-4908-4385-95c7-1034aa4a3734" name="Changes" comment="" />
+      <created>1686551771847</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1686551771847</updated>
+    </task>
+    <servers />
+  </component>
+  <component name="XDebuggerManager">
+    <breakpoint-manager>
+      <breakpoints>
+        <line-breakpoint enabled="true" suspend="THREAD" type="python-line">
+          <url>file://$PROJECT_DIR$/RoboEnv_View.py</url>
+          <line>135</line>
+          <option name="timeStamp" value="1" />
+        </line-breakpoint>
+      </breakpoints>
+    </breakpoint-manager>
+  </component>
+</project>

Clustering.py

@@ -0,0 +1,35 @@
+import numpy as np
+from sklearn.datasets import make_blobs
+import matplotlib.pyplot as plt
+
+n_samples = 1500
+random_state = 170
+transformation = [[0.60834549, -0.63667341], [-0.40887718, 0.85253229]]
+
+X, y = make_blobs(n_samples=n_samples, random_state=random_state)
+X_aniso = np.dot(X, transformation)  # Anisotropic blobs
+X_varied, y_varied = make_blobs(
+    n_samples=n_samples, cluster_std=[1.0, 2.5, 0.5], random_state=random_state
+)  # Unequal variance
+X_filtered = np.vstack(
+    (X[y == 0][:500], X[y == 1][:100], X[y == 2][:10])
+)  # Unevenly sized blobs
+y_filtered = [0] * 500 + [1] * 100 + [2] * 10
+
+
+fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(12, 12))
+
+axs[0, 0].scatter(X[:, 0], X[:, 1], c=y)
+axs[0, 0].set_title("Mixture of Gaussian Blobs")
+
+axs[0, 1].scatter(X_aniso[:, 0], X_aniso[:, 1], c=y)
+axs[0, 1].set_title("Anisotropically Distributed Blobs")
+
+axs[1, 0].scatter(X_varied[:, 0], X_varied[:, 1], c=y_varied)
+axs[1, 0].set_title("Unequal Variance")
+
+axs[1, 1].scatter(X_filtered[:, 0], X_filtered[:, 1], c=y_filtered)
+axs[1, 1].set_title("Unevenly Sized Blobs")
+
+plt.suptitle("Ground truth clusters").set_y(0.95)
+plt.show()

DDGP_torch.py

@@ -0,0 +1,96 @@
+import gymnasium as gym
+from stable_baselines3 import PPO
+from stable_baselines3 import A2C  # Actor-Critic
+import os
+import time
+
+def iterate_models(model_no):
+    if model_no == 1:
+        models_dir = f"../models/PPO-{int(time.time())}"
+        log_dir = f"../logs/PPO-{int(time.time())}"
+
+        os.makedirs(models_dir, exist_ok=True)
+        os.makedirs(log_dir, exist_ok=True)
+
+        env = gym.make("BipedalWalker-v3")
+
+        env.reset()
+
+        model = PPO("MlpPolicy", env, verbose=1, tensorboard_log=log_dir)  # Mlp = MultilayerPerceptron
+
+        TIMESTEPS = 10_000
+        for i in range(1, 100):
+            model.learn(total_timesteps=TIMESTEPS, reset_num_timesteps=False, tb_log_name="PPO")
+            model.save(f"{models_dir}/{TIMESTEPS * i}")
+
+        env.close()
+
+    if model_no == 2:
+        models_dir = f"../models/A2C-{int(time.time())}"
+        log_dir = f"../logs/A2C-{int(time.time())}"
+
+        os.makedirs(models_dir, exist_ok=True)
+        os.makedirs(log_dir, exist_ok=True)
+
+        env = gym.make("BipedalWalker-v3")
+
+        env.reset()
+
+        model = A2C("MlpPolicy", env, verbose=1, tensorboard_log=log_dir)  # Mlp = MultilayerPerceptron
+
+        TIMESTEPS = 10000
+        for i in range(1, 30):
+            model.learn(total_timesteps=TIMESTEPS, reset_num_timesteps=False, tb_log_name="A2C")
+            env.render("human")
+            model.save(f"{models_dir}/{TIMESTEPS * i}")
+
+        env.close()
+
+
+"""import gymnasium as gym
+
+from stable_baselines3 import DQN
+from stable_baselines3 import PPO
+
+from stable_baselines3.common.evaluation import evaluate_policy
+
+
+# Create environment
+env = gym.make("LunarLander-v2", render_mode="rgb_array")
+
+# Instantiate the agent
+model = PPO("MlpPolicy", env, verbose=1)
+# Train the agent and display a progress bar
+model.learn(total_timesteps=int(2e5), progress_bar=True)
+# Save the agent
+model.save("ppo_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 = PPO.load("ppo_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")"""
+
+
+def teach(model_no):
+    for i in range(1, model_no + 1):
+        iterate_models(i)
+        print(f"Teaching of {model_no} is done.")
+
+
+teach(2)

Gradio_Test.py

@@ -0,0 +1,81 @@
+#Libs
+"""
+We can import libraries when they necessary in if clauses.
+"""
+import numpy as np
+import pandas as pd
+from matplotlib import pyplot as plt
+import gradio as gr
+import sklearn.datasets
+from sklearn.metrics import confusion_matrix, mean_squared_error, roc_auc_score, precision_recall_curve
+from sklearn.metrics import roc_curve, accuracy_score, f1_score, precision_score, recall_score
+import os.path
+from sklearn.model_selection import train_test_split, cross_val_score, StratifiedShuffleSplit
+from sklearn.model_selection import GridSearchCV, RandomizedSearchCV, StratifiedKFold, cross_val_predict
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.impute import SimpleImputer
+from sklearn.preprocessing import OneHotEncoder
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import StandardScaler
+from sklearn.compose import ColumnTransformer
+from sklearn.linear_model import LinearRegression, SGDClassifier
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.tree import DecisionTreeRegressor
+from sklearn.multiclass import OneVsOneClassifier
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.datasets import make_moons
+from sklearn.svm import SVC
+
+#Gradio Function
+def polynomial_svm(file,n_sample,noise,degree,C,coef0,head_value):
+        df = pd.read_csv(file.name)
+        X, y = make_moons(n_samples=n_sample, noise=noise, random_state=44)
+        polynomial_svm_clf = Pipeline([
+            ("scaler", StandardScaler()),
+            ("svm_clf", SVC(kernel="poly", degree=degree, C=C, coef0=coef0,probability=True)),
+        ])
+        polynomial_svm_clf.fit(X, y)
+        fig = plt.figure()
+        # Create a meshgrid of points covering the input space
+        x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
+        y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
+        xx, yy = np.meshgrid(np.linspace(x_min, x_max, 200),
+                             np.linspace(y_min, y_max, 200))
+        # Generate predictions for each point in the meshgrid
+        Z = polynomial_svm_clf.predict(np.c_[xx.ravel(), yy.ravel()])
+        Z = Z.reshape(xx.shape)
+        # Create a color map
+        cmap = plt.cm.Pastel1
+        # Plot the decision boundary and the data points
+        plt.contourf(xx, yy, Z, alpha=0.8, cmap=cmap)
+        plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='k', cmap=cmap)
+        plt.xlabel('Feature 1')
+        plt.ylabel('Feature 2')
+        plt.title('Polynomial SVM Classifier Decision Boundary')
+        plt.xlim(xx.min(), xx.max())
+        plt.ylim(yy.min(), yy.max())
+        plt.xticks(())
+        plt.yticks(())
+
+        return fig,df.head(head_value)
+
+
+inputs = [
+    gr.File(label='Import a CSV File',file_count='single',file_types=['csv']),
+    gr.Slider(100,3000,1500,label='Number of Samples'),
+    gr.Slider(0,1,0.15,label='Noise'),
+    gr.Slider(1,5,3,step=1,label='Degree'),
+    gr.Slider(1,10,5,step=1,label='C'),
+    gr.Slider(1,10,3,step=1,label='coefficient 0'),
+    gr.Slider(1,20,10,step=1,label='Head'),
+]
+outputs = [gr.Plot(label='Polynomial SVM Classifier'),
+           gr.Textbox(label='Head')]
+
+demo = gr.Interface(
+    fn = polynomial_svm,
+    inputs=inputs,
+    outputs=outputs,
+)
+if __name__ == "__main__":
+    demo.launch(share=True)

LinearRegressionExample.py

@@ -0,0 +1,224 @@
+# Linear Regression Example
+"""# Code source: Jaques Grobler
+# License: BSD 3 clause
+
+import matplotlib.pyplot as plt
+import numpy as np
+from sklearn import datasets, linear_model
+from sklearn.metrics import mean_squared_error, r2_score
+import pandas as pd
+# Load the diabetes dataset
+diabetes_X, diabetes_y = datasets.load_diabetes(return_X_y=True)
+print(f"DATASET\n{datasets.load_diabetes()}")
+
+# Use only one feature
+diabetes_X = diabetes_X[:, np.newaxis, 2]
+
+# Split the data into training/testing sets
+diabetes_X_train = diabetes_X[:-20]
+diabetes_X_test = diabetes_X[-20:]
+
+# Split the targets into training/testing sets
+diabetes_y_train = diabetes_y[:-20]
+diabetes_y_test = diabetes_y[-20:]
+
+# Create linear regression object
+regr = linear_model.LinearRegression()
+
+# Train the model using the training sets
+regr.fit(diabetes_X_train, diabetes_y_train)
+
+# Make predictions using the testing set
+diabetes_y_pred = regr.predict(diabetes_X_test)
+
+# The coefficients
+print("Coefficients: \n", regr.coef_)
+# The mean squared error
+print("Mean squared error: %.2f" % mean_squared_error(diabetes_y_test, diabetes_y_pred))
+# The coefficient of determination: 1 is perfect prediction
+print("Coefficient of determination: %.2f" % r2_score(diabetes_y_test, diabetes_y_pred))
+
+# Plot outputs
+plt.scatter(diabetes_X_test, diabetes_y_test, color="black")
+plt.plot(diabetes_X_test, diabetes_y_pred, color="blue", linewidth=3)
+
+plt.xticks(())
+plt.yticks(())
+
+plt.show()"""
+
+import numpy as np
+import pybullet as p
+from scipy.optimize import minimize
+
+p.connect(p.GUI)
+
+
+class OPAX:
+    def __init__(self, dynamics_model, observation_model):
+        self.dynamics_model = dynamics_model
+        self.observation_model = observation_model
+
+    def optimize(self, initial_state):
+        def objective(x):
+            predicted_state = self.dynamics_model.predict(x)
+            info_gain = self.observation_model.info_gain(initial_state, predicted_state)
+            return -info_gain
+
+        x0 = np.zeros(self.dynamics_model.input_dim)
+        result = minimize(objective, x0)
+        return result.x
+
+
+class RobotDynamicsModel:
+    def __init__(self, robot):
+        self.robot = robot
+        self.input_dim = 6  # 6 DOF
+
+    def predict(self, control_inputs):
+        # Apply the control inputs to the robot and get the new state
+        self.robot.apply_control(control_inputs)
+        new_state = self.robot.get_state()
+        return new_state
+
+
+class RobotObservationModel:
+    def __init__(self, robot, box_id, target_point):
+        self.robot = robot
+        self.box_id = box_id
+        self.target_point = target_point
+
+    def info_gain(self, initial_state, predicted_state):
+        # The information gain could be the reduction in distance to the target point
+        initial_distance = np.linalg.norm(self.target_point - initial_state[:3])
+        predicted_distance = np.linalg.norm(self.target_point - predicted_state[:3])
+        info_gain = initial_distance - predicted_distance
+
+        # Check for collision between the robot's end effector and the box
+        collision_points = self.robot.check_collision(self.box_id)
+        if collision_points:
+            # If there is a collision, increase the information gain (reward)
+            info_gain += 1000
+
+        return info_gain
+
+
+class MyRobot:
+    def __init__(self):
+        # Load the robot model into PyBullet
+        self.robot_id = p.loadURDF("C:/IT/Assembly/urdf/Assembly.urdf")
+        self.end_effector_index = 6  # Assuming the last link is the end effector
+
+
+    def check_collision(self, other_body_id):
+
+        return p.getClosestPoints(self.robot_id, other_body_id, distance=0, linkIndexA=self.end_effector_index)
+    def set_state(self, state):
+        # Set the position and orientation of the robot's base
+        position = state[:3]
+        orientation = p.getQuaternionFromEuler(state[3:])
+        p.resetBasePositionAndOrientation(self.robot_id, position, orientation)
+
+    def apply_control(self, control_inputs):
+        # Apply control inputs to the robot
+        # Here, we assume that control_inputs is an array of joint torques
+        for i in range(6):  # 6 DOF
+            p.setJointMotorControl2(self.robot_id, i, p.TORQUE_CONTROL, force=control_inputs[i])
+
+        # Step the simulation forward
+        p.stepSimulation()
+
+    def get_state(self):
+        # Get the current state of the robot
+        # Here, we'll just get the position and orientation of the robot's base
+        position, orientation = p.getBasePositionAndOrientation(self.robot_id)
+
+        # Convert the orientation from a quaternion to Euler angles for simplicity
+        orientation = p.getEulerFromQuaternion(orientation)
+
+        # Concatenate position and orientation into a single array
+        state = np.concatenate([position, orientation])
+
+        return state
+
+
+# Initialize PyBullet and the robot
+p.connect(p.DIRECT)
+robot = MyRobot()  # Replace with your robot class
+
+# Define the target point in 3D space
+target_point = np.array([1, 1, 1])
+# Load a box at the target point
+box_id = p.loadURDF("C:/IT/Assembly/urdf/target.urdf", target_point)
+# Create the dynamics model and observation model
+dynamics_model = RobotDynamicsModel(robot)
+target_point = np.array([1,2,3])
+observation_model = RobotObservationModel(robot, box_id,target_point)
+
+# Create an instance of OPAX
+opax = OPAX(dynamics_model, observation_model)
+
+# Use OPAX to find the optimal control inputs
+initial_state = robot.get_state()
+optimal_control_inputs = opax.optimize(initial_state)
+import time
+
+# ... (rest of your code)
+
+# Number of episodes for training
+NUM_EPISODES = 10_000
+
+# Range of possible initial states
+initial_state_range = np.array([[0, 0, 0, -np.pi, -np.pi, -np.pi],
+                                [1, 1, 1, np.pi, np.pi, np.pi]])
+rewards = []
+import matplotlib.pyplot as plt
+for episode in range(NUM_EPISODES):
+    # Choose a random initial state within the specified range
+    initial_state = np.random.uniform(initial_state_range[0], initial_state_range[1])
+
+    # Set the robot's state to the initial state
+    robot.set_state(initial_state)
+
+    # Use OPAX to find the optimal control inputs
+    optimal_control_inputs = opax.optimize(initial_state)
+
+    # Apply the control inputs to the robot
+    robot.apply_control(optimal_control_inputs)
+
+    # Step the simulation forward
+    p.stepSimulation()
+
+    # Only visualize every 1000th episode
+    if episode % 1000 == 0:
+        for _ in range(1000):
+            p.stepSimulation()
+            time.sleep(0.01)
+            # Reset the state of the robot
+        robot.set_state(initial_state)
+
+            # Optimize the control inputs
+        optimal_control_inputs = opax.optimize(initial_state)
+
+            # Apply the optimal control inputs to the robot
+        robot.apply_control(optimal_control_inputs)
+
+            # Get the new state of the robot
+        new_state = robot.get_state()
+        reward = observation_model.info_gain(initial_state,new_state)
+        rewards.append(reward)
+
+            # Check for collision between the robot's end effector and the box
+        collision_points = robot.check_collision(box_id)
+        if collision_points:
+            print(f"Success in episode {episode} {reward}!")
+
+        else:
+            print(f"Failure in episode {episode} {reward}.")
+
+plt.plot(rewards)
+plt.xlabel('Episode')
+plt.ylabel('Reward')
+plt.title('Learning Curve')
+plt.show()
+

LogisticRegressionExample.py

@@ -0,0 +1,14 @@
+import numpy as np
+#X represents the size of a tumor in centimeters.
+X = np.array([3.78, 2.44, 2.09, 0.14, 1.72, 1.65, 4.92, 4.37, 4.96, 4.52, 3.69, 5.88]).reshape(-1,1)
+
+#Note: X has to be reshaped into a column from a row for the LogisticRegression() function to work.
+#y represents whether or not the tumor is cancerous (0 for "No", 1 for "Yes").
+y = np.array([0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1])
+from sklearn.linear_model import LogisticRegression
+
+logr = LogisticRegression()
+logr.fit(X,y)
+#predict if tumor is cancerous where the size is 3.46mm:
+predicted = logr.predict(np.array([3.46]).reshape(-1,1))
+print(predicted)

MyEnv.py

@@ -0,0 +1,241 @@
+import gym
+import numpy as np
+import os
+import tensorflow as tf
+import keras
+from keras.layers import Dense
+from keras.optimizers import Adam
+from keras.metrics import MSE
+
+class ReplayBuffer:
+    def __init__(self, max_size, input_shape, n_actions):
+        self.mem_size = max_size
+        self.mem_cntr = 0
+        self.state_memory = np.zeros((self.mem_size, *input_shape))
+        self.new_state_memory = np.zeros((self.mem_size, *input_shape))
+        self.action_memory = np.zeros((self.mem_size, n_actions))
+        self.reward_memory = np.zeros(self.mem_size)
+        self.terminal_memory = np.zeros(self.mem_size, dtype=np.bool)
+
+    def store_transition(self, state, action, reward, new_state, done):
+        index = self.mem_cntr % self.mem_size
+
+        self.state_memory[index] = state
+        self.new_state_memory[index] = new_state
+        self.action_memory[index] = action
+        self.reward_memory[index] = reward
+        self.terminal_memory[index] = done
+
+    def sample_buffer(self, batch_size):
+        max_mem = min(self.mem_cntr, self.mem_size)
+        batch = np.random.choice(max_mem, batch_size, replace=False)
+
+        states = self.state_memory[batch]
+        states_ = self.new_state_memory[batch]
+        actions = self.action_memory[batch]
+        rewards = self.reward_memory[batch]
+        dones = self.terminal_memory[batch]
+
+        return states, actions, rewards, states_, dones
+
+
+class CriticNetwork(keras.Model):
+    def __init__(self, n_actions, fc1_dims=512, fc2_dims=512, name='critic', chkpt_dir='tmp/ddpg'):
+        super(CriticNetwork, self).__init__()
+        self.fc1_dims = fc1_dims
+        self.fc2_dims = fc2_dims
+        self.n_actions = n_actions
+
+        self.model_name = name
+        self.checkpoint_dir = chkpt_dir
+        self.checkpoint_file = os.path.join(self.checkpoint_dir, self.model_name + '_ddpg.h5')
+
+        self.fc1 = Dense(self.fc1_dims, activation='relu')
+        self.fc2 = Dense(self.fc2_dims, activation='relu')
+        self.q = Dense(1, activation=None)
+
+    def call(self, state, action):
+        action_value = self.fc1(tf.concat([state, action], axis=1))
+        action_value = self.fc1(action_value)
+
+        q = self.q(action_value)
+
+        return q
+
+
+class ActorNetwork(keras.Model):
+    def __init__(self, fc1_dims=512, fc2_dims=512, n_actions=2, name='actor', chkpt_dir='tmp/ddpg'):
+        super(ActorNetwork, self).__init__()
+        self.fc1_dims = fc1_dims
+        self.fc2_dims = fc2_dims
+        self.n_actions = n_actions
+
+        self.model_name = name
+        self.checkpoint_dir = chkpt_dir
+        self.checkpoint_file = os.path.join(self.checkpoint_dir, self.model_name + '_ddpg.h5')
+
+        self.fc1 = Dense(self.fc1_dims, activation='relu')
+        self.fc2 = Dense(self.fc2_dims, activation='relu')
+        self.mu = Dense(self.n_actions, activation='tanh')
+
+    def call(self, state):
+        prob = self.fc1(state)
+        prob = self.fc2(prob)
+
+        # if action bounds not +/- 1, can multiply here
+        mu = self.mu(prob)
+        return mu
+
+
+class Agent:
+    def __init__(self, input_dims, alpha=0.001, beta=0.002, env=None,
+                 gamma=0.99, n_actions=2, max_size=1_000_000, tau=0.005,
+                 fc1=400, fc2=300, batch_size=64, noise=0.1):
+
+        self.gamma = gamma
+        self.tau = tau
+        self.memory = ReplayBuffer(max_size, input_dims, n_actions)
+        self.batch_size = batch_size
+        self.n_actions = n_actions
+        self.noise = noise
+        self.max_action = env.action_space.high[0]
+        self.min_action = env.action_space.low[0]
+
+        self.actor = ActorNetwork(n_actions=n_actions, name='actor')
+        self.critic = CriticNetwork(n_actions=n_actions, name='critic')
+        self.target_actor = ActorNetwork(n_actions=n_actions, name='target_actor')
+        self.target_critic = CriticNetwork(n_actions=n_actions, name='target_critic')
+
+        self.actor.compile(optimizer=Adam(learning_rate=alpha))
+        self.critic.compile(optimizer=Adam(learning_rate=beta))
+        self.target_actor.compile(optimizer=Adam(learning_rate=alpha))
+        self.target_critic.compile(optimizer=Adam(learning_rate=beta))
+
+        self.update_network_parameters(tau=1)
+
+    def update_network_parameters(self, tau=None):
+        if tau is None:
+            tau = self.tau
+
+        weights = []
+        targets = self.target_actor.weights
+        for i, weight in enumerate(self.actor.weights):
+            weights.append(weight * tau + targets[i] * (1 - tau))
+        self.target_actor.set_weights(weights)
+
+        weights = []
+        targets = self.target_critic.weights
+        for i, weight in enumerate(self.critic.weights):
+            weights.append(weight * tau + targets[i] * (1 - tau))
+        self.target_critic.set_weights(weights)
+
+    def remember(self, state, action, reward, new_state, done):
+        self.memory.store_transition(state, action, reward, new_state, done)
+
+    def save_models(self):
+        print('...Saving Models...')
+        self.actor.save_weights(self.actor.checkpoint_file)
+        self.critic.save_weights(self.critic.checkpoint_file)
+        self.target_actor.save_weights(self.target_actor.checkpoint_file)
+        self.target_critic.save_weights(self.target_critic.checkpoint_file)
+
+    def load_models(self):
+        print('...Loading Models...')
+        self.actor.load_weights(self.actor.checkpoint_file)
+        self.critic.load_weights(self.critic.checkpoint_file)
+        self.target_actor.load_weights(self.target_actor.checkpoint_file)
+        self.target_critic.load_weights(self.target_critic.checkpoint_file)
+
+    def choose_action(self, observation, evaluate=False):
+        state = tf.convert_to_tensor([observation], dtype=tf.float32)
+        actions = self.actor(state)
+
+        if not evaluate:
+            actions += tf.random.normal(shape=[self.n_actions],
+                                        mean=0.0, stddev=self.noise)
+
+        actions = tf.clip_by_value(actions, self.min_action, self.max_action)
+
+        return actions[0]
+
+    def learn(self):
+        if self.memory.mem_cntr < self.batch_size:
+            return
+
+        state, action, reward, new_state, done = self.memory.sample_buffer(self.batch_size)
+
+        states = tf.convert_to_tensor(state, dtype=tf.float32)
+        states_ = tf.convert_to_tensor(new_state, dtype=tf.float32)
+        actions = tf.convert_to_tensor(action, dtype=tf.float32)
+        rewards = tf.convert_to_tensor(reward, dtype=tf.float32)
+
+        with tf.GradientTape() as tape:
+            target_actions = self.target_actor(states_)
+            critic_value_ = tf.squeeze(self.target_critic(states_, target_actions), 1)
+            critic_value = tf.squeeze(self.critic(states, actions), 1)
+            target = reward + self.gamma * critic_value_ * (1 - done)
+            critic_lose = MSE(target, critic_value)
+            critic_network_gradient = tape.gradient(critic_lose, self.critic.trainable_variables)
+            self.critic.optimizer.apply_gradients(zip(critic_network_gradient, self.critic.trainable_variables))
+
+            with tf.GradientTape() as tape:
+                new_policy_actions = self.actor(states)
+                actor_loss = -self.critic(states, new_policy_actions)  # Gradient descent rather than gradient ascent
+                actor_loss = tf.math.reduce_mean(actor_loss)
+
+            actor_network_gradient = tape.gradient(actor_loss, self.actor.trainable_variables)
+            self.actor.optimizer.apply_gradients(zip(actor_network_gradient, self.actor.trainable_variables))
+
+            self.update_network_parameters()
+
+
+if __name__ == '__main__':
+    env = gym.make('Pendulum-v1')
+    agent = Agent(input_dims=env.observation_space.shape, env=env,
+                  n_actions=env.action_space.shape[0])
+
+    n_games = 500
+
+    figure_file = 'plots/pendulum.png'
+
+    best_score = env.reward_range[0]
+    score_history = []
+
+    load_checkpoint = False
+
+    if load_checkpoint:
+        n_steps = 0
+        while n_steps <= agent.batch_size:
+            observation = env.reset()
+            action = env.action_space.sample()
+            observation_, reward, done, info = env.step(action)
+            agent.remember(observation, action, reward, observation_, done)
+            n_steps += 1
+        agent.learn()
+        agent.load_models()
+        evaluate = True
+    else:
+        evaluate = False
+
+    for i in range(n_games):
+        observation = env.reset()
+        done = False
+        score = 0
+        while not done:
+            action = agent.choose_action(observation, evaluate)
+            observation_, reward, done, info = env.step(action)
+            score += reward
+            agent.remember(observation, action, reward, observation_, done)
+            if not load_checkpoint:
+                agent.learn()
+            observation = observation_
+
+        score_history.append(score)
+        avg_score = np.mean(score_history[-100:])
+
+        if avg_score > best_score:
+            best_score = avg_score
+            if not load_checkpoint:
+                agent.save_models()
+
+        print('episode', i, 'score %.1f' % score, 'avg score %.1f' % avg_score)

Oreilly_DecTree.py

@@ -0,0 +1,37 @@
+from sklearn.datasets import load_iris
+from sklearn.tree import DecisionTreeClassifier
+
+iris = load_iris()
+X = iris.data[:,2:] #petal length and width
+y = iris.target
+tree_clf = DecisionTreeClassifier(max_depth=2)
+tree_clf.fit(X,y)
+
+
+from sklearn.tree import export_graphviz
+export_graphviz(
+ tree_clf,
+ out_file="iris_tree.dot",
+ feature_names=iris.feature_names[2:],
+ class_names=iris.target_names,
+ rounded=True,
+ filled=True
+ )
+"""
+cmd -> C:\IT\PythonProject\OffsetCorrection>dot -Tpng iris_tree.dot -o iris_tree.png
+"""
+
+"""
+Model Interpretation: White Box Versus Black Box
+Decision Trees are fairly intuitive and their decisions are easy to inter‐
+pret. Such models are often called white box models. In contrast, as we will see, Ran‐
+dom Forests or neural networks are generally considered black box models. They
+make great predictions, and you can easily check the calculations that they performed
+to make these predictions; nevertheless, it is usually hard to explain in simple terms
+why the predictions were made. For example, if a neural network says that a particu‐
+lar person appears on a picture, it is hard to know what actually contributed to this
+prediction: did the model recognize that person’s eyes? Her mouth? Her nose? Her
+shoes? Or even the couch that she was sitting on? Conversely, Decision Trees provide
+nice and simple classification rules that can even be applied manually if need be (e.g.,
+for flower classification).
+"""

Oreilly_Ensamble_RandomForest.py

@@ -0,0 +1,74 @@
+import matplotlib.pyplot as plt
+from sklearn.ensemble import RandomForestClassifier,VotingClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.svm import SVC
+
+log_clf = LogisticRegression()
+rnd_clf = RandomForestClassifier()
+svm_clf = SVC(probability=True)
+
+voting_clf = VotingClassifier(
+    estimators=[('lr',log_clf),('rf',rnd_clf),('svc',svm_clf)],
+    voting='soft'
+)
+
+import numpy as np
+from sklearn.datasets import make_moons
+from sklearn.model_selection import train_test_split
+import pandas as pd
+
+moons = make_moons(n_samples=2000,noise=0.30,random_state=15)
+print(moons[0][:,-2].shape)
+df = pd.DataFrame()
+df['X_1'] = moons[0][:,0]
+df['X_2'] = moons[0][:,1]
+df['target'] = moons[1]
+print(df)
+
+X = df.iloc[:,0:2]
+print(X)
+y = df.iloc[:,-1]
+
+X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.33,random_state=42)
+print('Y_train\n',y_train)
+voting_clf.fit(X_train, y_train)
+
+from sklearn.metrics import accuracy_score
+
+for clf in (log_clf,rnd_clf,svm_clf,voting_clf):
+    clf.fit(X_train,y_train)
+    y_pred = clf.predict(X_test)
+    print(clf.__class__.__name__,accuracy_score(y_test,y_pred))
+
+"""
+If all classifiers are able to estimate class probabilities (i.e., they have a pre
+dict_proba() method), then you can tell Scikit-Learn to predict the class with the
+highest class probability, averaged over all the individual classifiers. This is called so
+voting. It often achieves higher performance than hard voting because it gives more
+weight to highly confident votes. All you need to do is replace voting="hard" with
+voting="soft" and ensure that all classifiers can estimate class probabilities. This is
+not the case of the SVC class by default, so you need to set its probability hyperpara‐
+meter to True (this will make the SVC class use cross-validation to estimate class prob‐
+abilities, slowing down training, and it will add a predict_proba() method)
+"""
+
+from sklearn.ensemble import BaggingClassifier
+from sklearn.tree import DecisionTreeClassifier
+
+bag_clf = BaggingClassifier(DecisionTreeClassifier(), n_estimators=500,n_jobs=-1,max_samples=100,bootstrap=True)
+bag_clf.fit(X_train,y_train)
+y_pred = bag_clf.predict(X_test)
+
+
+print(bag_clf.score(X_test,y_pred))
+
+
+
+
+
+x_min,x_max = X.iloc[:,0].min() - 0.5, X.iloc[:,0].max() + 0.5
+y_min,y_max = X.iloc[:,1].min() - 0.5, X.iloc[:,1].max() + 0.5
+print(x_min,x_max)
+print(y_min,y_max)
+cm_bright = plt.cm.RdBu
+plt.scatter(X_train.iloc[:,0],X_train.iloc[:,1],c=y_train,cmap=cm_bright,edgecolors='k')

Oreilly_Example1.py

@@ -0,0 +1,376 @@
+# to extract files from rar and save.
+"""import os
+import tarfile
+from six.moves import urllib
+
+DOWNLOAD_ROOT = "https://raw.githubusercontent.com/ageron/handson-ml2/master/"
+HOUSING_PATH = os.path.join("datasets", "housing")
+
+HOUSING_URL = DOWNLOAD_ROOT + "datasets/housing/housing.tgz"
+
+
+def fetch_housing_data(housing_url=HOUSING_URL, housing_path=HOUSING_PATH):
+    if not os.path.isdir(housing_path):
+        os.makedirs(housing_path)
+
+    tgz_path = os.path.join(housing_path, "housing.tgz")
+    urllib.request.urlretrieve(housing_url, tgz_path)
+    housing_tgz = tarfile.open(tgz_path)
+    housing_tgz.extractall(path=housing_path)
+    housing_tgz.close()
+
+
+fetch_housing_data()
+"""
+import os.path
+
+import matplotlib.pyplot as plt
+import pandas as pd
+
+HOUSING_PATH = "datasets/housing"
+
+pd.set_option("display.max_columns",15) #to set max column value.
+pd.set_option("display.max_rows",15) #to set max row value.
+pd.set_option("display.width",1200) #to set width.
+
+#for more info about set_option -> https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.set_option.html
+def load_housing_data(housing_path=HOUSING_PATH):
+    csv_path = os.path.join(housing_path, "housing.csv")
+    return pd.read_csv(csv_path)
+
+
+housing_data = load_housing_data("datasets/housing")
+print(housing_data.head(15))
+print(housing_data.columns)
+print(housing_data.info)
+print(housing_data.count())
+print(housing_data["total_bedrooms"].count()) #20433 rows, means there are missing values to be handled.
+print(housing_data.dtypes)
+print(housing_data["total_bedrooms"].dtype)
+print(housing_data["ocean_proximity"].dtype) # ocean_proximity is not float64.
+
+print(housing_data["ocean_proximity"].value_counts())
+print(type(housing_data["ocean_proximity"].describe()))
+
+print(housing_data.describe()) #to get count, mean, standard deviation, min, 25%,50%,75%,max.
+#histogram of the data
+
+housing_data.hist()
+
+plt.show()
+
+housing_data["ocean_proximity"].hist()
+plt.show()
+
+import matplotlib.pyplot as plt
+
+housing_data.hist(bins=100,figsize=(10,12),grid=False) #bins is the value of X being shown on plot.
+"""
+When a feature has a bell-shaped normal
+distribution (also called a Gaussian distribution), which is very common, the “68-95-99.7” rule applies: about
+68% of the values fall within 1σ of the mean, 95% within 2σ, and 99.7% within 3σ.
+"""
+plt.show()
+
+import numpy as np
+
+def split_train_test(data,test_ratio):
+    shuffled_indices = np.random.permutation(len(data)) #shuffle indices.
+    test_set_size = int(len(data)*test_ratio)
+    test_indices = shuffled_indices[:test_set_size]
+    train_indices = shuffled_indices[test_set_size:]
+    return data.iloc[train_indices], data.iloc[test_indices]
+
+
+train_set, test_set = split_train_test(housing_data,0.2)
+print(len(train_set))
+print(len(test_set))
+
+from sklearn.model_selection import train_test_split
+
+train_set, test_set = train_test_split(housing_data,test_size=0.33,random_state=42)
+
+housing_data["income_cat"] = pd.cut(housing_data["median_income"], bins=[0.,1.5,3.0,4.5,6.,np.inf],labels=[1,2,3,4,5])
+housing_data["income_cat"].hist()
+plt.show()
+
+
+from sklearn.model_selection import StratifiedShuffleSplit
+split = StratifiedShuffleSplit(n_splits=1,test_size=0.33,random_state=42)
+
+for train_index, test_index in split.split(housing_data, housing_data["income_cat"]):
+    strat_train_set = housing_data.loc[train_index]
+    strat_test_set = housing_data.loc[test_index]
+
+
+print(strat_test_set["income_cat"].value_counts())
+len(strat_test_set)
+
+for set_ in (strat_train_set,strat_test_set):
+    set_.drop("income_cat",axis=1,inplace=True)
+
+housing = strat_train_set.copy()
+
+housing.plot(kind="scatter",x="longitude",y="latitude",alpha=0.1)
+print(housing)
+plt.show()
+housing.plot(kind="scatter",x="longitude",y="latitude",alpha=0.4,s=housing["population"]/100,label="population",
+             figsize=(10,7),c="median_house_value",cmap=plt.get_cmap("jet"),colorbar=True,)
+plt.legend()
+plt.show()
+
+"""Since the dataset is not too large, you can easily compute the standard correlation
+cooefficient (also called Pearson’s r) between every pair of attributes using the corr()
+method:"""
+housing = housing.drop(["ocean_proximity"],axis=1) #to drop multiple columns housing.drop(["A","B"...],axis=1)
+corr_matrix = housing.corr()
+mhv_corr_m = corr_matrix["median_house_value"].sort_values(ascending=False)
+
+print(mhv_corr_m)
+"""
+it ranges between from -1 to 1.
+if correlation coefficient is close to 1, it means that there is a strong positive correlation.
+coefficients close to zero mean that there is no linear correlation.
+The correlation coefficient only measures linear correlations.
+
+"""
+from pandas.plotting import scatter_matrix
+
+attributes = ["median_house_value","median_income","total_rooms","housing_median_age"]
+scatter_matrix(housing[attributes],figsize=(12,8))
+#plt.show()
+
+housing["rooms_per_household"] = housing["total_rooms"]/housing["households"]
+housing["bedrooms_per_room"] = housing["total_bedrooms"]/housing["total_rooms"]
+housing["population_per_household"] = housing["population"]/housing["households"]
+
+corr_matrix = housing.corr()
+print(corr_matrix["median_house_value"].sort_values(ascending=False))
+
+#DATA CLEANING
+housing = strat_train_set.drop("median_house_value",axis=1)
+housing_labels = strat_train_set["median_house_value"].copy()
+
+"""
+#option 1
+housing.dropna(subset=["total_bedrooms"])
+
+#option 2
+housing.drop("total_bedrooms",axis=1)
+
+#option 3
+median = housing["total_bedrooms"].median()
+housing["total_bedrooms"].fillna(median,inplace=True)
+"""
+
+from sklearn.impute import SimpleImputer
+imputer = SimpleImputer(strategy="median") # only can be applied to numerical attributes.
+
+housing_num = housing.drop("ocean_proximity",axis=1)
+
+imputer.fit(housing_num)
+
+print(imputer.statistics_) #medians of each numerical attribute.
+
+X = imputer.transform(housing_num)
+housing_transform = pd.DataFrame(X,columns=housing_num.columns)
+
+#Handling Text and Categorical Attributes
+
+housing_cat = housing[["ocean_proximity"]]
+print(housing_cat.head(10))
+
+from sklearn.preprocessing import OrdinalEncoder
+ordinal_encoder = OrdinalEncoder()
+
+housing_cat_encoded = ordinal_encoder.fit_transform(housing_cat)
+print(housing_cat_encoded[:10])
+print(ordinal_encoder.categories_)
+
+"""
+One issue with this representation is that ML algorithms will assume that two nearby
+values are more similar than two distant values. This may be fine in some cases (e.g.,
+for ordered categories such as “bad”, “average”, “good”, “excellent”), but it is obviously
+not the case for the ocean_proximity column (for example, categories 0 and 4 are
+clearly more similar than categories 0 and 1). To fix this issue, a common solution is
+to create one binary attribute per category: one attribute equal to 1 when the category
+is “<1H OCEAN” (and 0 otherwise), another attribute equal to 1 when the category is
+“INLAND” (and 0 otherwise), and so on. This is called one-hot encoding, because
+only one attribute will be equal to 1 (hot), while the others will be 0 (cold). The new
+attributes are sometimes called dummy attributes. Scikit-Learn provides a OneHotEn
+coder class to convert categorical values into one-hot vectors.
+"""
+from sklearn.preprocessing import OneHotEncoder
+cat_encoder = OneHotEncoder()
+housing_cat_1hot = cat_encoder.fit_transform(housing_cat)
+print(housing_cat_1hot)
+
+"""
+If a categorical attribute has a large number of possible categories
+(e.g., country code, profession, species, etc.), then one-hot encod‐
+ing will result in a large number of input features. This may slow
+down training and degrade performance. If this happens, you may
+want to replace the categorical input with useful numerical features
+related to the categories: for example, you could replace the
+ocean_proximity feature with the distance to the ocean (similarly,
+a country code could be replaced with the country’s population and
+GDP per capita). Alternatively, you could replace each category
+with a learnable low dimensional vector called an embedding.
+"""
+#Check page 98 l8r.
+
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import StandardScaler
+
+num_pipeline = Pipeline([
+    ('imputer', SimpleImputer(strategy='median')),
+    ('std_scaler',StandardScaler())
+])
+
+housing_num_tr = num_pipeline.fit_transform(housing_num)
+
+from sklearn.compose import ColumnTransformer
+
+num_attribs = list(housing_num) #Numerical Attributes
+cat_attribs = ["ocean_proximity"] #Categorical Attributes
+
+full_pipeline = ColumnTransformer([
+    ("num",num_pipeline,num_attribs),
+    ("cat",OneHotEncoder(),cat_attribs)
+])
+"""The Pipeline constructor takes a list of name/estimator pairs defining a sequence of
+steps. All but the last estimator must be transformers (i.e., they must have a
+fit_transform() method)."""
+housing_prepared = full_pipeline.fit_transform(housing)
+
+"""
+OneHotEncoder returns a sparse matrix, while the num_pipeline returns
+a dense matrix. When there is such a mix of sparse and dense matrices, the Colum
+nTransformer estimates the density of the final matrix (i.e., the ratio of non-zero
+cells), and it returns a sparse matrix if the density is lower than a given threshold (by
+default, sparse_threshold=0.3). In this example, it returns a dense matrix.
+"""
+
+from sklearn.linear_model import LinearRegression
+
+lin_reg = LinearRegression()
+lin_reg.fit(housing_prepared,housing_labels)
+
+some_data = housing.iloc[:5]
+some_labels = housing_labels.iloc[:5]
+some_data_prepared = full_pipeline.transform(some_data)
+print("Predictions:", lin_reg.predict(some_data_prepared))
+print("Labels:", list(some_labels))
+
+from sklearn.metrics import mean_squared_error
+housing_predictions = lin_reg.predict(housing_prepared)
+lin_mse = mean_squared_error(housing_labels, housing_predictions)
+lin_rmse = np.sqrt(lin_mse)
+print(lin_rmse)
+
+#DecisionTreeRegressor
+
+from sklearn.tree import DecisionTreeRegressor
+
+tree_reg = DecisionTreeRegressor()
+tree_reg.fit(housing_prepared,housing_labels)
+
+housing_predictions = tree_reg.predict(housing_prepared)
+tree_mse = mean_squared_error(housing_labels, housing_predictions)
+tree_rmse = np.sqrt(tree_mse)
+print(tree_rmse)
+"""
+use Scikit-Learn’s K-fold cross-validation feature. The follow‐
+ing code randomly splits the training set into 10 distinct subsets called `folds`, then it
+trains and evaluates the Decision Tree model 10 times, picking a different fold for
+evaluation every time and training on the other 9 folds. The result is an array con‐
+taining the 10 evaluation scores:
+"""
+from sklearn.model_selection import cross_val_score
+scores = cross_val_score(tree_reg, housing_prepared, housing_labels, scoring="neg_mean_squared_error", cv=10)
+tree_rmse_scores = np.sqrt(-scores)
+print("10 evalution scores:", tree_rmse_scores)
+
+"""
+Cross-validation features expect a utility function
+(greater is better) rather than a cost function (lower is better), so
+the scoring function is actually the opposite of the MSE (i.e., a neg‐
+ative value), which is why the preceding code computes -scores
+before calculating the square root.
+"""
+def display_scores(scores):
+    print("Scores:", scores)
+    print("Mean:", scores.mean())
+    print("Standard deviation:", scores.std())
+display_scores(tree_rmse_scores)
+
+
+lin_scores = cross_val_score(lin_reg, housing_prepared, housing_labels, scoring="neg_mean_squared_error", cv=10)
+lin_rmse_scores = np.sqrt(-lin_scores)
+display_scores(lin_rmse_scores)
+"""
+Building a model on top of many
+other models is called Ensemble Learning, and it is often a great way to push ML algo‐
+rithms even further
+"""
+from sklearn.ensemble import RandomForestRegressor #RFR takes long time to compute in this computer.
+forest_reg = RandomForestRegressor()
+forest_reg.fit(housing_prepared, housing_labels)
+housing_predictions = forest_reg.predict(housing_prepared)
+forest_mse = mean_squared_error(housing_labels, housing_predictions)
+forest_rmse = np.sqrt(forest_mse)
+print(forest_rmse)
+forest_scores = cross_val_score(forest_reg,housing_prepared,housing_labels,scoring="neg_mean_squared_error",cv=10)
+forest_rmse_scores = np.sqrt(-forest_scores)
+display_scores(forest_rmse_scores)
+
+#Grid Search
+
+from sklearn.model_selection import GridSearchCV
+
+
+param_grid = [
+
+    {'n_estimators':[3,10,30,50],'max_features':[2,4,6,8]},
+    {'bootstrap':[False],'n_estimators':[3,10],'max_features':[2,3,4]},
+    {'n_estimators':[3,10,30,50,100],'max_features':[2,4,6,8],'min_samples_split':[2,3,5]}
+]
+forest_reg = RandomForestRegressor()
+grid_search = GridSearchCV(forest_reg, param_grid,cv=5,scoring='neg_mean_squared_error',return_train_score=True,refit=True)
+grid_search.fit(housing_prepared,housing_labels)
+
+print(grid_search.best_params_)
+print(grid_search.best_estimator_)
+
+cv_res = grid_search.cv_results_
+
+for mean_score, params in zip(cv_res['mean_test_score'],cv_res['params']):
+    print(np.sqrt(-mean_score),params)
+
+"""
+The grid search approach is fine when you are exploring relatively few combinations,
+like in the previous example, but when the hyperparameter search space is large, it is
+often preferable to use RandomizedSearchCV instead.
+ This class can be used in much the same way as the GridSearchCV class, but instead of trying out all possible combi‐
+nations, it evaluates a given number of random combinations by selecting a random
+value for each hyperparameter at every iteration. This approach has two main bene‐
+fits:
+•If you let the randomized search run for, say, 1,000 iterations, this approach will
+explore 1,000 different values for each hyperparameter (instead of just a few val‐
+ues per hyperparameter with the grid search approach).
+• You have more control over the computing budget you want to allocate to hyper‐
+parameter search, simply by setting the number of iterations.
+"""
+
+from sklearn.model_selection import RandomizedSearchCV
+
+rand_grid_search = RandomizedSearchCV(forest_reg,param_grid,n_iter=100,scoring='neg_mean_squared_error',return_train_score=True,refit=True)
+rand_grid_search.fit(housing_prepared,housing_labels)
+print(rand_grid_search.best_params_)
+print(rand_grid_search.best_estimator_)
+
+feature_importances = grid_search.best_estimator_.feature_importances_
+print(feature_importances)
+
+feature_importances_rand = rand_grid_search.best_estimator_.feature_importances_
+print(feature_importances_rand)

Oreilly_Example2.py

@@ -0,0 +1,255 @@
+#CLASSIFICATION
+from sklearn.datasets import fetch_openml
+mnist = fetch_openml('mnist_784',version=1,parser='auto')
+print(mnist.keys())
+
+X,y = mnist['data'],mnist['target']
+
+print(X.shape,y.shape)
+
+"""
+There are 70,000 images, and each image has 784 features. This is because each image
+is 28×28 pixels, and each feature simply represents one pixel’s intensity, from 0
+(white) to 255 (black). Let’s take a peek at one digit from the dataset. All you need to
+do is grab an instance’s feature vector, reshape it to a 28×28 array, and display it using
+Matplotlib’s imshow() function:
+"""
+
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import numpy as np
+some_digit = np.array(X.iloc[0])
+some_digit_image = some_digit.reshape(28,28)
+print(some_digit_image)
+plt.imshow(some_digit_image,cmap=mpl.cm.binary,interpolation='nearest')
+plt.axis('off')
+plt.show()
+print(y.iloc[0])
+
+y = y.astype(np.uint8)
+print(y)
+print(y[0])
+
+X_train,X_test,y_train,y_test = X[:60000], X[60000:], y[:60000], y[60000:]
+
+"""
+Shuffling may be a bad idea in some contexts—for example, if you are working on time series data (such as
+stock market prices or weather conditions). We will explore this in the next chapters.
+"""
+
+y_train_5 = (y_train == 5) #True for all 5s, False for all other digits.
+y_test_5 = (y_test == 5)
+
+from sklearn.linear_model import SGDClassifier
+
+sgd_clf = SGDClassifier()
+sgd_clf.fit(X_train,y_train_5)
+
+
+print(sgd_clf.predict([some_digit]))
+
+#Measuring Accuracy Using Cross-Validation
+
+from sklearn.model_selection import StratifiedKFold
+from sklearn.base import clone
+
+skfolds = StratifiedKFold(n_splits=3)
+
+for train_index, test_index in skfolds.split(X_train, y_train_5):
+    clone_clf = clone(sgd_clf)
+    X_train_folds = X_train.iloc[train_index]
+    y_train_folds = y_train_5.iloc[train_index]
+    X_test_fold = X_train.iloc[test_index]
+    y_test_fold = y_train_5.iloc[test_index]
+    clone_clf.fit(X_train_folds, y_train_folds)
+    y_pred = clone_clf.predict(X_test_fold)
+    n_correct = sum(y_pred == y_test_fold)
+    print(n_correct / len(y_pred))
+
+from sklearn.model_selection import cross_val_score
+cvs_sgd = cross_val_score(sgd_clf, X_train, y_train_5, cv=3, scoring="accuracy")
+print("cvs_sgd: ", cvs_sgd)
+from sklearn.base import BaseEstimator
+
+class Never5Classifier(BaseEstimator):
+    def fit(self,X,y=None):
+        pass
+    def predict(self,X):
+        return np.zeros((len(X),1),dtype=bool)
+
+
+
+never_5_clf = Never5Classifier()
+cvs = cross_val_score(never_5_clf,X_train,y_train_5,cv=3,scoring='accuracy')
+print("cvs: ",cvs)
+
+#Confusion Matrix
+
+from sklearn.metrics import confusion_matrix
+y_pred = sgd_clf.predict(X_train)
+print(confusion_matrix(y_train_5, y_pred))
+
+from sklearn.metrics import precision_score,recall_score,accuracy_score
+#TP:True-Positive; FP:False-Positive
+print(precision_score(y_train_5, y_pred)) #precision = TP/(TP+FP)
+print(recall_score(y_train_5, y_pred)) #recall = TP / (TP+FN)
+print(accuracy_score(y_train_5, y_pred))
+
+"""
+It is often convenient to combine precision and recall into a single metric called the F1
+score, in particular if you need a simple way to compare two classifiers. The F1 score is
+the harmonic mean of precision and recall. Whereas the regular mean treats all values equally,
+the harmonic mean gives much more weight to low values. As a result, the classifier will only
+get a high F1 score if both recall and precision are high.
+"""
+
+from sklearn.metrics import f1_score
+
+print(f"F1 Score: {f1_score(y_train_5, y_pred)}")
+###Precision/Recall Tradeoff.
+"""!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+The F1 score favors classifiers that have similar precision and recall. This is not always
+what you want: in some contexts you mostly care about precision, and in other con‐
+texts you really care about recall. For example, if you trained a classifier to detect vid‐
+eos that are safe for kids, you would probably prefer a classifier that rejects many
+good videos (low recall) but keeps only safe ones (high precision), rather than a clas‐
+sifier that has a much higher recall but lets a few really bad videos show up in your
+product (in such cases, you may even want to add a human pipeline to check the clas‐
+sifier’s video selection). On the other hand, suppose you train a classifier to detect
+shoplifters on surveillance images: it is probably fine if your classifier has only 30%
+precision as long as it has 99% recall (sure, the security guards will get a few false
+alerts, but almost all shoplifters will get caught).
+Unfortunately, you can’t have it both ways: increasing precision reduces recall, and
+vice versa. This is called the `precision/recall tradeoff`.
+!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""
+
+#adjust threshold by using decision_function()
+
+y_scores = sgd_clf.decision_function([some_digit])
+print(y_scores)
+
+threshold = 0
+y_some_digit_pred = (y_scores>threshold)
+print(y_some_digit_pred)
+
+threshold = 5000
+y_some_digit_pred = (y_scores>threshold)
+print(y_some_digit_pred)
+import gradio as gr
+
+#Gradio
+"""def ml_func(threshold):
+    y_some_digit_pred = (y_scores>int(threshold))
+    return "Result is " + str(y_some_digit_pred[0])
+
+demo = gr.Interface(fn=ml_func,inputs="text", outputs="text")
+
+demo.launch(share=True)
+"""
+from sklearn.metrics import precision_recall_curve
+from sklearn.model_selection import cross_val_predict
+
+y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3,method="decision_function")
+
+precisions, recalls, thresholds = precision_recall_curve(y_train_5,y_scores)
+
+def plot_precision_recall_vs_threshold(precisions,recalls,thresholds):
+    plt.plot(thresholds, precisions[:-1],"b--",label="Precision")
+    plt.plot(thresholds,recalls[:-1],"g-",label="Recall")
+    plt.legend()
+
+plot_precision_recall_vs_threshold(precisions,recalls,thresholds)
+plt.show()
+
+#receiver operating characteristic (ROC)
+
+from sklearn.metrics import roc_curve,roc_auc_score
+
+fpr, tpr, thresholds = roc_curve(y_train_5,y_scores)
+
+def plot_roc_curve(fpr,tpr,label=None):
+    plt.plot(fpr,tpr,linewidth=2.5,label=label)
+    plt.plot([0,1],[0,1],"k--")
+
+plot_roc_curve(fpr,tpr)
+plt.show()
+"""
+One way to compare classifiers is to measure the area under the curve (AUC). A per‐
+fect classifier will have a ROC AUC equal to 1, whereas a purely random classifier will
+have a ROC AUC equal to 0.5. Scikit-Learn provides a function to compute the ROC
+AUC:
+"""
+print(roc_auc_score(y_train_5,y_scores))
+
+#Comparing of RFC's and SGD's ROC Curves
+from sklearn.ensemble import RandomForestClassifier
+forest_clf = RandomForestClassifier(random_state=42)
+y_probas_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3,
+ method="predict_proba")
+
+y_scores_forest = y_probas_forest[:, 1] # score = proba of positive class
+fpr_forest, tpr_forest, thresholds_forest = roc_curve(y_train_5,y_scores_forest)
+
+plt.plot(fpr, tpr, "b:", label="SGD")
+plot_roc_curve(fpr_forest, tpr_forest, "Random Forest")
+plt.legend(loc="lower right")
+plt.show()
+
+#Multiclass Classification
+from sklearn.multiclass import OneVsOneClassifier
+
+ovo_clf = OneVsOneClassifier(SGDClassifier(random_state=42))
+ovo_clf.fit(X_train,y_train)
+print(f"OvO -> {ovo_clf.predict([some_digit])}")
+
+print(len(ovo_clf.estimators_))
+
+forest_clf.fit(X_train,y_train)
+print(f"Random Forest Classifier -> {forest_clf.predict([some_digit])}")
+
+print(forest_clf.predict_proba([some_digit]))
+
+print(cross_val_score(sgd_clf, X_train, y_train, cv=3, scoring="accuracy"))
+
+from sklearn.preprocessing import StandardScaler
+scaler = StandardScaler()
+X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
+print(cross_val_score(sgd_clf, X_train_scaled, y_train, cv=3, scoring="accuracy"))
+y_train_pred = cross_val_predict(sgd_clf, X_train_scaled, y_train, cv=3)
+conf_mx = confusion_matrix(y_train, y_train_pred)
+plt.matshow(conf_mx, cmap=plt.cm.gray)
+plt.show()
+
+
+#Multilabel Classification
+
+"""
+Say the classifier has been trained to recognize three faces, Alice, Bob, and Charlie; then
+when it is shown a picture of Alice and Charlie, it should output [1, 0, 1] (meaning
+“Alice yes, Bob no, Charlie yes”). Such a classification system that outputs multiple
+binary tags is called a multilabel classification system.
+"""
+
+from sklearn.neighbors import KNeighborsClassifier
+#supports multilabel classification, but not all classifiers do
+y_train_large = (y_train >= 7)
+y_train_odd = (y_train % 2 == 1)
+y_multilabel = np.c_[y_train_large,y_train_odd]
+
+"""
+np.c_[np.array([1,2,3]), np.array([4,5,6])]
+array([[1, 4],
+       [2, 5],
+       [3, 6]])
+np.c_[np.array([[1,2,3]]), 0, 0, np.array([[4,5,6]])]
+array([[1, 2, 3, ..., 4, 5, 6]])
+"""
+
+knn_clf = KNeighborsClassifier()
+knn_clf.fit(X_train,y_multilabel)
+
+prediksiyon = knn_clf.predict([some_digit]) #Checks some_digit is equal and large than 7 and odd.
+print(prediksiyon)
+
+y_train_knn_pred = cross_val_predict(knn_clf,X_train,y_multilabel,cv=3)
+f1_score(y_multilabel,y_train_knn_pred,average='macro')

Oreilly_Example3.py

@@ -0,0 +1,34 @@
+import numpy as np
+from matplotlib import pyplot as plt
+from sklearn.linear_model import LinearRegression
+X = 2 * np.random.rand(100, 1)
+y = 4 + 3 * X + np.random.randn(100, 1)
+
+lr = LinearRegression()
+lr.fit(X,y)
+print(lr.predict([[2]]))
+plt.scatter(X,y)
+plt.plot([0,2],[lr.predict([[0]])[0][0],lr.predict([[2]])[0][0]],color="red")
+plt.show()
+
+X_b = np.c_[np.ones((100,1)),X] #added x0 = 1 to each instance
+theta_best = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y)
+print(theta_best)
+print(lr.intercept_, lr.coef_)
+
+"""
+Note about Gradient Descent:
+When using Gradient Descent, you should ensure that all features
+have a similar scale (e.g., using Scikit-Learn’s StandardScaler
+class), or else it will take much longer to converge.
+To find a good learning rate eta, can use grid search. However, you
+may want to limit the number of iterations so that grid search can eliminate models
+that take too long to converge.
+
+"""
+
+from sklearn.linear_model import SGDRegressor
+sgd_reg = SGDRegressor(max_iter=1000,tol=1e-3,penalty=None,eta0=0.1)
+sgd_reg.fit(X,y.ravel())
+
+print(sgd_reg.intercept_, sgd_reg.coef_)

Oreilly_LogisticReg.py

@@ -0,0 +1,24 @@
+from sklearn import datasets
+from sklearn.linear_model import LogisticRegression
+import numpy as np
+from matplotlib import pyplot as plt
+iris = datasets.load_iris()
+print(list(iris.keys()))
+X = iris["data"][:,3:]
+y = (iris["target"] == 0).astype(int)
+print(X)
+print(y)
+
+from sklearn.linear_model import LogisticRegression
+log_reg = LogisticRegression()
+log_reg.fit(X, y)
+X_new = np.linspace(0, 3, 1000).reshape(-1, 1)
+print(X_new)
+y_proba = log_reg.predict_proba(X_new)
+plt.figure(figsize=(10,6))
+plt.plot(X_new, y_proba[:, 1], "g-", label="Iris-Virginica")
+plt.plot(X_new, y_proba[:, 0], "b--", label="Not Iris-Virginica")
+plt.xlabel("Petal width (cm)")
+plt.ylabel("Probability")
+plt.legend()
+plt.show()

Oreilly_PolynomialReg.py

@@ -0,0 +1,27 @@
+
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.linear_model import LinearRegression
+m = 100
+X = 6 * np.random.rand(m,1)-3
+y = 0.3 * X**3 + 0.5 * X**2 + X + 8 - np.random.rand(m,1)
+
+plt.scatter(X,y)
+plt.xlabel("X1")
+plt.ylabel("y")
+plt.show()
+
+from sklearn.preprocessing import PolynomialFeatures
+
+poly_features = PolynomialFeatures(degree=3,include_bias=False)
+X_poly = poly_features.fit_transform(X)
+print(X[0])
+print(X_poly[0])
+
+lin_reg = LinearRegression()
+lin_reg.fit(X_poly,y)
+print(X_poly)
+print(y)
+print(lin_reg.intercept_, lin_reg.coef_)
+
+print(lin_reg.predict([[0,1,2]]))

Oreilly_SVM.py

@@ -0,0 +1,81 @@
+"""
+
+A Support Vector Machine (SVM) is a very powerful and versatile Machine Learning
+model, capable of performing linear or nonlinear classification, regression, and even
+outlier detection. It is one of the most popular models in Machine Learning, and any‐
+one interested in Machine Learning should have it in their toolbox. SVMs are partic‐
+ularly well suited for classification of complex but small- or medium-sized datasets.
+
+SVMs are sensitive to the feature scales. After feature scaling
+(e.g., using Scikit-Learn’s StandardScaler),
+the decision boundary looks much better.
+
+"""
+import gradio as gr
+from sklearn import datasets
+from sklearn.svm import SVC
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.datasets import make_moons
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import StandardScaler
+
+iris = datasets.load_iris()
+
+import pandas as pd
+#Gradio Function
+def polynomial_svm(file,n_sample,noise,degree,C,coef0,head_value):
+        df = pd.read_csv(file.name)
+        X, y = make_moons(n_samples=n_sample, noise=noise, random_state=44)
+        polynomial_svm_clf = Pipeline([
+            ("scaler", StandardScaler()),
+            ("svm_clf", SVC(kernel="poly", degree=degree, C=C, coef0=coef0,probability=True)),
+        ])
+        polynomial_svm_clf.fit(X, y)
+        fig = plt.figure()
+        # Create a meshgrid of points covering the input space
+        x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
+        y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
+        xx, yy = np.meshgrid(np.linspace(x_min, x_max, 200),
+                             np.linspace(y_min, y_max, 200))
+        # Generate predictions for each point in the meshgrid
+        Z = polynomial_svm_clf.predict(np.c_[xx.ravel(), yy.ravel()])
+        Z = Z.reshape(xx.shape)
+        # Create a color map
+        cmap = plt.cm.Pastel1
+        # Plot the decision boundary and the data points
+        plt.contourf(xx, yy, Z, alpha=0.8, cmap=cmap)
+        plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='k', cmap=cmap)
+        plt.xlabel('Feature 1')
+        plt.ylabel('Feature 2')
+        plt.title('Polynomial SVM Classifier Decision Boundary')
+        plt.xlim(xx.min(), xx.max())
+        plt.ylim(yy.min(), yy.max())
+        plt.xticks(())
+        plt.yticks(())
+
+        return fig,df.head(head_value)
+
+
+
+
+
+inputs = [
+    gr.File(label='Import a CSV File',file_count='single',file_types=['csv']),
+    gr.Slider(100,3000,1500,label='Number of Samples'),
+    gr.Slider(0,1,0.15,label='Noise'),
+    gr.Slider(1,5,3,step=1,label='Degree'),
+    gr.Slider(1,10,5,step=1,label='C'),
+    gr.Slider(1,10,3,step=1,label='coefficient 0'),
+    gr.Slider(1,20,10,step=1,label='Head'),
+]
+outputs = [gr.Plot(label='Polynomial SVM Classifier'),
+           gr.Textbox(label='Head')]
+
+demo = gr.Interface(
+    fn = polynomial_svm,
+    inputs=inputs,
+    outputs=outputs,
+)
+if __name__ == "__main__":
+    demo.launch(share=True)

Panda.py

@@ -0,0 +1,177 @@
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch.optim import Adam
+from gym import spaces
+import gym
+from torch.distributions import Normal
+import random
+
+# Actor Network
+class Actor(torch.nn.Module):
+    def __init__(self, n_states, n_actions):
+        super(Actor, self).__init__()
+        self.fc1 = torch.nn.Linear(n_states, 400)
+        self.fc2 = torch.nn.Linear(400, 300)
+        self.fc3 = torch.nn.Linear(300, n_actions)
+
+    def forward(self, state):
+        x = F.relu(self.fc1(state))
+        x = F.relu(self.fc2(x))
+        return torch.tanh(self.fc3(x))  # bound the actions to the range [-1, 1]
+
+
+# Critic Network
+class Critic(torch.nn.Module):
+    def __init__(self, n_states, n_actions):
+        super(Critic, self).__init__()
+        self.fc1 = torch.nn.Linear(n_states + n_actions, 400)
+        self.fc2 = torch.nn.Linear(400, 300)
+        self.fc3 = torch.nn.Linear(300, 1)
+
+    def forward(self, state, action):
+        sa = torch.cat([state, action], dim=1)
+        x = F.relu(self.fc1(sa))
+        x = F.relu(self.fc2(x))
+        return self.fc3(x)
+
+
+class DDPGAgent:
+    def __init__(self, env, n_states, n_actions, actor_lr=1e-4, critic_lr=1e-3, gamma=0.99, tau=1e-2, max_memory_size=50000):
+        # Network
+
+
+        self.critic = Critic(n_states, n_actions)
+        self.target_actor = Actor(n_states, n_actions)
+        self.target_critic = Critic(n_states, n_actions)
+        self.memory = []
+        self.max_memory_size = max_memory_size
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.actor = Actor(n_states, n_actions).to(self.device)
+        # Training
+        self.gamma = gamma
+        self.tau = tau
+        self.loss_func = torch.nn.MSELoss()
+        self.actor_optim = Adam(self.actor.parameters(), lr=actor_lr)
+        self.critic_optim = Adam(self.critic.parameters(), lr=critic_lr)
+
+        # Noise
+        self.noise = Normal(0, 0.1)
+
+        # Action space bounds
+        self.action_low = env.action_space.low
+        self.action_high = env.action_space.high
+
+        self.env = env
+
+    def remember(self, state, action, reward, next_state):
+        self.memory.append((state, action, reward, next_state))
+        if len(self.memory) > self.max_memory_size:
+            self.memory.pop(0)
+
+    def train(self, batch_size=64):
+        if len(self.memory) < batch_size:
+            return
+
+        mini_batch = random.sample(self.memory, batch_size)
+        state_batch = torch.cat([data[0] for data in mini_batch])
+        action_batch = torch.cat([data[1] for data in mini_batch])
+        reward_batch = torch.cat([data[2] for data in mini_batch])
+        next_state_batch = torch.cat([data[3] for data in mini_batch])
+
+        target_action_batch = self.target_actor(next_state_batch)
+        target_critic_value = self.target_critic(next_state_batch, target_action_batch)
+        expected_critic_value = reward_batch + self.gamma * target_critic_value
+
+        # Update critic
+        self.critic_optim.zero_grad()
+        critic_value = self.critic(state_batch, action_batch)
+        critic_loss = self.loss_func(critic_value, expected_critic_value)
+        critic_loss.backward()
+        self.critic_optim.step()
+
+        # Update actor
+        self.actor_optim.zero_grad()
+        new_action_batch = self.actor(state_batch)
+        actor_loss = -self.critic(state_batch, new_action_batch).mean()
+        actor_loss.backward()
+        self.actor_optim.step()
+
+        # Update target networks
+        self.soft_update(self.target_actor, self.actor, self.tau)
+        self.soft_update(self.target_critic, self.critic, self.tau)
+
+    @staticmethod
+    def soft_update(target, source, tau):
+        for target_param, source_param in zip(target.parameters(), source.parameters()):
+            target_param.data.copy_(target_param.data * (1.0 - tau) + source_param.data * tau)
+
+    def get_action(self, state):
+        state = torch.FloatTensor(state).unsqueeze(0).to(self.device)
+        self.actor.eval()
+        with torch.no_grad():
+            action = self.actor(state).cpu().numpy()[0]
+        self.actor.train()
+        action_tensor = torch.tensor(action, dtype=torch.float32)
+        noise_sample = torch.normal(mean=torch.zeros_like(action_tensor),
+                                    std=0.1 * torch.ones_like(action_tensor)).numpy()
+        return np.clip(action + noise_sample, self.action_low, self.action_high)
+
+    def save_model(self, output):
+        torch.save(self.actor.state_dict(), '{}/actor.pkl'.format(output))
+        torch.save(self.critic.state_dict(), '{}/critic.pkl'.format(output))
+
+    def load_model(self, output):
+        self.actor.load_state_dict(torch.load('{}/actor.pkl'.format(output)))
+        self.critic.load_state_dict(torch.load('{}/critic.pkl'.format(output)))
+
+
+# Define your environment below
+class PandaRobotEnv(gym.Env):
+    def __init__(self):
+        super(PandaRobotEnv, self).__init__()
+        self.action_space = spaces.Box(low=-np.inf, high=np.inf, shape=(6,), dtype=np.float32)
+        self.observation_space = spaces.Box(low=-np.inf, high=np.inf, shape=(6,), dtype=np.float32)
+        self.state = None
+        self.goal = None
+
+    def step(self, action):
+        # You would typically use the action to update the state of the robot.
+        # Then, you would calculate the reward based on the new state and whether the new state is terminal.
+        self.state = np.clip(self.state + action, -np.inf, np.inf)  # Update state with action
+        distance_to_goal = np.linalg.norm(self.goal - self.state)
+        done = distance_to_goal < 0.1  # The episode ends if you're close enough to the goal
+        reward = -distance_to_goal  # The reward is the negative distance to the goal
+        return self.state, reward, done, {}
+
+    def reset(self):
+        # Reset the state and goal for the start of a new episode.
+        self.state = np.random.uniform(-1, 1, size=(6,))
+        self.goal = np.random.uniform(-1, 1, size=(6,))
+        return self.state
+
+
+def run():
+    # Initialize the environment and the agent
+    env = PandaRobotEnv()
+    agent = DDPGAgent(env=env, n_states=env.observation_space.shape[0], n_actions=env.action_space.shape[0])
+
+    for episode in range(1, 1001):  # for 1000 episodes
+        state = env.reset()
+        done = False
+        total_reward = 0
+        while not done:
+            action = agent.get_action(state)
+            next_state, reward, done, _ = env.step(action)
+            agent.remember(torch.tensor(state, dtype=torch.float), torch.tensor(action, dtype=torch.float),
+                           torch.tensor([reward], dtype=torch.float), torch.tensor(next_state, dtype=torch.float))
+            agent.train()
+            state = next_state
+            total_reward += reward
+
+        if episode % 100 == 0:  # print every 100 episodes
+            print('Episode: {}, Total reward: {}'.format(episode, total_reward))
+
+
+if __name__ == "__main__":
+    run()

Q-Learning Example.py

@@ -0,0 +1,134 @@
+from keras.models import Sequential, Model
+from keras.layers import Dropout, Dense, Input, Activation
+from keras.optimizers import Adam
+import numpy as np
+from collections import deque
+import random
+
+EPISODES=1000
+
+class Walker:
+    def __init__(self, nx, ny, lr, gamma):
+        self.nx = nx
+        self.ny = ny
+        self.lr = lr
+        self.los = []
+        self.gamma = gamma
+        self.memory_deck = deque(maxlen=2000)
+        self.epsilon = 0.7
+        self.epsilon_ = 0.01
+        self.decay = 0.995
+        self.model = self.get_model()
+        self.episode_observation, self.episode_rewards, self.episode_action, self.new_episode_observation, self.episode_flag = [], [], [], [], []
+
+    def get_action(self, observation):
+        if np.random.rand() <= self.epsilon:
+            return np.random.uniform(-1, 1, 4)
+        p = self.model.predict(observation)
+        return p[0]
+
+    def memory_recall(self, observation, action, reward, new_observation, flags):
+        self.memory_deck.append((observation, action, reward, new_observation, flags))
+        self.episode_rewards.append(reward)
+
+    def get_model(self):
+        model = Sequential()
+        model.add(Dense(400, input_dim=self.nx, activation='relu'))
+        model.add(Dense(300, activation='relu'))
+        model.add(Dense(self.ny, activation='linear'))
+        model.compile(loss='mse', optimizer=Adam(lr=self.lr))
+        return model
+
+    def training(self, batch):
+        i = random.sample(self.memory_deck, batch)
+        self.los = []
+        for obs, act, rew, new_obs, done in i:
+            target = rew
+            if not done:
+                target = ((1.0 - 0.1) * rew + 0.1 * (self.gamma * np.amax(self.model.predict(new_obs)[0])))
+
+            old_target = self.model.predict(obs)
+            old_target[0] = target
+            history = self.model.fit(x=obs, y=old_target, verbose=0, epochs=1)
+            self.los.append(history.history['loss'])
+            self.episode_observation, self.episode_rewards, self.episode_action, self.new_episode_observation, self.episode_flag = [], [], [], [], []
+
+        mm = np.mean(self.los)
+        if self.epsilon >= self.epsilon_:
+            self.epsilon *= self.decay
+        return history, mm
+
+
+import gym
+import numpy as np
+import random
+import time
+
+seed = np.random.seed(666)
+
+episodes = EPISODES
+render = False
+
+env = gym.make('BipedalWalker-v3')
+env = env.unwrapped
+
+lr = 0.001
+gamma = 0.98
+nx = env.observation_space.shape[0]
+ny = env.action_space.shape[0]
+agent = Walker(nx, ny, lr, gamma)
+win = 0
+rewards_over_time = []
+avg_reward_mat = []
+net_max = []
+
+for i in range(episodes):
+    observation = env.reset()[0]
+    observation = observation.reshape(1, -1)
+    start = time.time()
+    while True:
+        if render == True:
+            env.render()
+
+        action = agent.get_action(observation)
+        new_observation, reward, flag, inf, fff = env.step(action)
+        new_observation = new_observation.reshape(1, -1)
+        agent.memory_recall(observation, action, reward, new_observation, flag)
+        observation = new_observation
+
+        end = time.time()
+        t = end - start
+        if t > 20:
+            flag = True
+
+        total_episode_rewards = sum(agent.episode_rewards)
+        if total_episode_rewards < -300:
+            flag = True
+
+        if flag == True:
+            rewards_over_time.append(total_episode_rewards)
+            max_reward = np.max(rewards_over_time)
+            if (i % 10 == 0):
+                avg_reward_mat.append(sum(rewards_over_time[-10:]) / 10)
+            if (len(net_max) == 0):
+                net_max.append(total_episode_rewards)
+            else:
+                if (net_max[-1] < total_episode_rewards):
+                    net_max.append(total_episode_rewards)
+                else:
+                    net_max.append(net_max[-1])
+            if int(total_episode_rewards) > 270 and i > 2000:
+                render = True
+            episode_max = np.argmax(rewards_over_time)
+            if total_episode_rewards >= 300:
+                win = win + 1
+            print('##################################################################')
+            print('Walk# : ', i)
+            print('Reward : ', int(total_episode_rewards))
+            print('Time : ', np.round(t, 2), 'sec')
+            print('Maximum Reward : ' + str(int(max_reward)) + '       (in episode#:' + str(episode_max) + ')')
+            print('Wins : ' + str(win))
+
+            hist, mm = agent.training(16)
+            # if max_reward > 100: render = True
+            break

README.md

@@ -1,12 +1,6 @@
 ---
-title: Regressions Classifications Test
-emoji: 🏢
-colorFrom: red
-colorTo: green
+title: Regressions_Classifications_Test
+app_file: data_visualization.py
 sdk: gradio
-sdk_version: 3.36.0
-app_file: app.py
-pinned: false
+sdk_version: 3.35.2
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

RoboEnv_View.py

@@ -0,0 +1,153 @@
+import time
+import pybullet as p
+import pybullet_data
+import numpy as np
+import gymnasium as gym
+from stable_baselines3 import PPO
+from stable_baselines3.common.env_checker import check_env
+from sklearn.metrics import r2_score
+# Create a custom PyBullet environment
+class PyBulletEnv(gym.Env):
+    def __init__(self, render_mode='human'):
+        # Connect to the physics server
+        self.physics_client = p.connect(p.DIRECT)
+
+        # Load additional data files from pybullet_data
+        p.setAdditionalSearchPath(pybullet_data.getDataPath())
+
+        # Load the plane at the origin of the world
+        self.plane = p.loadURDF("plane.urdf", [0, 0, 0], [0, 0, 0, 1], useFixedBase=True)
+
+        # Load the robot model
+        self.robot = p.loadURDF("robot.urdf", [0, 0, 0], [0, 0, 0, 1], useFixedBase=True)
+
+        # Randomly set initial joint angles
+        initial_joint_angles = np.random.uniform(low=-np.pi, high=np.pi, size=(6,))
+        for i in range(6):
+            p.resetJointState(self.robot, i, initial_joint_angles[i])
+
+        # Fix the base_link to the origin of the plane
+        base_link_pos, _ = p.getBasePositionAndOrientation(self.robot)
+        plane_pos, _ = p.getBasePositionAndOrientation(self.plane)
+        constraint_pos = np.array(plane_pos) - np.array(base_link_pos)
+        p.createConstraint(self.plane, -1, self.robot, -1, p.JOINT_FIXED, constraint_pos, [0, 0, 0], [0, 0, 0])
+
+        # Load the target model at a reachable position
+        self.target = p.loadURDF("target.urdf", [0.3, 0.3, 0], [0, 0, 0, 1], useFixedBase=True)
+
+        # Define the action and observation spaces
+        self.action_space = gym.spaces.Box(low=-1, high=1, shape=(6,), dtype=np.float32)
+        self.observation_space = gym.spaces.Box(low=-np.inf, high=np.inf, shape=(6,), dtype=np.float32)
+
+        # Set the initial observation
+        self.observation = np.zeros((6,))
+
+        # Set the rendering mode
+        self.render_mode = render_mode
+
+    def step(self, action):
+        # Set joint motor controls based on the action
+        p.setJointMotorControlArray(self.robot, range(6), p.POSITION_CONTROL, targetPositions=action)
+
+        # Step the simulation
+        p.stepSimulation()
+
+        # Get the robot's joint angles
+        joint_angles = []
+        for i in range(6):
+            joint_state = p.getJointState(self.robot, i)
+            joint_angles.append(joint_state[0])
+        self.observation = np.array(joint_angles)
+
+        # Calculate the reward (6th link touching the target)
+        end_effector_pos, _ = p.getLinkState(self.robot, 6)[:2]
+        target_pos, _ = p.getBasePositionAndOrientation(self.target)
+        dist = np.linalg.norm(np.array(end_effector_pos) - np.array(target_pos))
+        reward = -dist if dist > 0.1 else 1.0
+
+        # Check if the episode is done (6th link touching the target)
+        done = dist <= 0.1
+
+        # Return the observation, reward, done flag, and additional info
+        return self.observation, reward, done, {}
+
+    def reset(self):
+        # Randomly set initial joint angles
+        initial_joint_angles = np.random.uniform(low=-np.pi, high=np.pi, size=(6,))
+        for i in range(6):
+            p.resetJointState(self.robot, i, initial_joint_angles[i])
+
+        # Set the initial observation
+        self.observation = np.array(initial_joint_angles)
+
+        return self.observation
+
+
+
+
+    def render(self, mode='human'):
+        if mode == 'human':
+            p.disconnect()
+            p.connect(p.GUI)
+            self.physics_client = p.GUI
+        elif mode == 'rgb_array':
+            p.disconnect()
+            p.connect(p.DIRECT)
+            self.physics_client = p.DIRECT
+        else:
+            raise ValueError("Invalid rendering mode. Supported modes are 'human' and 'rgb_array'.")
+
+        # Render the environment
+        p.configureDebugVisualizer(p.COV_ENABLE_RENDERING, 1)
+        p.configureDebugVisualizer(p.COV_ENABLE_GUI, 0)
+        p.configureDebugVisualizer(p.COV_ENABLE_KEYBOARD_SHORTCUTS, 0)
+        p.configureDebugVisualizer(p.COV_ENABLE_MOUSE_PICKING, 0)
+
+        # Set the camera parameters (adjust as needed)
+        p.resetDebugVisualizerCamera(cameraDistance=1, cameraYaw=45, cameraPitch=-45, cameraTargetPosition=[0, 0, 0])
+
+        # Get the camera image
+        _, _, rgb, _, _ = p.getCameraImage(width=800, height=600, renderer=p.ER_BULLET_HARDWARE_OPENGL)
+
+        # Convert RGB image to numpy array
+        rgb_array = np.array(rgb)
+
+        if mode == 'rgb_array':
+            return rgb_array
+        else:
+            # Show the rendered image in a window
+            time.sleep(1 / 240)  # Control rendering speed
+
+
+# Create the custom PyBullet environment
+env = PyBulletEnv()
+check_env(env)
+
+# Create the PPO agent
+model = PPO("MlpPolicy", env, verbose=1)
+
+# Train the agent
+model.learn(total_timesteps=10000)
+
+# Render the trained model every 100 episodes
+for episode in range(0, 10001, 100):
+    # Reset the environment
+    vec_env = model.get_env()
+    obs = vec_env.reset()
+
+    # Run the episode with the trained model
+    for _ in range(100):
+        # Get the action from the trained model
+
+        # Render the environment
+        vec_env.render()
+        action, _ = model.predict(obs, deterministic=True)
+        # Take a step in the environment
+        obs, reward, done, info = vec_env.step(action)
+
+        # Check if the episode is done
+        if done:
+            break
+
+# Close the environment
+env.close()

data_X.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:384f8a2c378f24d24834ce6be39278224da0f203b570935d56c130462f980bff
+size 196164389

data_visualization.py

@@ -0,0 +1,75 @@
+
+import matplotlib.pyplot as plt
+import pandas as pd
+import gradio as gr
+from sklearn.linear_model import LinearRegression,LogisticRegression
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.model_selection import train_test_split
+"""x,y = [1,2,3],[4,5,6]
+plt.title("Linear Graph",fontdict={'fontname':'Times New Roman','fontsize':26,'color':'#000000'})
+plt.xlabel('X Axis',fontdict={'fontname':'Times New Roman','fontsize':16,'color':'blue'})
+plt.ylabel('Y Axis',fontdict={'fontname':'Times New Roman','fontsize':16,'color':'green'})
+plt.plot(x,y,color='purple',linewidth=2,label='first')
+plt.plot(y,x,color='red',linewidth=2,label='second')
+plt.xticks([0.5,1,1.5,2,2.5,3])
+plt.xticks([3.5,4,4.5,5,5.5,6])
+plt.legend()
+plt.show()
+"""
+
+
+def draw_graph(x=str, y=str, title=str, x_label=str, y_label=str):
+
+
+    fig = plt.figure()
+    plt.title(title, fontdict={'fontname': 'Times New Roman', 'fontsize': 26, 'color': '#000000'})
+    plt.xlabel(x_label, fontdict={'fontname': 'Times New Roman', 'fontsize': 16, 'color': 'blue'})
+    plt.ylabel(y_label, fontdict={'fontname': 'Times New Roman', 'fontsize': 16, 'color': 'green'})
+    x = list(map(int, x.split(',')))
+    y = list(map(int, y.split(',')))
+    if len(x) != len(y):
+       raise gr.Error("X and Y Arrays' Lengths are not Equal!")
+    df = pd.DataFrame({'X':x,'Y':y})
+    x_train,x_test,y_train,y_test=train_test_split(df[['X']],df[['Y']],test_size=0.33,random_state=42)
+    lr = LinearRegression()
+    lr.fit(x_train,y_train)
+    y_pred_lr = lr.predict(x_test)
+    log_reg = LogisticRegression(max_iter=1000)
+    log_reg.fit(x_train.to_numpy().tolist(),y_train.to_numpy().tolist())
+    y_pred_log_reg = log_reg.predict(x_test.to_numpy().tolist())
+    rnd_fr = RandomForestRegressor(n_jobs=100)
+    rnd_fr.fit(x_train.to_numpy().tolist(),y_train.to_numpy().tolist())
+    y_pred_rnd_fr = rnd_fr.predict(x_test)
+    plt.grid('on')
+    plt.plot(x, y,"o",label='Values')
+    plt.plot(x_test,y_pred_lr,label='Linear Regression')
+    plt.plot(x_test,y_pred_log_reg,label='Logistic Regression')
+    plt.plot(x_test,y_pred_rnd_fr,label='Random Forest Regression')
+    plt.legend()
+
+
+
+    return fig
+
+inputs = [
+    gr.Textbox(label='X values'),
+    gr.Textbox(label='Y values'),
+    gr.Textbox(label='Title'),
+    gr.Textbox(label='X Label'),
+    gr.Textbox(label='Y Label'),
+]
+outputs = [
+    gr.Plot(label='Regressions'),
+    gr.Plot(label='Classifications'),
+    gr.Textbox(label='Regression Scores'),
+    gr.Textbox(label='Classification Scores')
+
+]
+
+demo = gr.Interface(
+    fn=draw_graph,
+    inputs=inputs,
+    outputs=outputs,
+)
+if __name__ == "__main__":
+    demo.launch(share=True)

datasets/housing/housing.tgz

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

dqn_lunar.zip

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

flagged/Polynomial SVM Classifier/tmp1qkjy2sm.json

@@ -0,0 +1 @@
+{"type": "matplotlib", "plot": "data:image/png;base64,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"}

flagged/log.csv

@@ -0,0 +1,102 @@
+Number of Samples,Noise,Degree,C,coefficient 0,Polynomial SVM Classifier,Probabilities,flag,username,timestamp
+350,1,5,8,8,C:\IT\PythonProject\OffsetCorrection\flagged\Polynomial SVM Classifier\tmp1qkjy2sm.json,"[[4.84269407e-01 5.15730593e-01]
+ [4.90755053e-01 5.09244947e-01]
+ [5.63261660e-01 4.36738340e-01]
+ [4.08689474e-01 5.91310526e-01]
+ [5.00000000e-01 5.00000000e-01]
+ [4.62511426e-01 5.37488574e-01]
+ [4.83982836e-01 5.16017164e-01]
+ [5.45072318e-01 4.54927682e-01]
+ [4.67917347e-01 5.32082653e-01]
+ [4.74482405e-01 5.25517595e-01]
+ [4.12314113e-01 5.87685887e-01]
+ [4.91000216e-01 5.08999784e-01]
+ [6.57143411e-01 3.42856589e-01]
+ [4.56434251e-01 5.43565749e-01]
+ [4.69722281e-01 5.30277719e-01]
+ [4.16949760e-01 5.83050240e-01]
+ [4.55113843e-01 5.44886157e-01]
+ [4.79002628e-01 5.20997372e-01]
+ [4.33410232e-01 5.66589768e-01]
+ [5.08523248e-01 4.91476752e-01]
+ [4.01499958e-01 5.98500042e-01]
+ [5.00000000e-01 5.00000000e-01]
+ [5.00000000e-01 5.00000000e-01]
+ [4.08199595e-01 5.91800405e-01]
+ [9.69644681e-01 3.03553193e-02]
+ [4.88197228e-01 5.11802772e-01]
+ [4.84114775e-01 5.15885225e-01]
+ [4.77507941e-01 5.22492059e-01]
+ [3.74425704e-01 6.25574296e-01]
+ [4.58412126e-01 5.41587874e-01]
+ [4.89897945e-01 5.10102055e-01]
+ [4.78140045e-01 5.21859955e-01]
+ [4.03915616e-01 5.96084384e-01]
+ [4.56796091e-01 5.43203909e-01]
+ [5.00000000e-01 5.00000000e-01]
+ [7.32797836e-01 2.67202164e-01]
+ [5.00000000e-01 5.00000000e-01]
+ [5.00000000e-01 5.00000000e-01]
+ [9.93406935e-01 6.59306543e-03]
+ [3.78157020e-01 6.21842980e-01]
+ [4.57160704e-01 5.42839296e-01]
+ [9.99999733e-01 2.67343407e-07]
+ [6.22350465e-01 3.77649535e-01]
+ [4.64316427e-01 5.35683573e-01]
+ [4.81290184e-01 5.18709816e-01]
+ [7.14259399e-01 2.85740601e-01]
+ [4.77395029e-01 5.22604971e-01]
+ [5.00000000e-01 5.00000000e-01]
+ [4.16303760e-01 5.83696240e-01]
+ [4.80194576e-01 5.19805424e-01]
+ [7.15837454e-01 2.84162546e-01]
+ [4.85737793e-01 5.14262207e-01]
+ [4.59332065e-01 5.40667935e-01]
+ [5.00000000e-01 5.00000000e-01]
+ [4.88384247e-01 5.11615753e-01]
+ [4.54899516e-01 5.45100484e-01]
+ [5.60211023e-01 4.39788977e-01]
+ [4.53175429e-01 5.46824571e-01]
+ [4.85564491e-01 5.14435509e-01]
+ [4.53566621e-01 5.46433379e-01]
+ [4.92265383e-01 5.07734617e-01]
+ [4.90539349e-01 5.09460651e-01]
+ [3.95359300e-01 6.04640700e-01]
+ [6.20691301e-01 3.79308699e-01]
+ [5.00000000e-01 5.00000000e-01]
+ [9.99999287e-01 7.12873818e-07]
+ [4.85769673e-01 5.14230327e-01]
+ [4.93337010e-01 5.06662990e-01]
+ [9.81381449e-01 1.86185515e-02]
+ [4.55065432e-01 5.44934568e-01]
+ [4.57407007e-01 5.42592993e-01]
+ [4.88064354e-01 5.11935646e-01]
+ [4.07671732e-01 5.92328268e-01]
+ [5.00000000e-01 5.00000000e-01]
+ [4.57986562e-01 5.42013438e-01]
+ [3.49359951e-01 6.50640049e-01]
+ [4.87098761e-01 5.12901239e-01]
+ [4.57893841e-01 5.42106159e-01]
+ [5.00000000e-01 5.00000000e-01]
+ [5.00000000e-01 5.00000000e-01]
+ [5.00000000e-01 5.00000000e-01]
+ [3.86068942e-01 6.13931058e-01]
+ [5.11186691e-01 4.88813309e-01]
+ [5.00000000e-01 5.00000000e-01]
+ [5.00000000e-01 5.00000000e-01]
+ [5.11595504e-01 4.88404496e-01]
+ [4.56883473e-01 5.43116527e-01]
+ [4.48814896e-01 5.51185104e-01]
+ [4.49255361e-01 5.50744639e-01]
+ [4.83946813e-01 5.16053187e-01]
+ [4.91723763e-01 5.08276237e-01]
+ [4.83997832e-01 5.16002168e-01]
+ [6.46859600e-01 3.53140400e-01]
+ [4.31456429e-01 5.68543571e-01]
+ [4.57347527e-01 5.42652473e-01]
+ [6.34743472e-01 3.65256528e-01]
+ [4.55476049e-01 5.44523951e-01]
+ [4.88134941e-01 5.11865059e-01]
+ [5.25883778e-01 4.74116222e-01]
+ [4.87301266e-01 5.12698734e-01]]",,,2023-07-06 11:04:01.656113
+,,,,,,,,2023-07-06 17:24:49.861189

iris_tree.dot

@@ -0,0 +1,13 @@
+digraph Tree {
+node [shape=box, style="filled, rounded", color="black", fontname="helvetica"] ;
+edge [fontname="helvetica"] ;
+0 [label="petal length (cm) <= 2.45\ngini = 0.667\nsamples = 150\nvalue = [50, 50, 50]\nclass = setosa", fillcolor="#ffffff"] ;
+1 [label="gini = 0.0\nsamples = 50\nvalue = [50, 0, 0]\nclass = setosa", fillcolor="#e58139"] ;
+0 -> 1 [labeldistance=2.5, labelangle=45, headlabel="True"] ;
+2 [label="petal width (cm) <= 1.75\ngini = 0.5\nsamples = 100\nvalue = [0, 50, 50]\nclass = versicolor", fillcolor="#ffffff"] ;
+0 -> 2 [labeldistance=2.5, labelangle=-45, headlabel="False"] ;
+3 [label="gini = 0.168\nsamples = 54\nvalue = [0, 49, 5]\nclass = versicolor", fillcolor="#4de88e"] ;
+2 -> 3 ;
+4 [label="gini = 0.043\nsamples = 46\nvalue = [0, 1, 45]\nclass = virginica", fillcolor="#843de6"] ;
+2 -> 4 ;
+}

kaggle_example.py

@@ -0,0 +1,52 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+
+df_X = pd.read_csv("data_X.csv",parse_dates=["date_time"])
+df_Y = pd.read_csv("data_Y.csv",parse_dates=["date_time"])
+df_X_copy = df_X.copy()
+df_Y_copy = df_Y.copy()
+print(df_X.head(10))
+print(df_Y.head(10))
+print(df_X.shape)
+print(df_Y.shape)
+
+
+print(df_X_copy.head(10))
+
+print(type(df_X["date_time"][0]))
+
+print(df_X_copy.info(), df_Y_copy.info())
+
+print(df_X_copy.describe())
+
+print(df_X_copy.shape[0]/60)
+
+print(df_X_copy.isnull().sum()/df_X_copy.shape[0]*100)
+print(df_X_copy.isnull().sum())
+
+df_X_copy["date_hour"] = df_X_copy["date_time"].apply(lambda x: x.strftime("%d-%m-%Y-%H"))
+print(df_X_copy.head())
+
+L = list(df_X_copy.groupby("date_hour"))
+df_X_copy.hist(bins=100,figsize=(10,12),grid=False)
+#plt.show()
+
+l = len(L)
+print(l)
+
+List = []
+
+for i in range(l):
+    dh = L[i][1]["date_hour"].iloc[0]
+    row = L[i][1].drop(["date_time", "date_hour"], axis=1).to_numpy().flatten().tolist()
+    row.append(dh)
+    List.append(row)
+    if (i+1)%2000 == 0:
+        print("Processing: %.4f%%"%(100*(i+1)/l))
+
+df = pd.DataFrame(List)
+print(df[1020])
+df["date_hour"] = df[1020]
+
+

main.py

@@ -0,0 +1,43 @@
+"""
+Author: İlter Gökberk Özel 12/06/2023 11:40
+Summary: This program's main purpose is to determine the tool to give the offset to correct CNC process.
+
+"""
+
+#Libraries
+import numpy as np
+import pandas as pd
+from matplotlib import pyplot as plt
+import seaborn as sbn
+
+
+#Main Class
+class OffsetCorrection():
+    def __init__(self):
+        print("OffsetCorrection Initilized!")
+    @staticmethod
+    def x():
+        pass
+
+
+#Child Classes
+
+class Line(OffsetCorrection):
+    def __init__(self):
+        pass
+
+class Circle(OffsetCorrection):
+    def __init__(self):
+        pass
+
+    def A(self):
+        pass
+class Square(OffsetCorrection):
+    def __init__(self):
+        pass
+def main():
+    #Initilize
+    OSC = OffsetCorrection()
+if __name__=='__main__':
+    main()
+