# Umlimit ai frame
## Here's a demonstration of a simple AI using a decision tree classifier with Python and the `scikit-learn` library. The example demonstrates how to train a model, evaluate its performance, and predict new data.
#### Install Required Libraries:
First, make sure you have `scikit-learn` and `matplotlib` installed. You can do so by running the following command:
```
pip install scikit-learn matplotlib
```
## Example Code: Decision Tree Classification
```python
# Import necessary libraries
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
# Load the Iris dataset
data = load_iris()
X = data.data # Features
y = data.target # Labels
# Split the dataset into training and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Create a Decision Tree Classifier
clf = DecisionTreeClassifier(random_state=42)
# Train the model
clf.fit(X_train, y_train)
# Make predictions
y_pred = clf.predict(X_test)
# Evaluate the model
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy * 100:.2f}%")
# Display the confusion matrix
conf_matrix = confusion_matrix(y_test, y_pred)
print("\nConfusion Matrix:")
print(conf_matrix)
# Display the classification report
print("\nClassification Report:")
print(classification_report(y_test, y_pred))
# Visualize the Decision Tree
from sklearn.tree import plot_tree
plt.figure(figsize=(15, 10))
plot_tree(clf, filled=True, feature_names=data.feature_names, class_names=data.target_names)
plt.title("Decision Tree for Iris Dataset")
plt.show()
```
## Explanation of the Code:
1. **Import Libraries**: We import `numpy`, `matplotlib`, and relevant `scikit-learn` modules, such as `DecisionTreeClassifier`, `train_test_split`, etc., to load the dataset, train the model, evaluate results, and visualize the decision tree.
2. **Load Dataset**: We use the built-in Iris dataset from `scikit-learn`, which contains 150 samples divided into three classes with four features each.
3. **Data Splitting**: The dataset is split into 70% training data and 30% test data for training the model and evaluating its performance.
4. **Train the Model**: We use the `DecisionTreeClassifier` to train the model, generating a classification model.
5. **Evaluate the Model**: We calculate accuracy, display the confusion matrix, and generate a classification report to evaluate the model's performance.
6. **Decision Tree Visualization**: We use the `plot_tree` function to visualize the decision tree, helping to understand how the model makes its decisions.
## Sample Output:
```lua
Accuracy: 97.78%
Confusion Matrix:
[[14 0 0]
[ 0 17 1]
[ 0 0 13]]
Classification Report:
precision recall f1-score support
0 1.00 1.00 1.00 14
1 1.00 0.94 0.97 18
2 0.93 1.00 0.96 13
accuracy 0.98 45
macro avg 0.98 0.98 0.98 45
weighted avg 0.98 0.98 0.98 45
```
## Code Explanation:
* **Accuracy**: The percentage of correct predictions made by the model on the test set.
* **Confusion Matrix**: A matrix showing the true labels versus the predicted labels by the model.
* **Classification Report**: Precision, recall, and F1-score for each class in the dataset.
* **Decision Tree Visualization**: This part generates and displays a simple decision tree graph, showing how the model makes decisions based on the features.
### Summary:
This is a simple AI demonstration using a decision tree classifier to classify the Iris dataset. It showcases how to train the model, evaluate its performance, and visualize the decision tree. You can apply similar steps with your own datasets and modify hyperparameters for optimization.
{% hint style="success" %}
This is a simple AI demonstration using a **decision** tree classifier to classify the Iris dataset.
{% endhint %}
##
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://unlimit-ai.gitbook.io/unlimitforai/umlimit-ai/markdown.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
