Página 2 de 2 PrimerPrimer 12
Resultados 11 al 13 de 13

Tema: JupyterLab vs Jupyter Notebook para Ciencia de Datos y Aprendizaje Automático

  1. #11
    Con domicilio en Noticias3d.com
    Ubicación
    Esto no es Matrix, es Kyrgyzistan
    Mensajes
    5,020

    Predeterminado Re: JupyterLab vs Jupyter Notebook para Ciencia de Datos y Aprendizaje Automático

    Ah, que era por soporte... No te preocupes, una cosa es que Dell no publique soporte (que ya no tienes por cierto, la WS es vieja, las cosas como son) y otra cosa es que no puedas. Otra cosa por supuesto es saber, aunque Debian es amigable a dia de hoy, hay que saber un poquito o estar dispuesto a echarle tiempo para aprender.

    Bueno, que si estas bien con Ubuntu, pues genial.

    Por cierto, a lo major mas que grafica, te interesa mirar otras cosas. He visto por internet que las NVidia tesla se pueden encontrar baratitas baratitas, las antiguas al menos, pero apostaria que mas modernas de segunda mano son accesibles. No se si te pudieran servir mejor que una grafica gaming
    ¿De verdad hemos quedado para esto?

  2. #12

    Predeterminado Re: JupyterLab vs Jupyter Notebook para Ciencia de Datos y Aprendizaje Automático

    Hola a todos he hecho algunos avances. Me he comprado la RTX 4060 TI de 16 GB y también he Instalado el Jupyterlab.



    Con Ubuntu la verdad es que no me desagrada. De todos modos lo utilizo como servidor y normalmente uso la consola.



    Lo que me preocupa es el uso de memoria RAM en entrenamiento. Parece que 32 Gb son pocos.



    Y lo de la grafica, creo que utiliza 14 Gb de los 16. A final mas gigas mejor. De todas formas pongo esta captura y ya me comentáis si estoy en lo cierto o no.



    Esto es todo por ahora. Si tenéis alguna pregunta o dudas al respecto, puedo hacer mas pruebas. Otra cosa, sobre las bibliotecas, hay que actualizarlas todas si no, da error. Para actualizar:

    pip install --upgrade tensorflow
    o también
    pip install --upgrade tensorflow matplotlib

    Así con todas, gracias por los concejos y la ayuda.

    Saludos a todos
    Gigabyte Aorus AX370-Gaming K7
    AMD Ryzen 7 3700X 3.6GHZ BOX
    Corsair Vengeance LPX DDR4 3200 PC4-25600 16GB 2x8GB C16
    Corsair HX850i 850W 80 Plus Platinum Modular
    Gigabyte AMD Radeon RX 6700 XT GAMING OC 12GB GDDR6

  3. #13

    Predeterminado Re: JupyterLab vs Jupyter Notebook para Ciencia de Datos y Aprendizaje Automático

    Primero quiero comentar que este es un ejemplo muy básico de Como entrenar un Chatbot con JSON

    A continuación, proporcionaré los archivos necesarios para entrenar un chatbot básico. Utilizaremos la biblioteca nltk para el procesamiento del lenguaje natural y tensorflow para entrenar un modelo simple. Estos son los archivos y su contenido:

    Archivo intents.json

    Este archivo contiene las intenciones y respuestas del chatbot.

    {
    "intents": [
    {
    "tag": "saludo",
    "patterns": ["Hola", "¿Cómo estás?", "Buenos días", "Buenas tardes"],
    "responses": ["¡Hola! ¿En qué puedo asistirte hoy?", "¡Hola! ¿Cómo puedo ayudarte?"]
    },
    {
    "tag": "despedida",
    "patterns": ["Adiós", "Nos vemos", "Hasta luego"],
    "responses": ["¡Adiós! Que tengas un buen día.", "Hasta luego, ¡cuídate!"]
    },
    {
    "tag": "gracias",
    "patterns": ["Gracias", "Muchas gracias", "Te lo agradezco"],
    "responses": ["¡De nada!", "¡Para eso estoy!", "¡No hay de qué!"]
    }
    ]
    }
    No olvidéis que esta es solo una estructura básica, cuanto mas contenido hay mejores respuestas dará su Catbot.

    Archivo entrenar.py
    Este script entrenará el modelo del chatbot.

    import json
    import numpy as np
    import random
    import nltk
    from nltk.stem import WordNetLemmatizer
    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import Dense, Dropout
    from tensorflow.keras.optimizers import SGD
    import pickle

    lemmatizer = WordNetLemmatizer()

    nltk.download('punkt')
    nltk.download('wordnet')

    words = []
    classes = []
    documents = []
    ignore_words = ['?', '!', '.']
    data_file = open('intents.json').read()
    intents = json.loads(data_file)

    for intent in intents['intents']:
    for pattern in intent['patterns']:
    w = nltk.word_tokenize(pattern)
    words.extend(w)
    documents.append((w, intent['tag']))
    if intent['tag'] not in classes:
    classes.append(intent['tag'])

    words = [lemmatizer.lemmatize(w.lower()) for w in words if w not in ignore_words]
    words = sorted(list(set(words)))

    classes = sorted(list(set(classes)))

    pickle.dump(words, open('words.pkl', 'wb'))
    pickle.dump(classes, open('classes.pkl', 'wb'))

    training = []
    output_empty = [0] * len(classes)

    for doc in documents:
    bag = []
    pattern_words = doc[0]
    pattern_words = [lemmatizer.lemmatize(word.lower()) for word in pattern_words]
    for w in words:
    bag.append(1) if w in pattern_words else bag.append(0)

    output_row = list(output_empty)
    output_row[classes.index(doc[1])] = 1
    training.append([bag, output_row])

    random.shuffle(training)
    training = np.array(training, dtype=object)

    train_x = np.array([np.array(i[0]) for i in training], dtype='object')
    train_y = np.array([np.array(i[1]) for i in training], dtype='object')

    model = Sequential()
    model.add(Dense(128, input_shape=(len(train_x[0]),), activation='relu'))
    model.add(Dropout(0.5))
    model.add(Dense(64, activation='relu'))
    model.add(Dropout(0.5))
    model.add(Dense(len(train_y[0]), activation='softmax'))

    sgd = SGD(learning_rate=0.01, decay=1e-6, momentum=0.9, nesterov=True)
    model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])

    hist = model.fit(np.array(train_x.tolist()), np.array(train_y.tolist()), epochs=200, batch_size=5, verbose=1)
    model.save('chatbot_model.h5', hist)


    Explicación
    Conversión a dtype=object: Al crear el array training, lo hacemos con dtype=object para permitir listas de diferentes longitudes. Luego convertimos los arrays internos de train_x y train_y en listas de numpy arrays.

    Aseguramos longitud uniforme: Convertimos las listas internas a arrays de numpy y nos aseguramos de que todos tengan la misma longitud.

    Pasos a seguir
    Guardar intents.json: Guarda el contenido del archivo intents.json en un archivo con el mismo nombre en tu directorio de trabajo.

    Ejecutar entrenar.py: Ejecuta el script entrenar.py para entrenar el modelo y generar los archivos necesarios (chatbot_model.h5, words.pkl, y classes.pkl).

    Interactuar en Jupyter Notebook: Utiliza el script chatbot.py proporcionado para interactuar con el chatbot.

    Siguiendo estos pasos y asegurándote de que el código de entrenamiento se ejecute sin errores, deberías poder entrenar tu modelo correctamente y luego interactuar con él en Jupyter Notebook.

    Archivo chatbot.py
    Este script cargará el modelo entrenado y permitirá la interacción con el chatbot.

    import json
    import numpy as np
    import random
    import nltk
    from nltk.stem import WordNetLemmatizer
    from tensorflow.keras.models import load_model
    import pickle
    import ipywidgets as widgets
    from IPython.display import display

    lemmatizer = WordNetLemmatizer()

    # Cargar archivos
    model = load_model('chatbot_model.h5')
    intents = json.loads(open('intents.json').read())
    words = pickle.load(open('words.pkl', 'rb'))
    classes = pickle.load(open('classes.pkl', 'rb'))

    # Preprocesar entrada
    def clean_up_sentence(sentence):
    sentence_words = nltk.word_tokenize(sentence)
    sentence_words = [lemmatizer.lemmatize(word.lower()) for word in sentence_words]
    return sentence_words

    def bow(sentence, words, show_details=True):
    sentence_words = clean_up_sentence(sentence)
    bag = [0]*len(words)
    for s in sentence_words:
    for i, w in enumerate(words):
    if w == s:
    bag[i] = 1
    if show_details:
    print(f"found in bag: {w}")
    return np.array(bag)

    def predict_class(sentence, model):
    p = bow(sentence, words, show_details=False)
    res = model.predict(np.array([p]))[0]
    ERROR_THRESHOLD = 0.25
    results = [[i, r] for i, r in enumerate(res) if r > ERROR_THRESHOLD]
    results.sort(key=lambda x: x[1], reverse=True)
    return_list = []
    for r in results:
    return_list.append({"intent": classes[r[0]], "probability": str(r[1])})
    return return_list

    def get_response(ints, intents_json):
    tag = ints[0]['intent']
    list_of_intents = intents_json['intents']
    for i in list_of_intents:
    if i['tag'] == tag:
    result = random.choice(i['responses'])
    break
    return result

    def chatbot_response(msg):
    ints = predict_class(msg, model)
    if not ints:
    return "Lo siento, no te entendí. ¿Puedes intentar de nuevo?"
    res = get_response(ints, intents)
    return res

    # Interfaz gráfica en Jupyter Notebook
    conversation = widgets.Output()

    def ask_from_bot(button):
    msg = input_text.value
    if msg:
    with conversation:
    print(f"User: {msg}")
    res = chatbot_response(msg)
    print(f"Bot: {res}")
    input_text.value = ""

    input_text = widgets.Text(placeholder='Escribe tu pregunta aquí...')
    button = widgets.Button(description="Enviar")
    button.on_click(ask_from_bot)

    display(conversation, input_text, button)

    Pasos para ejecutar en JupyterLab con Ubuntu
    Instalar dependencias: En una celda de JupyterLab, instala las bibliotecas necesarias:

    !pip install nltk tensorflow

    !pip install tk

    Crear archivos: En la terminal de JupyterLab o usando celdas, crea los archivos intents.json, entrenar.py y chatbot.py con el contenido proporcionado.

    Entrenar el modelo: Ejecuta el script entrenar.py desde una celda de JupyterLab:

    !python entrenar.py

    Ejecutar el chatbot: Finalmente, ejecuta el script chatbot.py desde una celda de JupyterLab:

    !python chatbot.py

    Esto abrirá una ventana de diálogo en la que podrás escribir tus preguntas y recibir respuestas del chatbot.


    También hay que configurar: CUDA y cuDNN

    He publicado este post sabiendo que es algo muy básico y simple, pero si puedo animar a alguien que nos eche una mano, pues mejor. Como todo en esta vida el código es mejorable, y estoy abierto a cualquier consejo y ayuda.

    El error fue mío de no utilizar las celdas de código

    Gracias a todos y saludos
    Última edición por vesko2103; 26/05/2024 a las 09:29
    Gigabyte Aorus AX370-Gaming K7
    AMD Ryzen 7 3700X 3.6GHZ BOX
    Corsair Vengeance LPX DDR4 3200 PC4-25600 16GB 2x8GB C16
    Corsair HX850i 850W 80 Plus Platinum Modular
    Gigabyte AMD Radeon RX 6700 XT GAMING OC 12GB GDDR6

Página 2 de 2 PrimerPrimer 12

Permisos de publicación

  • No puedes crear nuevos temas
  • No puedes responder temas
  • No puedes subir archivos adjuntos
  • No puedes editar tus mensajes
  •