reg_linear

#A aprendizagem de máquina é uma técnica que permite que um modelo aprenda a realizar tarefas a partir de dados, sem que sejam explícitamente programados para realizar essas tarefas. Aqui está um exemplo de uma função de aprendizagem de máquina que utiliza o algoritmo de regressão linear simples para treinar um modelo de previsão de saída contínua a partir de um conjunto de entrada e saída:

import numpy as np

def fit(X, y):
  # Inicializa os pesos w com valores aleatórios
  w = np.random.randn(X.shape[1])

  # Define a taxa de aprendizado
  eta = 0.01

  # Executa o algoritmo de treinamento por 1000 iterações
  for i in range(1000):
    # Calcula a saída prevista do modelo para as amostras de entrada X
    y_pred = X.dot(w)

    # Calcula o erro entre a saída prevista e a saída real
    error = y_pred - y

    # Atualiza os pesos w usando o gradiente descendente
    w -= eta * (X.T.dot(error) / len(X))

  # Retorna os pesos treinados
  return w

def predict(X, w):
  # Calcula a saída prevista do modelo para as amostras de entrada X
  y_pred = X.dot(w)
  return y_pred

#Para usar essa função, basta fornecer um conjunto de entrada X e saída y de treinamento e chamar a função fit para treinar o modelo. Em seguida, você pode usar a função predict para realizar previsões usando o modelo treinado.

# Suponha que temos um conjunto de amostras de entrada X e saída y
X = np.array([[1, 2], [2, 3], [3, 4], [4, 5]])
y = np.array([5, 7, 9, 11])

# Treinamos o modelo usando o conjunto de treinamento
w = fit(X, y)

# Realizamos uma previsão usando o modelo treinado
x_test = np.array([5, 6])
y_pred = predict(x_test, w)
print(y_pred)  # imprime a previsão do modelo para as amostras de entrada x_test

import numpy as np
from keras.models import Sequential
from keras.layers import Dense

# Generate dummy data
x_train = np.random.random((1000, 20))
y_train = np.random.randint(2, size=(1000, 1))
x_test = np.random.random((100, 20))
y_test = np.random.randint(2, size=(100, 1))

# Build model
model = Sequential()
model.add(Dense(64, input_dim=20, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

# Compile model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Train model
model.fit(x_train, y_train, epochs=10, batch_size=128)

# Evaluate model
score = model.evaluate(x_test, y_test, batch_size=128)
print(score)


-------
import numpy as np

def sigmoid(x):
  return 1 / (1 + np.exp(-x))

def generate_neural_network(inputs, weights):
  # Generate hidden layer with random weights
  hidden_layer_weights = np.random.randn(inputs.shape[1], 4)
  
  # Generate output layer with random weights
  output_layer_weights = np.random.randn(4, 1)
  
  # Return generated weights as a list
  return [hidden_layer_weights, output_layer_weights]

def predict(inputs, weights):
  # Generate new neural network
  generated_weights = generate_neural_network(inputs, weights)
  
  # Use generated weights to make predictions
  hidden_layer_inputs = np.dot(inputs, generated_weights[0])
  hidden_layer_outputs = sigmoid(hidden_layer_inputs)
  output_layer_inputs = np.dot(hidden_layer_outputs, generated_weights[1])
  return sigmoid(output_layer_inputs)

def main():
  inputs = np.array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]])
  weights = np.array([0.5, 0.5, 0.5])

  predictions = predict(inputs, weights)
  print(predictions)

if __name__ == '__main__':
  main()


import nltk

# Define a set of words that the AI should recognize
words = []

# Tokenize input sentence and extract relevant words
def process_input(sentence):
  tokens = nltk.word_tokenize(sentence)
  relevant_words = [word for word in tokens if word in words]
  return relevant_words

# Respond to input using a simple classification algorithm
def generate_response(input_words):
  # If input is empty, return a random greeting
  if not input_words:
    return 'Hello!'
  
  # If input contains a greeting word, return a random greeting
  greeting_words = ['hello', 'hi', 'greetings']
  if any(word in greeting_words for word in input_words):
    return 'Hello! How are you doing?'
  
  # If input contains a question word, return a random question
  question_words = ['how', 'what', 'why']
  if any(word in question_words for word in input_words):
    return 'What would you like to know?'
  
  # If input contains a statement word, return a random statement
  statement_words = ['I', 'am', 'doing', 'well', 'thank', 'you']
  if any(word in statement_words for word in input_words):
    return 'I am glad to hear that you are doing well. Thank you!'
  
  # Otherwise, return a random response
  return 'Thank you for your input!'

# Learn new words from input
def learn_words(input_words):
  for word in input_words:
    if word not in words:
      words.append(word)

# Get user input and generate a response
def main():
  while True:
    input_sentence = input('Enter a sentence: ')
    input_words = process_input(input_sentence)
    learn_words(input_words)
    response = generate_response(input_words)
    print(response)

if __name__ == '__main__':
  main()

import spacy
import nltk
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB

# Carregar o modelo de linguagem em português do spaCy
nlp = spacy.load('pt_core_news_sm')

# Define exemplos de frases de cumprimento, pergunta e afirmação
exemplos_cumprimento = ['Olá!', 'Bom dia!', 'Oi!', 'Cumprimentos!']
exemplos_pergunta = ['Como você está?', 'O que você gostaria de saber?', 'Por que você está perguntando isso?']
exemplos_afirmacao = ['Eu estou bem, obrigado.', 'Estou bem, obrigado.', 'Estou muito bem, obrigado.']

# Extrai as palavras das frases de exemplo e as combina em uma única lista
palavras_exemplo = []
for frase in exemplos_cumprimento + exemplos_pergunta + exemplos_afirmacao:
  doc = nlp(frase)
  palavras_exemplo.extend([token.text for token in doc])

# Cria um vetorizador de palavras para contar as ocorrências de cada palavra nas frases de exemplo
vetorizador = CountVectorizer()
X = vetorizador.fit_transform(palavras_exemplo)

# Define as categorias de cumprimento, pergunta e afirmação
categorias = ['cumprimento', 'pergunta', 'afirmação']

# Cria um classificador Naive Bayes com as frases de exemplo e suas respectivas categorias
classificador = MultinomialNB()
classificador.fit(X, categorias)

# Tokeniza a frase de entrada e extrai as palavras relevantes
def processar_entrada(frase):
  doc = nlp(frase)
  palavras_relevantes = [token.text for token in doc]
  return palavras_relevantes

# Classifica as palavras de entrada utilizando o classificador Naive Bayes treinado
def classificar_palavras(palavras_entrada):
  X_entrada = vetorizador.transform(palavras_entrada)
  categoria



#webcrawling


import requests, bs4

import BeautifulSoup

def crawl(url):
  # Faz uma requisição HTTP para a URL especificada
  response = requests.get(url)

  # Verifica se a requisição foi bem-sucedida
  if response.status_code == 200:
    # Obtém o conteúdo da página
    html_content = response.text

    # Cria um objeto BeautifulSoup a partir do conteúdo da página
    soup = BeautifulSoup(html_content, 'html.parser')

    # Obtém todos os links da página
    links = soup.find_all('a')

    # Itera pelos links e imprime o texto e a URL
    for link in links:
      print(link.text, link['href'])

      # Chama a função crawl() recursivamente para seguir os links
      crawl(link['href'])

# Inicia o crawl a partir de uma URL específica
crawl('https://www.example.com')