import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# Загрузка выпусков данных
iris = load_iris()
X, y = iris.data, iris.target

# Разделяются на тегированные данные и нетегированные данные.
X_train, X_unlabeled, y_train, _ = train_test_split(X, y, test_size=0.7, random_state=42)
X_unlabeled, X_test, _, y_test = train_test_split(X_unlabeled, _, test_size=0.5, random_state=42)

# Начальное обучение модели
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# процесс самообучения
for i in range(10):
    y_pred_unlabeled = model.predict(X_unlabeled)
    X_train = np.vstack((X_train, X_unlabeled))
    y_train = np.concatenate((y_train, y_pred_unlabeled))
    model.fit(X_train, y_train)

# Модель оценки
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f'Точность самообучаемой модели: {accuracy}')

from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier

# Определите два классификатора с разных точек зрения
model1 = LogisticRegression(random_state=42)
model2 = DecisionTreeClassifier(random_state=42)

# Начальное обучение модели
model1.fit(X_train, y_train)
model2.fit(X_train, y_train)

# совместный процесс обучения
for i in range(10):
    y_pred_unlabeled1 = model1.predict(X_unlabeled)
    y_pred_unlabeled2 = model2.predict(X_unlabeled)
    
    high_confidence_idx1 = np.where(model1.predict_proba(X_unlabeled).max(axis=1) > 0.9)[0]
    high_confidence_idx2 = np.where(model2.predict_proba(X_unlabeled).max(axis=1) > 0.9)[0]
    
    X_train1 = np.vstack((X_train, X_unlabeled[high_confidence_idx2]))
    y_train1 = np.concatenate((y_train, y_pred_unlabeled2[high_confidence_idx2]))
    
    X_train2 = np.vstack((X_train, X_unlabeled[high_confidence_idx1]))
    y_train2 = np.concatenate((y_train, y_pred_unlabeled1[high_confidence_idx1]))
    
    model1.fit(X_train1, y_train1)
    model2.fit(X_train2, y_train2)

# Модель оценки
y_pred1 = model1.predict(X_test)
y_pred2 = model2.predict(X_test)
accuracy1 = accuracy_score(y_test, y_pred1)
accuracy2 = accuracy_score(y_test, y_pred2)
print(f'Точность модели 1 совместного обучения: {accuracy1}')
print(f'Точность модели 2 совместного обучения: {accuracy2}')

from sklearn.semi_supervised import LabelPropagation

# Сборка с данными тегов и без данных тегов
X_labeled, X_unlabeled, y_labeled, y_unlabeled = train_test_split(X, y, test_size=0.7, random_state=42)
y_unlabeled[:] = -1  # Установите для тегов без данных тега значение -1.

# Объединение тегированных и нетегированных данных
X_combined = np.vstack((X_labeled, X_unlabeled))
y_combined = np.concatenate((y_labeled, y_unlabeled))

# Модель распространения меток поездов
label_propagation = LabelPropagation()
label_propagation.fit(X_combined, y_combined)

# Прогноз и модель оценки
y_pred = label_propagation.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f' точность модели распространения меток: {accuracy}')

import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten

# Загрузка выпусков данных
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# Разделяются на тегированные данные и нетегированные данные.
x_labeled, x_unlabeled = x_train[:1000], x_train[1000:]
y_labeled = y_train[:1000]

# Определить модель
model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
])

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

# Начальное обучение модели
model.fit(x_labeled, y_labeled, epochs=10, validation_data=(x_test, y_test), verbose=2)

# процесс самообучения
for i in range(10):
    y_pred_unlabeled = np.argmax(model.predict(x_unlabeled), axis=1)
    x_labeled = np.vstack((x_labeled, x_unlabeled))
    y_labeled = np.concatenate((y_labeled, y_pred_unlabeled))
    model.fit(x_labeled, y_labeled, epochs=10, validation_data=(x_test, y_test), verbose=2)

# Модель оценки
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print(f'Точность самообучаемой модели: {test_acc}')

from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.layers import Embedding, LSTM, Dense, Bidirectional
from tensorflow.keras.models import Sequential

# Загрузка выпусков данных
(x_train, y_train), (x_test,y_test) =

 tf.keras.datasets.imdb.load_data(num_words=10000);

# данныепредварительная обработка
макслен = 100
x_train = Pad_sequences ( x_train, maxlen=maxlen)
x_test = pad_sequences(x_test, maxlen=maxlen)

# Разделяются на тегированные данные и нетегированные данные.
x_labeled, x_unlabeled = x_train[:1000], x_train[1000:]
y_labeled = y_train[:1000]

# Определить модель LSTM
def create_lstm_model():
    model = Sequential([
        Embedding(10000, 128, input_length=maxlen),
        Bidirectional(LSTM(64)),
        Dense(1, activation='sigmoid')
    ])
    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
    return model

# Обучите две модели LSTM
model1 = create_lstm_model()
model2 = create_lstm_model()
model1.fit(x_labeled, y_labeled, epochs=5, validation_data=(x_test, y_test), verbose=2)
model2.fit(x_labeled, y_labeled, epochs=5, validation_data=(x_test, y_test), verbose=2)

# совместный процесс обучения
for i in range(5):
    y_pred_unlabeled1 = (model1.predict(x_unlabeled) > 0.5).astype(int)
    y_pred_unlabeled2 = (model2.predict(x_unlabeled) > 0.5).astype(int)
    
    high_confidence_idx1 = np.where(np.abs(model1.predict(x_unlabeled) - 0.5) > 0.4)[0]
    high_confidence_idx2 = np.where(np.abs(model2.predict(x_unlabeled) - 0.5) > 0.4)[0]
    
    x_train1 = np.vstack((x_labeled, x_unlabeled[high_confidence_idx2]))
    y_train1 = np.concatenate((y_labeled, y_pred_unlabeled2[high_confidence_idx2]))
    
    x_train2 = np.vstack((x_labeled, x_unlabeled[high_confidence_idx1]))
    y_train2 = np.concatenate((y_labeled, y_pred_unlabeled1[high_confidence_idx1]))
    
    model1.fit(x_train1, y_train1, epochs=5, validation_data=(x_test, y_test), verbose=2)
    model2.fit(x_train2, y_train2, epochs=5, validation_data=(x_test, y_test), verbose=2)

# Модель оценки
test_loss1, test_acc1 = model1.evaluate(x_test, y_test, verbose=2)
test_loss2, test_acc2 = model2.evaluate(x_test, y_test, verbose=2)
print(f'Точность модели 1 совместного обучения: {test_acc1}')
print(f'Точность модели 2 совместного обучения: {test_acc2}')