Fahd Mirza on AI, Cloud, DevOps and Databases

NemoClaw Tutorial: Run Locally with Free Local Models: Easy Guide

2026-03-18T21:42:00.000-07:00

This video locally installs NemoClaw with OpenShell and vllm Qwen3.5 9B.

Run Microsoft VibeVoice TTS Locally on CPU

2025-09-04T14:25:00.000-07:00

In this tutorial, I install the Microsoft VibeVoice model locally and test.

app.py:

"""

VibeVoice with Fahd Mirza

"""

import argparse

import os

import tempfile

import time

import threading

import subprocess

import numpy as np

import gradio as gr

import librosa

import soundfile as sf

import torch

from pathlib import Path

from typing import Iterator, Dict, Any

# Clone and setup VibeVoice if not already present

vibevoice_dir = Path('./VibeVoice')

if not vibevoice_dir.exists():

print("Cloning VibeVoice repository...")

subprocess.run(['git', 'clone', 'https://github.com/vibevoice-community/VibeVoice'], check=True)

print("Installing VibeVoice...")

subprocess.run(['pip', 'install', '-e', './VibeVoice'], check=True)

print("Installing wheel (required for flash-attn)...")

subprocess.run(['pip', 'install', 'wheel'], check=True)

print("Installing flash-attn...")

try:

subprocess.run(['pip', 'install', 'flash-attn', '--no-build-isolation'], check=True)

except subprocess.CalledProcessError:

print("Warning: flash-attn installation failed. Continuing without it...")

# Add the VibeVoice directory to path

import sys

sys.path.insert(0, str(vibevoice_dir))

# Import VibeVoice modules

try:

from vibevoice.modular.configuration_vibevoice import VibeVoiceConfig

from vibevoice.modular.modeling_vibevoice_inference import VibeVoiceForConditionalGenerationInference

from vibevoice.processor.vibevoice_processor import VibeVoiceProcessor

from vibevoice.modular.streamer import AudioStreamer

except ImportError:

try:

import importlib.util

def load_module(module_name, file_path):

spec = importlib.util.spec_from_file_location(module_name, file_path)

module = importlib.util.module_from_spec(spec)

sys.modules[module_name] = module

spec.loader.exec_module(module)

return module

config_module = load_module(

"vibevoice_config",

vibevoice_dir / "modular" / "configuration_vibevoice.py"

)

VibeVoiceConfig = config_module.VibeVoiceConfig

model_module = load_module(

"vibevoice_model",

vibevoice_dir / "modular" / "modeling_vibevoice_inference.py"

)

VibeVoiceForConditionalGenerationInference = model_module.VibeVoiceForConditionalGenerationInference

processor_module = load_module(

"vibevoice_processor",

vibevoice_dir / "processor" / "vibevoice_processor.py"

)

VibeVoiceProcessor = processor_module.VibeVoiceProcessor

streamer_module = load_module(

"vibevoice_streamer",

vibevoice_dir / "modular" / "streamer.py"

)

AudioStreamer = streamer_module.AudioStreamer

except Exception as e:

raise ImportError(

f"VibeVoice module not found. Error: {e}\n"

"Please ensure VibeVoice is properly installed:\n"

"git clone https://github.com/vibevoice-community/VibeVoice\n"

"cd VibeVoice/\n"

"pip install -e .\n"

)

from transformers.utils import logging

from transformers import set_seed

logging.set_verbosity_info()

logger = logging.get_logger(__name__)

class VibeVoiceChat:

def __init__(self, model_path: str, device: str = "cuda", inference_steps: int = 5):

"""Initialize the VibeVoice chat model."""

self.model_path = model_path

self.device = device if torch.cuda.is_available() else "cpu"

self.inference_steps = inference_steps

self.is_generating = False

self.stop_generation = False

self.current_streamer = None

# Check GPU availability and CUDA version

if torch.cuda.is_available():

print(f"✓ GPU detected: {torch.cuda.get_device_name(0)}")

print(f" Memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.2f} GB")

print(f" CUDA Version: {torch.version.cuda}")

print(f" PyTorch CUDA: {torch.cuda.is_available()}")

# Set memory fraction to avoid OOM

torch.cuda.set_per_process_memory_fraction(0.95)

# Enable TF32 for faster computation on Ampere GPUs

torch.backends.cuda.matmul.allow_tf32 = True

torch.backends.cudnn.allow_tf32 = True

else:

print("✗ No GPU detected, using CPU (generation will be VERY slow)")

print(" For faster generation, ensure CUDA is properly installed")

self.load_model()

self.setup_voice_presets()

def load_model(self):

"""Load the VibeVoice model and processor."""

print(f"Loading model from {self.model_path}")

start_time = time.time()

self.processor = VibeVoiceProcessor.from_pretrained(self.model_path)

if torch.cuda.is_available():

print("Loading model with GPU acceleration...")

try:

self.model = VibeVoiceForConditionalGenerationInference.from_pretrained(

self.model_path,

torch_dtype=torch.bfloat16,

device_map='cuda:0',

attn_implementation="flash_attention_2",

low_cpu_mem_usage=True,

)

print("✓ Flash Attention 2 enabled for faster generation")

except Exception as e:

print(f"Warning: Could not load with flash_attention_2: {e}")

print("Falling back to standard attention...")

self.model = VibeVoiceForConditionalGenerationInference.from_pretrained(

self.model_path,

torch_dtype=torch.bfloat16,

device_map='cuda:0',

low_cpu_mem_usage=True,

)

else:

print("Loading model on CPU (this will be slow)...")

self.model = VibeVoiceForConditionalGenerationInference.from_pretrained(

self.model_path,

torch_dtype=torch.float32,

device_map='cpu',

low_cpu_mem_usage=True,

)

self.model.eval()

# Configure noise scheduler for faster inference

self.model.model.noise_scheduler = self.model.model.noise_scheduler.from_config(

self.model.model.noise_scheduler.config,

algorithm_type='sde-dpmsolver++',

beta_schedule='squaredcos_cap_v2'

)

self.model.set_ddpm_inference_steps(num_steps=self.inference_steps)

load_time = time.time() - start_time

print(f"✓ Model loaded in {load_time:.2f} seconds")

# Print model device

if hasattr(self.model, 'device'):

print(f"Model device: {self.model.device}")

def setup_voice_presets(self):

"""Setup voice presets from the voices directory."""

voices_dir = os.path.join(os.path.dirname(__file__), "voices")

# Create voices directory if it doesn't exist

if not os.path.exists(voices_dir):

os.makedirs(voices_dir)

print(f"Created voices directory at {voices_dir}")

print("Please add voice sample files (.wav, .mp3, etc.) to this directory")

self.available_voices = {}

audio_extensions = ('.wav', '.mp3', '.flac', '.ogg', '.m4a', '.aac')

# Scan for audio files

for file in os.listdir(voices_dir):

if file.lower().endswith(audio_extensions):

name = os.path.splitext(file)[0]

self.available_voices[name] = os.path.join(voices_dir, file)

# Sort voices alphabetically

self.available_voices = dict(sorted(self.available_voices.items()))

if not self.available_voices:

print(f"Warning: No voice files found in {voices_dir}")

print("Using default (zero) voice samples. Add audio files to the voices directory for better results.")

# Add a default "None" option

self.available_voices = {"Default": None}

else:

print(f"Found {len(self.available_voices)} voice presets: {', '.join(self.available_voices.keys())}")

def read_audio(self, audio_path: str, target_sr: int = 24000) -> np.ndarray:

"""Read and preprocess audio file."""

try:

wav, sr = sf.read(audio_path)

if len(wav.shape) > 1:

wav = np.mean(wav, axis=1)

if sr != target_sr:

wav = librosa.resample(wav, orig_sr=sr, target_sr=target_sr)

return wav

except Exception as e:

print(f"Error reading audio {audio_path}: {e}")

return np.zeros(24000) # Return 1 second of silence as fallback

def format_script(self, message: str, num_speakers: int = 2) -> str:

"""Format input message into a script with speaker assignments."""

lines = message.strip().split('\n')

formatted_lines = []

for i, line in enumerate(lines):

line = line.strip()

if not line:

continue

# Check if already formatted

if line.startswith('Speaker ') and ':' in line:

formatted_lines.append(line)

else:

# Auto-assign speakers in rotation

speaker_id = i % num_speakers

formatted_lines.append(f"Speaker {speaker_id}: {line}")

return '\n'.join(formatted_lines)

def generate_audio_stream(

self,

message: str,

history: list,

voice_1: str,

voice_2: str,

num_speakers: int,

cfg_scale: float

) -> Iterator[tuple]:

"""Generate audio stream from text input."""

try:

self.stop_generation = False

self.is_generating = True

# Validate inputs

if not message.strip():

yield None

return

# Format the script

formatted_script = self.format_script(message, num_speakers)

print(f"Formatted script:\n{formatted_script}")

print(f"Using device: {self.device}")

# Start timing

start_time = time.time()

# Select voices based on number of speakers

selected_voices = []

if voice_1 and voice_1 != "Default":

selected_voices.append(voice_1)

if num_speakers > 1 and voice_2 and voice_2 != "Default":

selected_voices.append(voice_2)

# Load voice samples

voice_samples = []

for i in range(num_speakers):

# Use the appropriate voice for each speaker

if i < len(selected_voices):

voice_name = selected_voices[i]

if voice_name in self.available_voices and self.available_voices[voice_name]:

audio_data = self.read_audio(self.available_voices[voice_name])

else:

audio_data = np.zeros(24000) # Default silence

else:

# Use first voice or default if not enough voices selected

if selected_voices and selected_voices[0] in self.available_voices and self.available_voices[selected_voices[0]]:

audio_data = self.read_audio(self.available_voices[selected_voices[0]])

else:

audio_data = np.zeros(24000) # Default silence

voice_samples.append(audio_data)

print(f"Loaded {len(voice_samples)} voice samples")

# Process inputs

inputs = self.processor(

text=[formatted_script],

voice_samples=[voice_samples],

padding=True,

return_tensors="pt",

return_attention_mask=True,

)

# Move to device and ensure correct dtype

if self.device == "cuda":

inputs = {k: v.to(self.device) if torch.is_tensor(v) else v for k, v in inputs.items()}

print(f"✓ Inputs moved to GPU")

# Check GPU memory

if torch.cuda.is_available():

print(f"GPU memory allocated: {torch.cuda.memory_allocated() / 1e9:.2f} GB")

# Create audio streamer

audio_streamer = AudioStreamer(

batch_size=1,

stop_signal=None,

timeout=None

)

self.current_streamer = audio_streamer

# Start generation in separate thread

generation_thread = threading.Thread(

target=self._generate_with_streamer,

args=(inputs, cfg_scale, audio_streamer)

)

generation_thread.start()

# Wait briefly for generation to start

time.sleep(1)

# Stream audio chunks

sample_rate = 24000

audio_stream = audio_streamer.get_stream(0)

all_audio_chunks = []

chunk_count = 0

for audio_chunk in audio_stream:

if self.stop_generation:

audio_streamer.end()

break

chunk_count += 1

# Convert to numpy

if torch.is_tensor(audio_chunk):

if audio_chunk.dtype == torch.bfloat16:

audio_chunk = audio_chunk.float()

audio_np = audio_chunk.cpu().numpy().astype(np.float32)

else:

audio_np = np.array(audio_chunk, dtype=np.float32)

# Ensure 1D

if len(audio_np.shape) > 1:

audio_np = audio_np.squeeze()

# Convert to 16-bit

audio_16bit = self.convert_to_16_bit_wav(audio_np)

all_audio_chunks.append(audio_16bit)

# Yield accumulated audio

if all_audio_chunks:

complete_audio = np.concatenate(all_audio_chunks)

yield (sample_rate, complete_audio)

# Wait for generation to complete

generation_thread.join(timeout=5.0)

# Final yield with complete audio

if all_audio_chunks:

complete_audio = np.concatenate(all_audio_chunks)

generation_time = time.time() - start_time

audio_duration = len(complete_audio) / sample_rate

print(f"✓ Generation complete:")

print(f" Time taken: {generation_time:.2f} seconds")

print(f" Audio duration: {audio_duration:.2f} seconds")

print(f" Real-time factor: {audio_duration/generation_time:.2f}x")

yield (sample_rate, complete_audio)

self.current_streamer = None

self.is_generating = False

except Exception as e:

print(f"Error in generation: {e}")

import traceback

traceback.print_exc()

self.is_generating = False

self.current_streamer = None

yield None

def _generate_with_streamer(self, inputs, cfg_scale, audio_streamer):

"""Helper method to run generation with streamer."""

try:

def check_stop():

return self.stop_generation

# Use torch.cuda.amp for mixed precision if available

if self.device == "cuda" and torch.cuda.is_available():

with torch.cuda.amp.autocast(dtype=torch.bfloat16):

outputs = self.model.generate(

**inputs,

max_new_tokens=None,

cfg_scale=cfg_scale,

tokenizer=self.processor.tokenizer,

generation_config={'do_sample': False},

audio_streamer=audio_streamer,

stop_check_fn=check_stop,

verbose=False,

refresh_negative=True,

)

else:

outputs = self.model.generate(

**inputs,

max_new_tokens=None,

cfg_scale=cfg_scale,

tokenizer=self.processor.tokenizer,

generation_config={'do_sample': False},

audio_streamer=audio_streamer,

stop_check_fn=check_stop,

verbose=False,

refresh_negative=True,

)

except Exception as e:

print(f"Error in generation thread: {e}")

import traceback

traceback.print_exc()

audio_streamer.end()

def convert_to_16_bit_wav(self, data):

"""Convert audio data to 16-bit WAV format."""

if torch.is_tensor(data):

data = data.detach().cpu().numpy()

data = np.array(data)

if np.max(np.abs(data)) > 1.0:

data = data / np.max(np.abs(data))

data = (data * 32767).astype(np.int16)

return data

def stop_audio_generation(self):

"""Stop the current audio generation."""

self.stop_generation = True

if self.current_streamer:

try:

self.current_streamer.end()

except:

pass

def create_chat_interface(chat_instance: VibeVoiceChat):

"""Create a simplified Gradio ChatInterface for VibeVoice."""

# Get available voices

voice_options = list(chat_instance.available_voices.keys())

if not voice_options:

voice_options = ["Default"]

default_voice_1 = voice_options[0] if len(voice_options) > 0 else "Default"

default_voice_2 = voice_options[1] if len(voice_options) > 1 else voice_options[0]

# Define the chat function that returns audio

def chat_fn(message: str, history: list, voice_1: str, voice_2: str, num_speakers: int, cfg_scale: float):

"""Process chat message and generate audio response."""

# Extract text from message

if isinstance(message, dict):

text = message.get("text", "")

else:

text = message

if not text.strip():

return ""

try:

# Generate audio stream

audio_generator = chat_instance.generate_audio_stream(

text, history, voice_1, voice_2, num_speakers, cfg_scale

)

# Collect all audio data

audio_data = None

for audio_chunk in audio_generator:

if audio_chunk is not None:

audio_data = audio_chunk

# Return audio file path or error message

if audio_data:

# Save audio to temporary file

with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:

sample_rate, audio_array = audio_data

sf.write(tmp_file.name, audio_array, sample_rate)

# Return the file path directly

return tmp_file.name

else:

return "Failed to generate audio"

except Exception as e:

print(f"Error in chat_fn: {e}")

import traceback

traceback.print_exc()

return f"Error: {str(e)}"

# Create the interface using Blocks for more control

with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="purple"), fill_height=True) as interface:

gr.Markdown("# 🎙️ VibeVoice Chat\nGenerate natural dialogue audio with AI voices")

with gr.Row():

with gr.Column(scale=1):

gr.Markdown("### Voice & Generation Settings")

voice_1 = gr.Dropdown(

choices=voice_options,

value=default_voice_1,

label="Voice 1",

info="Select voice for Speaker 0"

)

voice_2 = gr.Dropdown(

choices=voice_options,

value=default_voice_2,

label="Voice 2",

info="Select voice for Speaker 1 (if using multiple speakers)"

)

num_speakers = gr.Slider(

minimum=1,

maximum=2,

value=2,

step=1,

label="Number of Speakers",

info="Number of speakers in the dialogue"

)

cfg_scale = gr.Slider(

minimum=1.0,

maximum=2.0,

value=1.3,

step=0.05,

label="CFG Scale",

info="Guidance strength (higher = more adherence to text)"

)

with gr.Column(scale=2):

chatbot = gr.Chatbot(

label="Conversation",

height=400,

type="messages",

elem_id="chatbot"

)

msg = gr.Textbox(

label="Message",

placeholder="Type your message or paste a script...",

lines=3

)

audio_output = gr.Audio(

label="Generated Audio",

type="filepath",

autoplay=True,

visible=False

)

with gr.Row():

submit = gr.Button("🎵 Generate Audio", variant="primary")

clear = gr.Button("🗑️ Clear")

# Example messages

gr.Examples(

examples=[

"Hello! How are you doing today?",

"Speaker 0: Welcome to our podcast!\nSpeaker 1: Thanks for having me!",

"Tell me an interesting fact about space.",

"What's your favorite type of music and why?",

inputs=msg,

label="Example Messages"

)

# Set up event handlers

def process_and_display(message, history, voice_1, voice_2, num_speakers, cfg_scale):

"""Process message and update both chatbot and audio."""

# Add user message to history

history = history or []

history.append({"role": "user", "content": message})

# Generate audio

audio_path = chat_fn(message, history, voice_1, voice_2, num_speakers, cfg_scale)

# Add assistant response with audio

if audio_path and audio_path.endswith('.wav'):

history.append({"role": "assistant", "content": f"🎵 Audio generated successfully"})

return history, audio_path, gr.update(visible=True), ""

else:

history.append({"role": "assistant", "content": audio_path or "Failed to generate audio"})

return history, None, gr.update(visible=False), ""

submit.click(

fn=process_and_display,

inputs=[msg, chatbot, voice_1, voice_2, num_speakers, cfg_scale],

outputs=[chatbot, audio_output, audio_output, msg],

queue=True

)

msg.submit(

fn=process_and_display,

inputs=[msg, chatbot, voice_1, voice_2, num_speakers, cfg_scale],

outputs=[chatbot, audio_output, audio_output, msg],

queue=True

)

clear.click(lambda: ([], None, gr.update(visible=False)), outputs=[chatbot, audio_output, audio_output])

return interface

def parse_args():

parser = argparse.ArgumentParser(description="VibeVoice Chat Interface")

parser.add_argument(

"--model_path",

type=str,

default="microsoft/VibeVoice-1.5B",

help="Path to the VibeVoice model",

)

parser.add_argument(

"--device",

type=str,

default="cuda" if torch.cuda.is_available() else "cpu",

help="Device for inference",

)

parser.add_argument(

"--inference_steps",

type=int,

default=5,

help="Number of DDPM inference steps (lower = faster, higher = better quality)",

)

return parser.parse_args()

def main():

"""Main function to run the chat interface."""

args = parse_args()

set_seed(42)

print("🎙️ Initializing VibeVoice Chat Interface...")

# Initialize chat instance

chat_instance = VibeVoiceChat(

model_path=args.model_path,

device=args.device,

inference_steps=args.inference_steps

)

# Create interface

interface = create_chat_interface(chat_instance)

print(f"🚀 Launching chat interface")

print(f"📁 Model: {args.model_path}")

print(f"💻 Device: {chat_instance.device}")

print(f"🔢 Inference steps: {args.inference_steps}")

print(f"🎭 Available voices: {len(chat_instance.available_voices)}")

if chat_instance.device == "cpu":

print("\n⚠️ WARNING: Running on CPU - generation will be VERY slow!")

print(" For faster generation, ensure you have:")

print(" 1. NVIDIA GPU with CUDA support")

print(" 2. PyTorch with CUDA installed: pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118")

# Launch the interface

interface.queue(max_size=10).launch(

show_error=True,

quiet=False,

)

if __name__ == "__main__":

main()

Install Wan2.2 Locally with Free ComfyUI Workflow: Text-to-Video and Image-to-Video

2025-07-28T14:10:00.000-07:00

This video locally installs Wan2.2, which is the premier video foundation model.

Models :

Comfy-Org/Wan_2.2_ComfyUI_Repackaged at main

Workflow:

https://github.com/fahdmirza/comfyuiworkflows

AI Evals: Step-by-Step Tutorial for Everyone with Hands-on Demo

2025-07-07T14:42:00.000-07:00

Learn what AI evals are, why they matter, and build your first evaluation test using OpenAI's framework in under 10 minutes.

How-To Build MCP Server and Client: Step-by-Step Simple Tutorial

2025-04-04T20:38:00.000-07:00

This video is a step-by-step very simple tutorial on Anthropic's Model Context Protocol (MCP) with a hello-world and then a real-world example.

Code:

fahdmirza/mcp: Code for Easiest Tutorial on Model Context Protocol (MCP)

Qwen2.5-Omni 7B - Run Easily Locally or in Google Colab

2025-03-27T15:07:00.000-07:00

This video locally installs Qwen2.5-Omni in a jupyter notebook. You can use same commands in Google Colab, Kaggle, etc.

Code:

conda create -n qwen_omni python=3.10 -y && conda activate qwen_omni

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
pip install pillow accelerate soundfile
pip install git+https://github.com/huggingface/transformers@3a1ead0aabed473eafe527915eea8c197d424356
pip install "qwen-omni-utils[decord]" librosa ipywidgets notebook
pip install -U flash-attn --no-build-isolation

jupyter notebook

Run following commands in notebook cells:

import torch
import soundfile as sf
from transformers import Qwen2_5OmniModel, Qwen2_5OmniProcessor
from qwen_omni_utils import process_mm_info

model = Qwen2_5OmniModel.from_pretrained(
    "Qwen/Qwen2.5-Omni-7B",
    torch_dtype=torch.bfloat16,
    device_map="auto",
    attn_implementation="flash_attention_2",
    enable_audio_output=True
)

processor = Qwen2_5OmniProcessor.from_pretrained("Qwen/Qwen2.5-Omni-7B")

conversation = [
    {
        "role": "system",
        "content": "You are Qwen, a virtual human developed by the Qwen Team, Alibaba Group, capable of perceiving auditory and visual inputs, as well as generating text and speech. Please always respond in English."
    },
    {
        "role": "user",
        "content": [{"type": "video", "video": "./fahdvideo.mp4"}]
    }
]

text = processor.apply_chat_template(conversation, add_generation_prompt=True, tokenize=False)
audios, images, videos = process_mm_info(conversation, use_audio_in_video=True)

inputs = processor(text=text, audios=audios, images=images, videos=videos,
                   return_tensors="pt", padding=True).to(model.device).to(model.dtype)

with torch.no_grad():
    text_ids, audio = model.generate(**inputs, use_audio_in_video=True, spk="Chelsie")

output_text = processor.batch_decode(text_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
print("\n🌟 Qwen Omni Response:\n", output_text)

sf.write("output.wav", audio.reshape(-1).detach().cpu().numpy(), samplerate=24000)
print("\n✅ Audio saved to output.wav")

For Audio:

import librosa
from IPython.display import Audio, display

audio_path = "/home/Ubuntu/audio/cough.wav"
prompt = "Classify the given human vocal sound in English."

audio, sr = librosa.load(audio_path, sr=16000)
display(Audio(audio, rate=16000))

response = audio_inference(audio_path, 
                           prompt=prompt, 
                           sys_prompt="You are a vocal sound classification model.")
print("\n🌟 Model Response:\n", response[0])

Bring Photos to LIFE! 🗣️ Transform Single Image & Audio to Talking AI Avatar (KDTalker)

2025-03-22T18:36:00.000-07:00

🔥 "Learn to quickly install KDTalker locally and easily turn any image & audio into a realistic talking AI video!"

Code:

conda create -n KDTalker python=3.9 -y && conda activate KDTalker

git clone https://huggingface.co/ChaolongYang/KDTalker && cd KDTalker

pip install -r requirements.txt

pip install huggingface_hub

huggingface-cli login <Grab your Free Read token from huggingface.co>

huggingface-cli download ChaolongYang/KDTalker pretrained_weights

--local-dir pretrained_weights --local-dir-use-symlinks False

python inference.py \

-source_image /home/Ubuntu/images/fahdimages/fahdhd.png \

-driven_audio /home/Ubuntu/audio/chinese.wav \

-output ./results/output.mp4

Mistral Small 3.1 24B Instruct - Install Locally and Thorough Testing

2025-03-18T13:31:00.000-07:00

This video locally installs Mistral-Small-3.1-24B-Instruct-2503 and checks for various vision tasks along with others.

VLLM Code:

vllm serve mistralai/Mistral-Small-3.1-24B-Instruct-2503 --tokenizer_mode mistral --config_format mistral --load_format mistral --tool-call-parser mistral --enable-auto-tool-choice --limit_mm_per_prompt 'image=10' --tensor-parallel-size 1

Inference Code:

import requests
import json
import base64
from PIL import Image
import io

# Endpoint
url = "http://localhost:8000/v1/chat/completions"

# Headers (modify token as required)
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer token"
}

# Your model name (match exact served model)
model = "mistralai/Mistral-Small-3.1-24B-Instruct-2503"

# Minimal simple system prompt (no complicated pre-downloaded prompt)
SYSTEM_PROMPT = """
You are Mistral Small 3.1, a Large Language Model (LLM) created by Mistral AI, a French startup headquartered in Paris.
You power an AI assistant called Le Chat.
Your knowledge base was last updated on 2023-10-01.
The current date is {today}.

When you're not sure about some information, you say that you don't have the information and don't make up anything.
If the user's question is not clear, ambiguous, or does not provide enough context for you to accurately answer the question, you do not try to answer it right away and you rather ask the user to clarify their request (e.g. "What are some good restaurants around me?" => "Where are you?" or "When is the next flight to Tokyo" => "Where do you travel from?").
You are always very attentive to dates, in particular you try to resolve dates (e.g. "yesterday" is {yesterday}) and when asked about information at specific dates, you discard information that is at another date.
You follow these instructions in all languages, and always respond to the user in the language they use or request.
Next sections describe the capabilities that you have.

# WEB BROWSING INSTRUCTIONS

You cannot perform any web search or access internet to open URLs, links etc. If it seems like the user is expecting you to do so, you clarify the situation and ask the user to copy paste the text directly in the chat.

# MULTI-MODAL INSTRUCTIONS

You have the ability to read images, but you cannot generate images. You also cannot transcribe audio files or videos.

"""

prompt="""
explain this chart and which product is better?
"""
# Load and encode image correctly
with Image.open('/home/Ubuntu/images/moondream/chart.png').convert('RGB') as img:
    buffered = io.BytesIO()
    img.save(buffered, format="PNG")
    img_base64 = base64.b64encode(buffered.getvalue()).decode('utf-8')
image_data_uri = f'data:image/png;base64,{img_base64}'

# Simple user message aligned clearly to your described intention
messages = [
    {"role": "system", "content": SYSTEM_PROMPT},
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": prompt,
            },
            {
                "type": "image_url",
                "image_url": {"url": image_data_uri}
            },
        ],
    },
]

# data payload correctly specified
data = {
    "model": model,
    "messages": messages,
    "temperature": 0.15,
}

# Post request
response = requests.post(url, headers=headers, data=json.dumps(data))

# Read response
if response.status_code == 200:
    result = response.json()
    reply_message = result["choices"][0]["message"]["content"]
    print(reply_message)
else:
    print(f"Request failed: {response.status_code}, {response.text}")

Install HunyuanVideo Image to Video Locally - Create Free Private AI Videos

2025-03-06T17:13:00.000-08:00

This video locally installs HunyuanVideo-I2V, which is a new image-to-video generation model.

Models:

ComfyUI Workflow:

fahdmirza/comfyuiworkflows: Free ComfyUI Workflows

AI Web Scraping for Free with DeepSeek R1 Locally with Crawl4AI and Ollama

2025-02-06T20:19:00.000-08:00

This video shows how to do AI web-scraping with DeepSeek R1 locally with Ollama and Crawl4AI easily.

Code:

deepseekwebscraper/ at main · fahdmirza/deepseekwebscraper

Getting Data LLM-Ready with JSON in Oracle Database

2025-02-06T14:25:00.000-08:00

If you are building an AI-powered application, especially with tools and function calling you know that using JSON could greatly improve the accuracy of your application and the LLM would be able to give more grounded response. That is where this blog post is helping to show you how easy and powerful it is to use JSON with Oracle PL/SQL, which is still very much relevant in today's AI world.

Oracle Database provides native support for JavaScript Object Notation (JSON) data, allowing you to store, index, and query JSON data using standard SQL and PL/SQL.

Benefits of Using JSON in Oracle Database

Schemaless development: Quickly react to changing application requirements without needing to change storage schemas.
Flexible data analysis and reporting: Leverage the power of SQL and relational databases for complex data analysis and reporting.
Rock-solid data protection and access control: Ensure data integrity and security with Oracle Database's robust features.

JSON data can be stored, indexed, and queried without defining a schema. Oracle Database supports JSON natively, providing features like transactions, indexing, declarative querying, and views. JSON data is stored using standard SQL data types such as VARCHAR2, CLOB, and BLOB. It is recommended to use an is_json check constraint to ensure column values are valid JSON instances.

PL/SQL supports SQL code, including SQL code that accesses JSON data. You can use SQL/JSON functions and conditions as built-in PL/SQL functions.

Additionally, PL/SQL provides object types for JSON, allowing for fine-grained construction and manipulation of in-memory JSON data.

Let's say we have a JSON object that represents a list of books:

declare
  v_json      clob;
  v_parsed    json_object_t;
  v_books     json_array_t;
  v_book      json_object_t;
  v_title     varchar2(100);
  v_author    varchar2(100);
  v_price     number;

begin
  -- Load JSON Data
  v_json := '{
    "books": [
      {
        "title": "Book 1",
        "author": "Author 1",
        "price": 10.99
      },
      {
        "title": "Book 2",
        "author": "Author 2",
        "price": 9.99
      },
      {
        "title": "Book 3",
        "author": "Author 3",
        "price": 12.99
      }
    ]
  }';

  -- Parse JSON
  v_parsed := json_object_t.parse(v_json);
  v_books := v_parsed.get_array('books');

  -- Loop through books
  for i in 1 .. v_books.get_size
  loop
    v_book := v_books.get_object(i);
    v_title := v_book.get_string('title');
    v_author := v_book.get_string('author');
    v_price := v_book.get_number('price');

    -- Output book details
    dbms_output.put_line(v_title || ' by ' || v_author || ', Price: ' || v_price);
  end loop;
end;
/

The output of this script would be:

Book 1 by Author 1, Price: 10.99
Book 2 by Author 2, Price: 9.99
Book 3 by Author 3, Price: 12.99

By leveraging Oracle Database's native support for JSON data, you can efficiently store, query, and analyze JSON data using standard SQL and PL/SQL.

How-To Speedup Initial Load from Oracle to SQL Server with Oracle GoldenGate 23ai

2025-02-01T23:03:00.000-08:00

Have you ever stared at your computer screen, watching the hours tick by as you wait for a massive data transfer to complete? If you're using Oracle GoldenGate to move data from an Oracle database to SQL Server, you might know the feeling all too well—especially when you're dealing with something like 200 million rows that take way too long. Let’s dive into how Oracle GoldenGate works and some simple tricks to speed up that initial load time.

What is Oracle GoldenGate?

First things first—what is Oracle GoldenGate? In simple terms, it's like a super-efficient courier service that gets your data from one place to another. It specializes in real-time data integration and replication, making sure every bit of information moves swiftly and accurately from your Oracle database to whatever destination you've chosen, like SQL Server, in this case. It's especially handy for businesses that need their data synchronized quickly and continuously.

Making the Initial Load Faster

Now, onto the good part: how can you speed up the initial load that seems to take forever? The good news is that there are several strategies you can use to make the process more efficient.

Using the BATCHSQL parameter is one approach. This allows you to bundle multiple SQL insert statements together, reducing the overall time spent on these operations. Creating a unique index on your target SQL Server for inserts is another useful tip. This helps your database manage the incoming data more efficiently, cutting down on the time it takes to sort and place the records.

Splitting your data into smaller batches is also a great way to speed things up. Instead of overwhelming your system with 200 million rows all at once, use the Range function or Column Filters to divide the data into more manageable chunks. This approach is especially useful for large tables, as it allows you to tackle the data in sections rather than trying to handle it all at once.

Finally, if you're working with multiple database instances that are all on the same version, consider creating multiple extracts that can connect to these different instances. This allows you to distribute the workload across various sources, which can significantly speed up the entire process.

By implementing these strategies, you can make your initial load process faster, smoother, and less stressful. Whether you're dealing with 200 million rows or even more, these tips can help you get the job done more efficiently.

How-To Fix Poco::IOException Error During Goldengate 23ai Upgrade

2025-01-30T22:51:00.000-08:00

I recently upgraded Oracle GoldenGate 23ai. In this post, I'll share my experience and provide a step-by-step guide on how to upgrade Oracle GoldenGate 23ai using the GUI and especially a weird error which I received during this upgrade which is as follows:

Error:

Operating system character set identified as UTF-8.
terminate called after throwing an instance of 'Poco::IOException'
what(): I/O error

If you want TLDR; then I had to apply patch 27788241 to get this resolved. For details, keep reading on.

To start the upgrade, I downloaded the latest Oracle GoldenGate 23ai software from the Oracle Technology Network or eDelivery. Then, I moved the software to a staging folder and unzipped it.

For Linux users, the commands are:

$ mv /home/user/fbo_ggs_Linux_x64_Oracle_services_shiphome.zip /tmp
$ cd /tmp
$ unzip fbo_ggs_Linux_x64_Oracle_services_shiphome.zip

Next, I uploaded the Oracle GoldenGate 23ai software to a staging location on the server where the previous release of Oracle GoldenGate existed.

Upgrading the Service Manager

After installing the latest Oracle GoldenGate 23ai version, I upgraded the Service Manager. I logged into the Service Manager using the URL: https://hostname:servicemanager_port.

From the Service Manager Overview page, I selected the ServiceManager link in the Deployments section. Then, I clicked the pencil icon next to the Deployment Detail section to open the dialog box for editing the GoldenGate home path.

I updated the GoldenGate Home path with the full path to the new Oracle GoldenGate 23ai home and clicked Apply. Finally, I restarted the Service Manager using the Action dropdown.

Upgrading the Deployment

To upgrade the deployment, I stopped all Extract and Replicat processes. I checked for open transactions and Bounded Recovery.

Then, I updated the deployment with the location of the new Oracle GoldenGate 23ai Home directory. I edited the deployment details and updated the Oracle GoldenGate 23ai Home path.

Resolving the Error

During the upgrade, I got this error:

Operating system character set identified as UTF-8.
terminate called after throwing an instance of 'Poco::IOException'
what(): I/O error

After researching, I found that applying patch 27788241 fixed the issue. I applied the patch, and the upgrade completed successfully.

Hope this helps.

DeepSeek R1 Coding Examples - Easy Tutorial for Beginners and Experts

2025-01-26T17:16:00.000-08:00

This video gives a hands-on tutorial to use DeepSeek R1 model in code for various use-cases.

Code:

fahdmirza/deepseekr1: This repo contains examples of using DeepSeek R1 Reasoner model in Python Code with API

Oracle Scheduler SQL Cheat Sheet

2025-01-21T19:42:00.000-08:00

Oracle Scheduler is a built-in job scheduler in Oracle Database that enables you to manage and execute various tasks, such as running database program units, external executables, and scripts. It provides a flexible and sophisticated way to schedule jobs based on time, events, or dependencies, allowing you to automate routine tasks and reduce manual intervention.

The Scheduler offers advanced features, including prioritization of jobs based on business requirements, resource allocation, and monitoring of job execution. It also supports execution of jobs in a clustered environment, such as Oracle Real Application Clusters (Oracle RAC). With Oracle Scheduler, you can streamline your database operations, improve reliability, and reduce operating costs.

You can use following SQLs to manage your Scheduler and the jobs:

Check Scheduler Job Details in CDB
SQL
-- View job details in the Container Database (CDB)
SELECT 
  CON_ID, 
  JOB_NAME, 
  JOB_TYPE, 
  ENABLED, 
  STATE, 
  NEXT_RUN_DATE, 
  REPEAT_INTERVAL 
FROM 
  cdb_scheduler_jobs;
Monitor Currently Running Jobs
SQL
-- View currently running jobs
SELECT 
  job_name, 
  session_id, 
  running_instance, 
  elapsed_time 
FROM 
  dba_scheduler_running_jobs;
View Job Run Details
SQL
-- View details of job runs
SELECT 
  * 
FROM 
  DBA_SCHEDULER_JOB_RUN_DETAILS;
View Job-Related Logs
SQL
-- View logs related to job execution
SELECT 
  * 
FROM 
  DBA_SCHEDULER_JOB_LOG;
Check All Scheduler Schedules
SQL
-- Set formatting options for output
SET PAGESIZE 200
SET LINES 299
COL START_DATE FOR A45
COL REPEAT_INTERVAL FOR A45
COL schedule_name FOR A34

-- View all scheduler schedules
SELECT 
  schedule_name, 
  schedule_type, 
  start_date, 
  repeat_interval 
FROM 
  dba_scheduler_schedules;
History of All Scheduler Job Runs
SQL
-- Set formatting options for output
SET PAGESIZE 299
SET LINES 299
COL JOB_NAME FOR A24
COL actual_start_date FOR A56
COL RUN_DURATION FOR A34

-- View history of all scheduler job runs
SELECT 
  job_name, 
  status, 
  actual_start_date, 
  run_duration 
FROM 
  DBA_SCHEDULER_JOB_RUN_DETAILS 
ORDER BY 
  ACTUAL_START_DATE DESC;
Check Log Information for All Scheduler Jobs
SQL
-- Set formatting options for output
SET PAGESIZE 299
SET LINES 299
COL job_name FOR A24
COL log_date FOR A40
COL operation FOR A19
COL additional_info A79

-- View log information for all scheduler jobs
SELECT 
  job_name, 
  log_date, 
  status, 
  OPERATION, 
  ADDITIONAL_INFO 
FROM 
  dba_scheduler_job_log 
ORDER BY 
  log_date DESC;
Check All Scheduler Windows Details
SQL
-- Set formatting options for output
SET PAGESIZE 300
SET LINESIZE 200

-- View all scheduler windows details
SELECT 
  * 
FROM 
  dba_scheduler_windows;

SOLVED - ORA-20000: ORA-24247: Network access denied by access control list (ACL) with Select AI

2025-01-14T22:11:00.000-08:00

I have been experimenting with Oracle Select AI for couple of months now and it has become one of my favorite tool. The other day, I encountered an error while playing with it and it took me sometime to find a fix, so thought of sharing it with you guys.

If you don't know what Oracle Select AI is, here is a quick simple intro:

Oracle Select AI is a tool that lets you interact with your database using everyday language instead of complicated SQL code. It uses artificial intelligence (AI) to understand what you're asking and generate the right SQL queries for you. This makes it easier for everyone, regardless of their technical expertise, to get insights from their data and develop AI-based applications.

Now we know what Oracle Select AI is, lets have a look at error:

I was trying to integrate Select AI with Oracle APEX. Oracle Application Express (Oracle APEX) is a low-code application development platform that enables users to build scalable, secure enterprise applications. It is a web-based integrated development environment (IDE) that runs as part of the Oracle Database.

But when I was trying to configure profile with OpenAI's model like following:

BEGIN

DBMS_CLOUD_AI.CREATE_PROFILE(

profile_name => 'OPENAI_ORACLE',

attributes => '{ "provider": "openai",

"credential_name": "OPENAI_CRED",

"object_list": [{"owner": "SCOTT", "name": "MYTABLE"}]

}',

description => 'AI profile to use OpenAI with Oracle APEX'

);

END;

I was getting following error:

ORA-20000: ORA-24247: Network access denied by access control list (ACL)

ORA-06512: en "C##CLOUD$SERVICE.DBMS_CLOUD$PDBCS_240705_0", línea 2064

ORA-06512: en "C##CLOUD$SERVICE.DBMS_CLOUD_AI", línea 5674

ORA-06512: en línea 2 Error at Line: 7 Column: 0

After much ado, it turned out that I had missed following step to grant network access:

BEGIN

DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(

HOST => 'api.openai.com',

ACE => XS$ACE_TYPE(PRIVILEGE_LIST => XS$NAME_LIST('http'),

PRINCIPAL_NAME => 'SCOTT',

PRINCIPAL_TYPE => XS_ACL.PTYPE_DB)

);

END;

As soon as I run above network ACL command, it worked like a charm.

Hope that helps.

NVIDIA SANA Model Local Installation with GUI - Step-by-Step Tutorial

2025-01-13T15:48:00.000-08:00

This video locally installs NVIDIA SANA which is a text-to-image framework that can efficiently generate images up to 4096 × 4096 resolution.

Code:

git clone https://github.com/NVlabs/Sana.git && cd Sana

./environment_setup.sh sana

pip install huggingface_hub

huggingface-cli login  <Get read token from huggingface.co also accept access to
google gemma model on huggingface>

# official online demo
DEMO_PORT=15432 \
python3 app/app_sana.py \
    --share \
    --config=configs/sana_config/1024ms/Sana_1600M_img1024.yaml \
    --model_path=hf://Efficient-Large-Model/Sana_1600M_1024px/checkpoints/Sana_1600M_1024px.pth \
    --image_size=1024
    
Access demo at http://localhost:15432

How to Use OpenAI models with Oracle Select AI

2025-01-07T21:54:00.000-08:00

If you want to use OpenAI models with Oracle databases then Oracle Select AI makes it a breeze to do so. Provided you already have an Oracle autonomous database in OCI, you can use following steps to use OpenAI's model to use natural language to query you database with LLMs from OpenAI.

Oracle Autonomous Database Select AI is a powerful tool that enables you to leverage AI capabilities directly within your database environment, and OpenAI is a leading AI model provider. Also, as OpenAI is a paid option, so you would need to grab your OpenAI's API key from platform.openai.com. By default, Oracle Select AI uses gpt-3.5-turbo (default) from OpenAI but you can select any model from below list:

gpt-3.5-turbo (default)
gpt-4o
gpt-4o-mini
gpt-4
gpt-4-0613
gpt-4-32k
gpt-4-32k-0613
gpt-3.5-turbo-0613
gpt-3.5-turbo-16k
gpt-3.5-turbo-16k-0613

Lets first create a user:

CREATE USER SCOTT IDENTIFIED BY "SelectAI25#TEST";

GRANT RESOURCE TO SCOTT;

GRANT CREATE SESSION TO SCOTT;

GRANT CREATE VIEW TO SCOTT;

GRANT CREATE TABLE TO SCOTT;

GRANT CONNECT TO SCOTT;

--Grants EXECUTE privilege to SCOTT

SQL> grant execute on DBMS_CLOUD_AI to SCOTT;

-- Grant Network ACL for OpenAI endpoint

SQL> BEGIN

DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(

host => 'api.openai.com',

ace => xs$ace_type(privilege_list => xs$name_list('http'),

principal_name => 'SCOTT',

principal_type => xs_acl.ptype_db)

);

END;

-- Create Credential for AI provider

EXEC

DBMS_CLOUD.CREATE_CREDENTIAL(

CREDENTIAL_NAME => 'OPENAI_CRED',

username => 'OPENAI',

password => '<OPENAI_API_KEY>');

-- Create AI profile

BEGIN

DBMS_CLOUD_AI.CREATE_PROFILE(

profile_name => 'OPENAI',

attributes =>'{"provider": "openai",

"credential_name": "OPENAI_CRED",

"object_list": [{"owner": "SCOTT", "name": "MYTABLE"},

"conversation": "true"

}');

END;

-- Enable AI profile in current session

SQL> EXEC DBMS_CLOUD_AI.SET_PROFILE('OPENAI');

-- Use Select AI

SQL> select ai how many rows exist in table;

SQL> select ai how many users in Jakarta are jobless;

-- You can also show the actual SQL with the result:

SQL> select ai showsql how many users in Jakarta are jobless;

How-To Create Lip Sync Video with AI - Change Any Video or Audio Locally and Free

2025-01-06T15:59:00.000-08:00

This video shows how to locally install Latent Sync AI model to lip sync any video and audio for free and in private.

Code:

git clone https://github.com/bytedance/LatentSync.git && cd LatentSync

source setup_env.sh

./inference.sh

Install NVIDIA Ingest Locally and Use it with Thousands of Documents

2025-01-03T23:24:00.000-08:00

This video shares step-by-step instructions to install NVIDIA Ingest locally and use it with PDFs, Word, and PowerPoint.

Code:

Pre-requisites:
===============

-- Install docker
-- Get NGC api key from https://ngc.nvidia.com/
-- Get Early Access from https://developer.nvidia.com/nemo-microservices-early-access/join

Phase 1= Configure NV-INGEST Server:
====================================

Step 1:

git clone https://github.com/nvidia/nv-ingest && cd nv-ingest

Step 2:

docker login nvcr.io

Username: $oauthtoken
Password: <Your NGC API Key>

Step 3:

Make sure NVIDIA is set as your default container runtime before running the docker compose command:
sudo nvidia-ctk runtime configure --runtime=docker --set-as-default

Step 4:

docker compose up


Phase 2= Configure NV-INGEST client:
====================================

Step 1:


conda create --name nv-ingest-dev --file ./conda/environments/nv_ingest_environment.yml
conda activate nv-ingest-dev

cd client
pip install .

Step 2:

nv-ingest-cli \
  --doc ./data/multimodal_test.pdf \
  --output_directory ./processed_docs \
  --task='extract:{"document_type": "pdf", "extract_method": "pdfium", "extract_tables": "true", "extract_images": "true"}' \
  --client_host=localhost \
  --client_port=7670

  
Where to find output?
======================

After the ingestion steps above have completed, you should be able to find text and image subfolders inside your processed docs folder. Each will contain JSON formatted extracted content and metadata.

  ls -R processed_docs

Oracle Select AI and DBMS_CLOUD_AI in Simple Words

2024-12-31T21:36:00.000-08:00

Oracle Select AI enables you to elevate your productivity and develop innovative AI-based applications by interacting with your database and Large Language Models (LLMs) using natural language through SQL.

Select AI leverages generative AI to automate and simplify various tasks, including:

Generating, running, and explaining SQL queries from natural language prompts
Retrieval augmented generation using vector stores
Synthetic data generation
Conversing with LLMs
Seamless Natural Language Interaction

With Select AI, Autonomous Database effortlessly converts natural language into SQL. This enables you to interact with your data using natural language prompts instead of SQL code.

Select AI serves as a productivity tool for both expert and non-expert SQL users, enabling them to:

Derive valuable insights from data without requiring extensive technical knowledge
Automate the retrieval augmented generation process
Utilize features like synthetic data generation, chat history support, and more from a SQL interface

The DBMS_CLOUD_AI package facilitates integration with user-specified LLMs, enabling natural language to SQL generation. This package provides an augmented prompt to the LLM, containing relevant database schema metadata, to generate, run, and explain SQL queries based on natural language prompts.

At the moment, following models are supported by Select AI:

meta.llama-3.1-70b-instruct (default)
meta.llama-3.1-405b-instruct
meta.llama-3.2-90b-vision-instruct
cohere.command-r-16k (deprecated)
cohere.command–r-plus (deprecated)
cohere.command-r-08-2024
cohere.command-r-plus-08-2024
GPT-4o
GPT-4
GPT-4 Turbo with Vision
GPT-3.5-Turbo
command (default)
command-nightly (experimental)
command-r
command-r-plus
command-light
Mixtral-8x7B-Instruct-v0.1 (default)
Meta-Llama-3-70B-Instruct
Qwen1.5-1.8B
claude-3-5-sonnet-20240620 (default)
claude-3-opus-20240229
claude-3-sonnet-20240229
gpt-3.5-turbo (default)
gpt-4o
gpt-4o-mini

Install Kokoro TTS Model Locally

2024-12-29T23:50:00.000-08:00

This video locally installs Kokoro which is a frontier TTS model for its size of 82 million parameters. It can be run anywhere.

!git clone https://huggingface.co/hexgrad/Kokoro-82M
%cd Kokoro-82M

!apt-get -qq -y install espeak-ng > /dev/null 2>&1
!pip install -q phonemizer torch transformers scipy munch

from models import build_model
import torch
device = 'cuda' if torch.cuda.is_available() else 'cpu'
MODEL = build_model('kokoro-v0_19.pth', device)

VOICE_NAME = [
    'af',
    'af_bella', 'af_sarah', 'am_adam', 'am_michael',
    'bf_emma', 'bf_isabella', 'bm_george', 'bm_lewis',][0]

VOICEPACK = torch.load(f'voices/{VOICE_NAME}.pt', weights_only=True).to(device)
print(f'Loaded voice: {VOICE_NAME}')

from kokoro import generate
text = "How could I know? It's an unanswerable question. Like asking an unborn child if they'll lead a good life. They haven't even been born."
audio, out_ps = generate(MODEL, text, VOICEPACK, lang=VOICE_NAME[0])

from IPython.display import display, Audio
display(Audio(data=audio, rate=24000, autoplay=True))
print(out_ps)

MagicQuill Installation on Windows, Linux, Mac for AI Image Editing for Free

2024-12-20T17:22:00.000-08:00

This video is an easy step-by-step tutorial to install MagicQuill locally on Linux, Windows, Mac.

Code:

conda create -n ai python=3.10 -y && conda activate ai

git clone --recursive https://github.com/magic-quill/MagicQuill.git && cd MagicQuill

wget -O models.zip "https://hkustconnect-my.sharepoint.com/:u:/g/personal/zliucz_connect_ust_hk/EWlGF0WfawJIrJ1Hn85_-3gB0MtwImAnYeWXuleVQcukMg?e=Gcjugg&download=1"

unzip models.zip

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

pip install gradio_magicquill-0.0.1-py3-none-any.whl

cp -f pyproject.toml MagicQuill/LLaVA/
pip install -e MagicQuill/LLaVA/

pip install -r requirements.txt

python gradio_run.py

SOLVED - Cannot Log in Oracle cloud with 2FA after Phone Change with Oracle Mobile Authenticator

2024-12-17T15:27:00.000-08:00

I have been logging in to Oracle cloud using multi-factor authentication using 2FA with Oracle Mobile Authenticator and it was going fine until I had to change my phone. Both of my phones are android and I THOUGHT that I will simply migrate the apps and keep using the accounts in my Oracle mobile authenticator same way, but it seems that after migration I lost all the accounts.

Multi-Factor Authentication (MFA) is a security process that requires a user to provide two or more authentication factors to access a system, network, or application. Two-Factor Authentication (2FA) is a type of Multi-Factor Authentication that requires a user to provide two authentication factors:

Something you know (password, PIN)
Something you have (smartphone, token, or a one-time password sent via SMS or authenticator app)

So I was using 2FA with this Oracle Mobile Authenticator. I tried with my older codes , QR codes, the password, PIN and stuff but nothing worked. No matter, what I tried I simply couldn't log in to Oracle Cloud since the page asked me for a code generated by the authenticator.

Eventually following is the only way I could find to resolve this issue:

I talked in Oracle live chat, and they asked me to find an engineer to send me a bypass code.

If you don't know what Oracle Mobile Authenticator app is then as per docs:

Oracle Mobile Authenticator enables you to securely verify your identity by using your mobile device as a authentication factor. The app generates one-time passwords for login. Or it can receive notifications for login, which can be approved with a simple tap. When this authentication is used on top of username-password, it adds an additional layer of security that is essential for today's online applications.

Features:

Generate one-time passwords even when the device is offline
Push Notification based approval
App PIN for app protection
Set up via QR code, Config URL, or by entering key manually
Multiple account support
Generate OTP for other applications that make use of One-Time Password as per RFC 6238
Generate one-time passwords even when the device is offline
Push Notification based approval
App PIN for app protection

I hope this helps.

How-To Integrate ChatGPT with Oracle Digital Assistant

2024-12-16T23:31:00.000-08:00

Oracle Digital Assistant (ODA) provides a comprehensive platform for creating conversational interfaces. This article will guide you through integrating ChatGPT with ODA using the bots-node-sdk and openai libraries.

Prerequisites:

Oracle Digital Assistant instance
ChatGPT API key
Node.js environment

Configuration:

Create a new file named services.js and add the following code:

const OracleBot = require('@oracle/bots-node-sdk');
const { WebhookClient, WebhookEvent } = OracleBot.Middleware;
const express = require('express');
const { Configuration, OpenIApi } = require("openai");

const configuration = new Configuration({
  apiKey: "YOUR_CHATGPT_API_KEY",
});

const openai = new OpenIApi(configuration);

const textGeneration = async (prompt) => {
  try {
    const response = await openai.createCompletion({
      model: 'text-davinci-003',
      prompt: `Human: ${prompt}\nAI: `,
      temperature: 0.9,
      max_tokens: 500,
      top_p: 1,
      frequency_penalty: 0,
      presence_penalty: 0.6,
      stop: ['Human:', 'AI:'],
    });
    return {
      status: 1,
      response: `${response.data.choices[0].text}`,
    };
  } catch (error) {
    return {
      status: 0,
      response: '',
    };
  }
};

module.exports = (app) => {
  const logger = console;

  // Initialize Oracle Digital Assistant
  OracleBot.init(app, {
    logger,
  });

  // Set up webhook integration
  const webhook = new WebhookClient({
    channel: {
      url: "YOUR_ODA_WEBHOOK_URL",
      secret: "YOUR_ODA_WEBHOOK_SECRET",
    },
  });

  // Handle incoming messages
  webhook.on(WebhookEvent.MESSAGE_RECEIVED, (message) => {
    const action = message.queryResult.action;
    const queryText = message.queryResult.queryText;

    if (action === 'input.unknown') {
      textGeneration(queryText).then((result) => {
        if (result.status === 1) {
          res.send({
            fulfillmentMessages: [
              {
                text: {
                  text: [result.response],
                },
              },
            ],
          });
        } else {
          res.send({
            fulfillmentMessages: [
              {
                text: {
                  text: ["Sorry, I'm not able to help with that."],
                },
              },
            ],
          });
        }
      });
    } else {
      res.send({
        fulfillmentMessages: [
          {
            text: {
              text: [`No handler for action ${action}`],
            },
          },
        ],
      });
    }
  });

  // Set up endpoint for incoming messages
  app.post('/bot/message', (req, res) => {
    const message = req.body;
    webhook.send(message).then(() => res.send('ok'));
  });
};

Replace YOUR_CHATGPT_API_KEY with your actual ChatGPT API key.
Replace YOUR_ODA_WEBHOOK_URL and YOUR_ODA_WEBHOOK_SECRET with your actual Oracle Digital Assistant webhook URL and secret.

Dialog Flow Integration

To integrate the ChatGPT service with your Oracle Digital Assistant dialog flow, follow these steps:

Create a new intent in your dialog flow with the action input.unknown.

Add a new fulfillment to the intent with the following settings:

Fulfillment type: Webhook

Webhook URL: YOUR_APP_URL/bot/message (replace with your actual app URL)

HTTP method: POST

Save and deploy your dialog flow.

Testing

Test your integration by sending a message to your Oracle Digital Assistant instance. The message should be routed to the ChatGPT service, which will generate a response. The response will then be sent back to the user.

Note: Make sure to replace the placeholder values with your actual credentials and URLs.