Qualification
Anyone Born Between 2004 ~ 2011
No Limitation of gender and nationality
Category
Vocal / Rap : 1 minute or less of a confident song (without music)
Dance : 1 minute or less of a confident song
Acting : Free Acting
Modeling : Freestyle posing/catwalk
Audition Process
01. Online Registration
- Google Form link on @istent_audition instagram profile, Applicants can only apply ONCE during the audition period.
02. 1:1 Online Audition
Only those who passed 1st step will be announced individually by E-mail.
03. 1:1 IN-Person Audition
Only those who passed 2nd step will be announced individually by E-mail.
志願資格
年齢:2004年生まれ~2011年生まれ
性別/国籍:無関係
志願分野
ボーカル/ラップ:1分前後自信のある曲（無伴奏）
ダンス:1分前後自信のある曲
演:自由演技
モデル:自由なポーズ/ウォーキング
進行過程
01. オンライン受付
- インスタグラム:@instent_auditionプロフィールにお知らせされたグーグルフォームの志願書作成は重複受付不可
02. 1:1オンラインオーディション
- オーディション結果は1次合格者に限りEメールにて個別連絡
03. 1:1 現場オーディション
- オーディション結果は2次合格者に限り個別連絡
import numpy as np
import matplotlib.pyplot as plt
# 입력 데이터
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
# 정답 레이블
y = np.array([[0], [1], [1], [0]])
# 시그모이드 활성화 함수
def sigmoid(x):
return 1 / (1 + np.exp(-x))
# 시그모이드의 도함수
def sigmoid_derivative(x):
return x * (1 - x)
# 신경망 클래스
class NeuralNetwork:
def __init__(self, input_size, hidden_size, output_size):
# 가중치 초기화
self.U = np.array([[0.2, 0.2, 0.3], [0.3, 0.1, 0.2]])
self.W = np.array([[0.3, 0.2], [0.1, 0.4], [0.2, 0.3]])
# 편향 초기화
self.b1 = np.zeros((1, hidden_size))
self.b2 = np.zeros((1, output_size))
# 에포크와 오차 기록을 위한 리스트
self.epochs = []
self.errors = []
def forward(self, X):
# 은닉층 계산
self.hidden_layer = sigmoid(np.dot(X, self.U) + self.b1)
# 출력층 계산
self.output_layer = sigmoid(np.dot(self.hidden_layer, self.W) + self.b2)
def backward(self, X, y, learning_rate):
# 출력층의 오차 계산
output_error = y - self.output_layer
output_delta = output_error * sigmoid_derivative(self.output_layer)
# 은닉층의 오차 계산
hidden_error = np.dot(output_delta, self.W.T)
hidden_delta = hidden_error * sigmoid_derivative(self.hidden_layer)
# 가중치 및 편향 업데이트
self.U += learning_rate * np.dot(X.T, hidden_delta)
self.W += learning_rate * np.dot(self.hidden_layer.T, output_delta)
self.b1 += learning_rate * np.sum(hidden_delta, axis=0)
self.b2 += learning_rate * np.sum(output_delta, axis=0)
def train(self, X, y, epochs, learning_rate):
for epoch in range(epochs):
self.forward(X)
self.backward(X, y, learning_rate)
self.epochs.append(epoch + 1)
self.errors.append(np.mean(np.abs(y - self.output_layer)))
def predict(self, X):
self.forward(X)
return self.output_layer
# 신경망 모델 생성
input_size = 2
hidden_size = 3
output_size = 2
learning_rate = 1.0
epochs = 1000
model = NeuralNetwork(input_size, hidden_size, output_size)
# 모델 훈련
model.train(X, y, epochs, learning_rate)
# 예측 결과 출력
predictions = model.predict(X)
for x, y_pred in zip(X, predictions):
print(f"x1: {x[0]}, x2: {x[1]}, y1: {y_pred[0]:.4f}, y2: {1 - y_pred[0]:.4f}")
# 에포크와 오차 그래프 출력
plt.plot(model.epochs, model.errors)
plt.xlabel('epoch')
plt.ylabel('Error')
plt.show()
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def sigmoid_derivative(x):
return x * (1 - x)
def mse_loss(y_true, y_pred):
return ((y_true - y_pred) ** 2).mean()
def forward_propagation(X, weights, biases):
layers = [X]
for weight, bias in zip(weights, biases):
layers.append(sigmoid(np.dot(layers[-1], weight) + bias))
return layers
def back_propagation(y_true, layers, weights, biases, learning_rate=1.0):
error = y_true - layers[-1]
for i in reversed(range(len(weights))):
delta = error * sigmoid_derivative(layers[i+1])
error = np.dot(delta, weights[i].T)
weights[i] += learning_rate * np.dot(layers[i].T, delta)
biases[i] += learning_rate * np.sum(delta, axis=0)
return weights, biases
np.random.seed(0)
weights = [
np.random.uniform(0, 1, (1, 6)),
np.random.uniform(0, 1, (6, 4)),
np.random.uniform(0, 1, (4, 1))
]
biases = [
np.zeros((1, 6)),
np.zeros((1, 4)),
np.zeros((1, 1))
]
df = pd.read_csv('nonlinear.csv')
X = df['x'].to_numpy().reshape(-1, 1)
y_true = df['y'].to_numpy().reshape(-1, 1)
for _ in range(100):
for i in range(X.shape[0]):
layers = forward_propagation(X[i:i+1], weights, biases)
weights, biases = back_propagation(y_true[i:i+1], layers, weights, biases)
domain = np.linspace(0, 1, 100).reshape(-1, 1)
y_hat = forward_propagation(domain, weights, biases)[-1]
plt.scatter(df['x'], df['y'])
plt.scatter(domain, y_hat, color='r')
plt.show()
model = keras.models.Sequential([
keras.layers.Dense(32, activation='tanh', input_shape=(1,)),
keras.layers.Dense(16, activation='tanh'),
keras.layers.Dense(8, activation='tanh'),
keras.layers.Dense(4, activation='tanh'),
keras.layers.Dense(1, activation='tanh'),
])
optimizer = keras.optimizers.SGD(learning_rate=0.1)
model.compile(optimizer=optimizer, loss='mse')
df = pd.read_csv('nonlinear.csv')
X = df['x'].to_numpy()
X = X.reshape(-1, 1)
y_label = df['y'].to_numpy()
model.fit(X, y_label, epochs=100)
domain = np.linspace(0, 1, 100).reshape(-1, 1)
y_hat = model.predict(domain)
plt.scatter(df['x'], df['y'])
plt.scatter(domain, y_hat, color='r')
plt.show()
#Iris 데이터를 입력으로 하여 Versicolor, Setosa, Virginica 3종의 품종을 구분하는 심층신경망을 아래 조건을 이용하여 구성
import numpy as np
import pandas as pd
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt
# Iris 데이터 불러오기
url = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"
df = pd.read_csv(url, header=None)
# 입력과 출력 데이터 분리
X = df.iloc[:, :-1].values
y = df.iloc[:, -1].values
# 레이블 숫자로 매핑
label_mapping = {
'Iris-setosa': 0,
'Iris-versicolor': 1,
'Iris-virginica': 2
}
y = np.array([label_mapping[label] for label in y])
# 훈련 데이터와 테스트 데이터로 분할 (stratify 옵션을 사용하여 클래스 비율 유지)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, stratify=y, random_state=42)
# 특성 스케일링
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
# 신경망 모델 구성
model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Dense(64, activation='relu', input_shape=(4,)))
model.add(tf.keras.layers.Dropout(0.2))
model.add(tf.keras.layers.Dense(32, activation='relu'))
model.add(tf.keras.layers.Dense(10, activation='relu'))
model.add(tf.keras.layers.Dense(3, activation='softmax'))
# 모델 컴파일
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# 모델 훈련
history = model.fit(X_train, y_train, batch_size=5, epochs=30, verbose=0)
# 테스트 데이터에 대한 정확도 평가
_, test_accuracy = model.evaluate(X_test, y_test)
# 그래프 출력
plt.plot(history.history['loss'], label='Loss')
plt.plot(history.history['accuracy'], label='Accuracy')
plt.title('Model Loss and Accuracy')
plt.xlabel('Epoch')
plt.legend()
plt.show()
print("Test Accuracy:", test_accuracy)
# Fashion MNIST 데이터를 이용하여 다음 조건을 만족하는 신경망을 생성 + 이미지 출력
import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt
import numpy as np
# Fashion MNIST 데이터 불러오기
fashion_mnist = keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
# 데이터 전처리: 0~1 사이의 값으로 스케일링
train_images = train_images / 255.0
test_images = test_images / 255.0
# 모델 구성
model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dropout(0.2),
keras.layers.Dense(32, activation='relu'),
keras.layers.Dense(10, activation='softmax')
])
# 모델 컴파일
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# 모델 훈련
history = model.fit(train_images, train_labels, batch_size=64, epochs=10, validation_split=0.25)
# 테스트 데이터에 대한 정확도 평가
test_loss, test_accuracy = model.evaluate(test_images, test_labels)
# 그래프 출력
plt.figure(figsize=(12, 5))
# Loss 그래프
plt.subplot(1, 2, 1)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss', linestyle='dashed')
plt.title('Model Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
# Accuracy 그래프
plt.subplot(1, 2, 2)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy', linestyle='dashed')
plt.title('Model Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.tight_layout()
plt.show()
# 첫 25개 테스트 이미지 가져오기
test_images_subset = test_images[:25]
test_labels_subset = test_labels[:25]
# 이미지 분류 및 출력
predictions = model.predict(test_images_subset)
predicted_labels = np.argmax(predictions, axis=1)
class_labels = {
0: "T-shirt/top",
1: "Trouser",
2: "Pullover",
3: "Dress",
4: "Coat",
5: "Sandal",
6: "Shirt",
7: "Sneaker",
8: "Bag",
9: "Ankle boot"
}
plt.figure(figsize=(10, 10))
for i in range(25):
plt.subplot(5, 5, i + 1)
plt.imshow(test_images_subset[i])
plt.title(class_labels[predicted_labels[i]])
plt.axis('off')
plt.tight_layout()
plt.show()
print("Test Accuracy:", test_accuracy)
#Keras에서 제공하는 MNIST 데이터에 대하여 합성곱 신경망을 통한 학습을 진행하라. 6만개의 훈련 데이터를 사용하여 학습하고 1만개의 테스트 데이터를 사용하여 정확도를 검증하라
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
# 시드 고정
tf.random.set_seed(0)
# MNIST 데이터
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train = x_train.astype("float32") / 255.0
x_test = x_test.astype("float32") / 255.0
# 과제 11-1-1
# CNN
model = keras.Sequential()
model.add(layers.Conv2D(4, (2, 2), strides=(2, 2), padding="same", activation="relu", input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))
# Flatten
model.add(layers.Flatten())
model.add(layers.Dense(32, activation="relu"))
model.add(layers.Dense(10, activation="softmax"))
model.compile(
optimizer=keras.optimizers.Adam(learning_rate=0.001),
loss=keras.losses.SparseCategoricalCrossentropy(),
metrics=["accuracy"],
)
# 모델 학습
model.fit(x_train, y_train, epochs=1, batch_size=32)
test_loss, test_acc = model.evaluate(x_test, y_test)
print("테스트 데이터의 손실값 : {:.2f}".format(test_loss))
print("테스트 데이터의 정확도 : {:.2f}".format(test_acc))
# 과제 11-1-2 98 % 이상되게 하라 정확도가
# CNN
model = keras.Sequential()
model.add(layers.Conv2D(8, (3, 3), strides=(1, 1), padding="same", activation="relu", input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(16, (3, 3), strides=(1, 1), padding="same", activation="relu"))
model.add(layers.MaxPooling2D((2, 2)))
# Flatten
model.add(layers.Flatten())
model.add(layers.Dense(128, activation="relu"))
model.add(layers.Dense(10, activation="softmax"))
model.compile(
optimizer=keras.optimizers.Adam(learning_rate=0.001),
loss=keras.losses.SparseCategoricalCrossentropy(),
metrics=["accuracy"],
)
# 모델 학습
model.fit(x_train, y_train, epochs=1, batch_size=32)
test_loss, test_acc = model.evaluate(x_test, y_test)
print("테스트 데이터의 손실값 : {:.2f}, 테스트 데이터의 정확도 : {:.2f}".format(test_loss, test_acc))
# Keras에서 Fashion MNIST 데이터를 불러와 아래와 같은 신경망을 구성하고 테스트 데이터에 대해 정확도를 계산하라
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import matplotlib.pyplot as plt
# Fashion MNIST 데이터 로드
(x_train, y_train), (x_test, y_test) = keras.datasets.fashion_mnist.load_data()
x_train = x_train.reshape(-1, 28, 28, 1).astype("float32") / 255.0
x_test = x_test.reshape(-1, 28, 28, 1).astype("float32") / 255.0
y_train = keras.utils.to_categorical(y_train, num_classes=10)
y_test = keras.utils.to_categorical(y_test, num_classes=10)
# 모델 생성
model = keras.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation="relu", input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation="relu"))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(32, (3, 3), activation="relu"))
model.add(layers.Flatten())
# DENSE
model.add(layers.Dense(1568, activation="relu"))
model.add(layers.Dense(128, activation="relu"))
model.add(layers.Dense(32, activation="relu"))
# 출력층
model.add(layers.Dense(10, activation="softmax"))
# 과제 11-2-1
# 모델 출력
model.compile(
optimizer=keras.optimizers.Adam(),
loss=keras.losses.CategoricalCrossentropy(),
metrics=["accuracy"],
)
model.fit(x_train, y_train, epochs=1)
_, test_acc = model.evaluate(x_test, y_test)
print("테스트 정확도: {}".format(test_acc))
# 과제 11-2-2
# 테스트 이미지 분류 및 출력
x_test_subset = x_test[:25]
y_test_subset = y_test[:25]
predictions = model.predict(x_test_subset)
predicted_labels = tf.argmax(predictions, axis=1).numpy()
class_labels = [
"T-shirt/top",
"Trouser",
"Pullover",
"Dress",
"Coat",
"Sandal",
"Shirt",
"Sneaker",
"Bag",
"Ankle boot"
]
plt.figure(figsize=(10, 10))
for i in range(25):
plt.subplot(5, 5, i + 1)
plt.imshow(x_test_subset[i].reshape(28, 28))
plt.title(class_labels[predicted_labels[i]])
plt.axis('off')
plt.tight_layout()
plt.show()
#51개의 시퀀스를 가지는 Sine 함수 100개를 생성하고, 마지막 시퀀스의 값(51번째 값)을 예측하는 모델을 RNN, LSTM, GRU를 이용하여 구현하고 그래프를 출력
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import SimpleRNN, LSTM, GRU, Dense
from sklearn.metrics import mean_squared_error
# 데이터 생성
x = np.arange(0, 10.2, 0.2)
num_samples = 100
num_sequences = 51
start_points = np.random.choice(100, num_samples)
dataset = []
for start in start_points:
y = np.sin(x + start)
dataset.append(y)
dataset = np.array(dataset)
X = dataset[:, :50]
y = dataset[:, -1]
# 모델 생성
model_list = [SimpleRNN, LSTM, GRU]
for i, model_name in enumerate(model_list):
X_train, X_test, y_train, y_test = X[:80], X[80:], y[:80], y[80:]
model = Sequential()
model.add(model_name(10, input_shape=(50, 1)))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mean_squared_error')
# 모델 학습
history = model.fit(X_train[:, :, np.newaxis], y_train, epochs=50, verbose=0)
y_train_pred = model.predict(X_train[:, :, np.newaxis])
y_test_pred = model.predict(X_test[:, :, np.newaxis])
train_mse = mean_squared_error(y_train, y_train_pred)
test_mse = mean_squared_error(y_test, y_test_pred)
# 출력
fig, axs = plt.subplots(2, 2, figsize=(10, 8))
axs[0, 0].plot(history.history['loss'])
axs[0, 0].set_xlabel('epoch')
axs[0, 0].set_ylabel('loss')
axs[1, 0].plot(y_train, label='Train Actual', color='black', linewidth=2.0)
axs[1, 0].plot(y_train_pred, label='Train Predicted', color='red')
axs[1, 0].set_title('Train')
axs[1, 0].legend(loc='upper right')
axs[0, 1].scatter(y_train, y_train_pred, label='Train', marker='o')
axs[0, 1].scatter(y_test, y_test_pred, label='Test', color='orange', marker='o')
axs[0, 1].set_xlabel('y')
axs[0, 1].set_ylabel('y_hat')
axs[0, 1].legend(loc='upper left')
axs[1, 1].plot(y_test, label='Test Actual', color='black', linewidth=2.0)
axs[1, 1].plot(y_test_pred, label='Test Predicted', color='red')
axs[1, 1].set_title('Test')
axs[1, 1].legend(loc='upper right')
axs[1, 0].text(0.05, 0.9, f'MSE: {train_mse:.5f}', transform=axs[1, 0].transAxes)
axs[1, 1].text(0.05, 0.9, f'MSE: {train_mse:.5f}', transform=axs[1, 1].transAxes)
plt.tight_layout()
plt.show()