create a step by step guide for technical newbies, which describes how and where to download a totally independent, locally run, uncensored AI with visual and speech output.

Creating a totally independent and locally run AI with visual and speech output can be complex, especially for technical newbies. Below is a step-by-step guide to help you through the process. This guide will cover setting up a basic open-source software environment to run an AI like Chatbot and some visual/speech integration.

### Step 1: System Requirements
Before you begin, ensure your computer meets the following minimum requirements:
- **Operating System**: Windows 10/11, macOS, or a recent version of Linux
- **RAM**: At least 8GB (16GB recommended)
- **CPU**: Dual-core processor or better
- **Disk Space**: At least 5 GB free

### Step 2: Install Python
Most AI software is built using Python. Here’s how to install Python:

1. **Download Python**:
   - Go to the [official Python website](https://www.python.org/downloads/).
   - Choose the version compatible with your OS (preferably the latest stable version).
   
2. **Install Python**:
   - Run the installer.
   - Ensure you check the box that says "Add Python to PATH."
   - Complete the installation.

### Step 3: Install Git
Git helps you to clone repositories of AI models using version control.

1. **Download Git**:
   - Go to the [official Git website](https://git-scm.com/downloads).
   
2. **Install Git**:
   - Follow the instructions based on your OS to install.

### Step 4: Clone the AI Repository
We will use a simple AI model such as GPT-2. We will run it locally without relying on any external servers.

1. **Open a Terminal/Command Prompt**:
   - Windows: Press `Win + R`, type `cmd`, and press Enter.
   - macOS: Press `Command + Space`, type `Terminal`, and press Enter.
   - Linux: Open the terminal from the applications menu.

2. **Clone the repository**:
   - Type the following command to clone the GPT-2 repository:
     ```bash
     git clone https://github.com/openai/gpt-2.git
     ```

3. **Change into the cloned directory**:
   ```bash
   cd gpt-2
   ```

### Step 5: Set Up a Python Virtual Environment
Creating a virtual environment helps you manage dependencies.

1. **Install Virtualenv**:
   ```bash
   pip install virtualenv
   ```

2. **Create a virtual environment**:
   ```bash
   virtualenv venv
   ```

3. **Activate the virtual environment**:
   - **Windows**:
     ```bash
     venv\Scripts\activate
     ```
   - **macOS/Linux**:
     ```bash
     source venv/bin/activate
     ```

### Step 6: Install Required Libraries
Now, you need to install the libraries required to run the AI model.

1. **Install libraries**:
   ```bash
   pip install -r requirements.txt
   ```

### Step 7: Download the GPT-2 Model
Now that the environment is set up, you need to download the model files.

1. **Download the model** (example for the small model):
   ```bash
   python download_model.py 124M
   ```

### Step 8: Running the AI Locally
You can run the model using Python scripts. 

1. **Run the AI model**:
   ```bash
   python src/interactive_conditional_samples.py --model_name 124M
   ```

### Step 9: Adding Visual Output
To add visual output, you need to create a simple GUI. You can use libraries like Tkinter or PyQt. Here’s a simple example using Tkinter.

1. **Install Tkinter** (if not already installed):
   - This usually comes bundled with Python installations. If not, you can find instructions [here](https://tkdocs.com/tutorial/install.html).
  
2. **Create a simple GUI**:
   ```python
   import tkinter as tk
   from tkinter import messagebox

   def show_response(response):
       messagebox.showinfo("AI Response", response)

   def get_input():
       user_input = entry.get()
       response = run_ai_function(user_input)  # Placeholder for the AI function.
       show_response(response)

   # Basic GUI
   root = tk.Tk()
   root.title('AI Chatbot')

   entry = tk.Entry(root)
   entry.pack()

   button = tk.Button(root, text="Submit", command=get_input)
   button.pack()

   root.mainloop()
   ```

### Step 10: Adding Speech Output
For speech output, you can use the `gTTS` (Google Text-to-Speech) library.

1. **Install gTTS**:
   ```bash
   pip install gTTS
   ```

2. **Integrate speech output**:
   Modify the `show_response` function:
   ```python
   from gtts import gTTS
   import os

   def show_response(response):
       # Speak the response
       tts = gTTS(text=response, lang='en')
       tts.save("response.mp3")
       os.system("start response.mp3")  # Use 'afplay' for macOS and 'xdg-open' for Linux
   ```

### Conclusion
That’s it! You now have a locally run AI with visual and speech output. Keep in mind that running a more advanced AI model might require more setup and resources, but this guide provides a good starting point for experimentation. Don't hesitate to explore more complex models and libraries as you become more comfortable with the basics!