Требуемые библиотеки

import pandas as pd
import numpy as np
import re
import tensorflow as tf
import keras
from keras import layers
from sklearn.metrics import mean_squared_error, mean_absolute_error
from tensorflow.keras.optimizers import Adam, SGD, RMSprop, Adagrad
from tensorflow.keras.callbacks import ModelCheckpoint
from tensorflow.keras.layers import Bidirectional, LSTM, Dropout, Embedding, Dense
from sklearn.model_selection import train_test_split
from imblearn.over_sampling import SMOTE
from imblearn.under_sampling import NearMiss
from nltk.stem import SnowballStemmer
from nltk.stem import WordNetLemmatizer
from sklearn.feature_extraction.text import TfidfVectorizer, TfidfTransformer
import pymorphy2
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences

1. Первичная обработка текстовых данных

train2 = table['Tweet'].str.lower()
text1_test = train2.astype(str)

text1_without = text1_test.str.replace('[\([{})\]]', '')
text1_without = text1_without.str.replace('https:\/\/\S+', '')
text1_without = text1_without.str.replace('[\n/!@#$%^&*()"№;—:?=|«»,.]', ' ')
text1_without = text1_without.str.replace('[0-9+]', ' ')

ready_text1 = pd.DataFrame(text1_without)
ready_text1.columns = ['cleaned_posts']
ready_text1

2. Удаление стоп-слов из всего массива

ready_text = []

#for i in ready_text1['cleaned_posts'][:10]:
for i in ready_text1['cleaned_posts']:
  vec = [word for word in i.split() if word not in stopwords.words('english')]
  vec = ' '.join(vec)
  ready_text.append(vec)

ready_text

3. Стемминг всех элемнтов в массиве

snowball = SnowballStemmer(language="english")
tab = []

for i in ready_text:
  sent = []
  for z in i.split():
    new_word = snowball.stem(z)
    sent.append(new_word)
  new_sent = ' '.join(sent)
  tab.append(new_sent)

  print(tab)

4. Лемматизация всех элементов в массиве

nltk.download('wordnet')
lemmatizer = WordNetLemmatizer()

for i in ready_text:
  row_lemm = []
  for z in i.split():
    lemm = lemmatizer.lemmatize(z)
    row_lemm.append(lemm)
  new_lemm = ' '.join(row_lemm)

  print(new_lemm)

5. Токенизация элементов массива на основе "мешка слов"

tokenizer = Tokenizer(num_words=num_words)
posts = new_tab1[0]
tokenizer.fit_on_texts(posts)
sequences = tokenizer.texts_to_sequences(posts)
x = pad_sequences(sequences, maxlen=max_review_len)

6. Токенизация элементов массива на основе алгоритма TF-IDF

#Токенизация элементов массива и их векторизация
count_vect = TfidfVectorizer(
    #analyzer='char',
    analyzer='word',
    ngram_range=(1, 2),
    max_df=0.9,
    min_df=2,
    norm = None
)
x_count = count_vect.fit_transform(new_tab1[0])

# Если требуется перевести в векторное пространство тестовый новый массив данных

x_test_count = count_vect1.transform(posts_test1)
x_test_tf = tfidf_transform.transform(x_test_count)



# Построение датафрейма для отображения всей матрицы токенов
x_tf1 = pd.DataFrame.sparse.from_spmatrix(x_count)
x_tf2 = x_tf1.to_numpy()



# Перевод матрицы в numpy array и удаление всех нулевых элементов построчно
matrix1 = []

z=1

for i in list(x_tf2):
  row = i[i!=0]
  matrix1.append(row)
  print(z)
  z=z+1

matrix1



# Приведение каждой строчки данных к единой длине (смотрим распределение длины векторов)
x_test2 = pad_sequences(matrix1, maxlen=max_review_len, dtype='float32')

7. Приведение выборки к сбалнсированному виду: Oversampling Case

over_sampler = SMOTE(k_neighbors=3)
x_res, y_res = over_sampler.fit_resample(x_train, y_train)
x_res, y_res = shuffle(x_res, y_res, random_state=0)
y_res.value_counts()

8. Приведение выборки к сбалнсированному виду: Undersampling Case
under_sampler = NearMiss()
x_res1, y_res1 = under_sampler.fit_resample(x_train, y_train)
y_res1.value_counts()

Требуемые библиотеки

from selenium import webdriver
import time
from webdriver_manager.chrome import ChromeDriverManager
from clickhouse_driver import Client
import pandas as pd
import requests as rs
from selenium.webdriver.common.by import By
from bs4 import BeautifulSoup as bs
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.chrome.service import Service

1. Пример кода для построения простой рекурретной нейронной сети

Можно также использовать универсальную команду find_element(By.) или find_elements(By.), где в скобках после By. можно указать разные команды:

ID = “id”

XPATH = “xpath”

NAME = “name”

TAG_NAME = “tag name”

CLASS_NAME = “class name”

LINK_TEXT = “link text”

PARTIAL_LINK_TEXT = “partial link text”

Для открытия страницы по ссылке используется команда:

.get("url")

Для обновления страницы:

.refresh()

Чтобы ввести текст в определенное поле / часть страницы:

.send_keys("emailid@lambdatest.com")

В случае, если требуется удалить часть "скелета" сайта или информацию из поля:

.clear()

Для нажатия для элемена по кнопке или другой части сайта:

.click()

Получение кода страницы 
.page_source

2. Основные команды работы в BeautifulSoup

Вместо подгружения вебдрайвера и открытия нового окна браузера можно сразу высызвать по ссылке нужную нам страницу:

requests.get('url')

Далее уже выгружаем сам код страницы:

html = response.text

На основе кода формируем объект для парсинга нужных элементов страницы:

soup = BeautifulSoup(html, 'html.parser')

или (более универсальный и быстрый метод)

soup = BeautifulSoup(html, 'lxml')

Если требуется определенный элемент по ID извлечь из кода страницы:

soup.find(id='example')

Если требуется выбрать все элемени по отдельному ID:

soup.find_all(id='example')

Однако можно находить элементы по различным атрибутам:

soup.find_all(attrs={'data-name': 'my-data'}) или soup.find(attrs={'data-name': 'my-data'})

Частым являются запросы по парсингу повторяющихся элементов страницы:

soup.find_all('div', {'class': 'class_name'})

или

soup.find_all('div', class_='class_name')

Однако, если в элементе с классом есть дополнительный тег, то можно применить:

soup.find_all('div', {'class': 'class_name'}, 'tag_name')

Можно также отбирать элементы:

soup.select('element')

И также эти элементы удалять из кода страницы:

soup.extract('element')

Требуемые библиотеки

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
import tensorflow as tf
import keras
from keras import layers
from sklearn.metrics import mean_squared_error, mean_absolute_error
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.callbacks import ModelCheckpoint
from sklearn.metrics import classification_report
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.utils import plot_model
from tensorflow.keras.layers import Bidirectional, LSTM
from tensorflow.keras.layers import Dropout

1. Пример кода для построения простой рекурретной нейронной сети

model = keras.Sequential()

model.add(layers.SimpleRNN(128, input_shape=(train_x.shape[1], 1), return_sequences=False))


model.add(layers.Dense(1, activation='sigmoid'))

optimizer = Adam(learning_rate=0.001)

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

model_save_path = 'best_model.h7'

checkpoint_callback = ModelCheckpoint(model_save_path,
                                     monitor='val_accuracy',
                                     save_best_only=True,
                                      verbose=1)

model.fit(train_x, train_y, epochs=10, batch_size=32, validation_split=0.2, verbose = 1,
          callbacks=[checkpoint_callback]
          )

2. Пример кода для построения LSTM

model_LSTM = keras.Sequential()

model_LSTM.add(layers.LSTM(128, input_shape=(train_x.shape[1], 1), return_sequences=False))


model_LSTM.add(layers.Dense(1, activation='sigmoid'))


optimizer = Adam(learning_rate=0.1)

model_LSTM.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy'])

model_save_path = 'best_model.h7'

checkpoint_callback = ModelCheckpoint(model_save_path,
                                     monitor='val_accuracy',
                                     save_best_only=True,
                                      verbose=1)

model_LSTM.fit(train_x, train_y, epochs=10, batch_size=32, validation_split=0.2, verbose = 1,
          callbacks=[checkpoint_callback]
          )

2. Пример кода для построения двунаправленной сети LSTM с отключением переобученных нейронов

model_BiLSTM_drop = keras.Sequential()

model_BiLSTM_drop.add(LSTM(128, input_shape=(train_x.shape[1], 1), return_sequences=True))

model_BiLSTM_drop.add(Dropout(0.2))

model_BiLSTM_drop.add(Bidirectional(LSTM(128, return_sequences=False)))


model_BiLSTM_drop.add(layers.Dense(1, activation='sigmoid'))


optimizer = Adam(learning_rate=0.1)

model_BiLSTM_drop.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy'])

model_save_path = 'best_model.h7'

checkpoint_callback = ModelCheckpoint(model_save_path,
                                     monitor='val_accuracy',
                                     save_best_only=True,
                                      verbose=1)

model_BiLSTM_drop.fit(train_x, train_y, epochs=10, batch_size=32, verbose = 1, validation_split=0.2,
          callbacks=[checkpoint_callback]
          )

Требуемые библиотеки

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

1. Пример кода для построения базовой нейронной модели

model1 = Sequential([
    Dense(1, input_shape=(2,))
])

model1.summary()

2. Пример построения многослойного персептрона с несколькими функциями активации и коимпилирования всей модели

model2 = Sequential([
    Dense(3, input_shape=(2,)),
    Dense(2, input_shape=(2,), activation='relu'),
    Dense(1, input_shape=(2,), activation='linear'),
   # Dense(1, activation='relu')
])

#model2.load_weights('my_model_weights.h5')

optimizer = Adam(lr=0.001)

model2.compile(optimizer=optimizer, loss='mse', metrics='mae')

model2.fit(x_train, y_train, epochs=50)

import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score

1. Загружаем данные

train = pd.read_csv('train_data.csv')
train.head()

test = pd.read_csv('test_data.csv')
test.head()

2. Готовим фичи и тренируем модель

features = [train.lat,
            train.lon]

df = np.array(features).T
train_X, test_X, train_y, test_y = train_test_split(df, train.burned.values)

lr = LogisticRegression()
lr.fit(train_X, train_y)

roc_auc_score(test_y.astype(int), lr.predict_proba(test_X)[:, 1])

3. Делаем предсказание на тесте и загружаем ответы в файл

test_features = [test.lat,
                 test.lon]
df_test = np.array(test_features).T

probas = lr.predict_proba(df_test)[:, 1]

df = pd.DataFrame(probas, columns=['Prob'])
df.to_csv('submit.csv', index_label='Id')