Chương trình python để vẽ ben 10

Tôi là một fan hâm mộ lớn của Ben 10 Series và tôi luôn thắc mắc tại sao Omnitrix của Ben không thể biến thành người ngoài hành tinh mà Ben chọn (Điều này phần lớn là do A yếu. Tôi đã tích hợp sẵn hệ thống vào đồng hồ). Để giúp Ben, Chúng tôi sẽ phát minh ra “OmniNet”, một mạng lưới thần kinh có khả năng dự đoán một người ngoài hành tinh phù hợp tùy theo tình huống nhất định

Như đã thảo luận trong chương trình, Omnitrix về cơ bản là một máy chủ kết nối với Planet Primus để khai thác DNA của khoảng 10000 người ngoài hành tinh. Nếu tôi là kỹ sư của thiết bị, chắc chắn tôi sẽ thêm một hoặc nhiều tính năng vào đồng hồ

W hy. Omnitrix/Ultimatrix là một trường hợp đặc biệt vì nó không nhận thức được môi trường xung quanh. Theo Azmuth và những người khác, Omnitrix đôi khi đưa ra sự chuyển đổi sai do Hệ thống Trí tuệ Nhân tạo của chính nó đã phân loại sai. Chúng ta hãy tưởng tượng rằng người sáng tạo Azmuth đã thuê chúng ta để xây dựng một hệ thống Trí tuệ nhân tạo/ML mới.

H ow. Để xây dựng hệ thống của mình, chúng tôi yêu cầu một số dạng dữ liệu ban đầu và nhờ những người Trái đất đồng hành của chúng tôi, chúng tôi có Bộ dữ liệu Ben 10 của Kaggle.

Đối với bất kỳ dự án nào, chúng tôi cần một danh sách yêu cầu tốt và đối với dự án này, chúng tôi cần

• Trăn 3. 8. Ngôn ngữ lập trình
• Scikit-Tìm hiểu. Học máy nói chung
• gấu trúc. Để phân tích dữ liệu
• Nặng nề. Đối với tính toán số
• TenorFlow. Để xây dựng mạng lưới thần kinh sâu của chúng tôi
• Matplotlib. Để biểu đồ tiến trình của chúng tôi

O tập dữ liệu của bạn bao gồm ba cột và 97 hàng. Các cột khá dễ hiểu và khi phân tích dữ liệu, chúng tôi ngay lập tức biến tất cả các biểu diễn phân loại thành biểu diễn số.

• Nhân vật. Nhân vật sê-ri Ben 10
• Cấp độ sức mạnh. Cấp độ sức mạnh của một nhân vật
• Dòng Ben 10. Chuỗi liên kết với nhân vật

lr = LabelEncoder()def convert_id_to_category(index, mapping=None):
    """
        Convert the id into the label
        Arguments:
            mappping: The Mapping built by the LabelEncoder
            id: id corresponding to the label
        Returns:
            str: the label
    """
    return mapping.get(index, False)def convert_to_mapping(lr:LabelEncoder):
    """
        Extract the mapping from the LabelEncoder
        
        Returns:
            Dict: key/value for the label encoded
    """
    mapping = dict(list(zip(lr.transform(lr.classes_),lr.classes_)))
    return mappingdef get_power_level_mapping(df=None):
    mapping = {}
    for i in range(0, len(df)):
        mapping[df.loc[i].Character] = df.loc[i].Power_Level
    vtok = {}
    for i,j in enumerate(mapping):
        vtok[mapping[j]] = j
    return mapping, vtok# Ben_10_Series
df['Ben_10_Series'] = lr.fit_transform(df['Ben_10_Series'])
mapping_ben_10_series = convert_to_mapping(lr)
df['Character'] = lr.fit_transform(df['Character'])
mapping_character = convert_to_mapping(lr)print ("Length [Ben_10_Series]: {}".format(len(mapping_ben_10_series)))
print ("Length [Character]: {}".format(len(mapping_character)))def remove_string_powerlevel(df=None):
    """
        Replaces the string format of power level into an integer. (Manually checked the data)
        
        Arguments:
            df: Pandas DataFrame
        Returns
            None
    """
    
    # lowe bound
    df.loc[28, "Power_Level"] = "265"
    df.loc[93, "Power_Level"] = "12.5"
    df.loc[51, "Power_Level"] = "195"
    df.loc[52, "Power_Level"] = "160"
    df.loc[62, "Power_Level"] = "140"
    df.loc[67, "Power_Level"] = "20"
    df['Power_Level'] = df['Power_Level'].str.replace(",","")
    
    # converting power_level to float
    df['Power_Level'] = df['Power_Level'].astype(float)
    df['Character'] = df['Character'].astype(int)remove_string_powerlevel(df)

Trong ngoài việc thay đổi cách trình bày phân loại, chúng tôi đã làm sạch dữ liệu (cột. Power_Level) vì nó chứa một số cấp độ là văn bản. Cột cũng chứa dấu phẩy nên chúng tôi cũng đã làm sạch cột đó.

Bật kiểm tra thêm dữ liệu, chúng tôi có thể thấy rõ một số điểm ngoại lệ. (Nguyên tử X và Người ngoài hành tinh X). Nếu bạn đã quen thuộc với Ben 10, bạn nên biết rằng những người ngoài hành tinh này cực kỳ mạnh mẽ.

Ngoài các phép biến đổi tính năng, chúng tôi sẽ tạo một bộ dữ liệu mới có khả năng xử lý các vấn đề phân loại đa lớp

Để xem nơi chúng tôi có thể áp dụng các chuyển đổi tính năng, trước tiên chúng tôi sẽ kiểm tra mọi ngoại lệ

Đưa ra dưới đây là một biểu đồ phân tán thể hiện mức độ sai lệch của hai Power_Level này

Chúng tôi có thể thấy rõ rằng có hai điểm ngoại lệ và cách rõ ràng để kiểm tra các điểm ngoại lệ là phân tích zscore của chúng và đặt ngưỡng.

values = df['Power_Level'].values
zscore(values, 0) > zscore(values, 0).mean() # All the True values are outliers.values[96] = np.mean(values)
values[36] = np.mean(values)
# changing the outliers to mean value
# handpicking abnormal values and setting it a justified value.

• Nếu chúng ta đặt ngưỡng làm giá trị trung bình của các giá trị điểm số z, chúng ta có thể thấy rõ ràng tất cả các giá trị ngoại lệ là Đúng
• Bây giờ chúng tôi không muốn xóa các giá trị vì mỗi ký tự đều cần thiết

Nhưng vì chúng tôi biết tập dữ liệu và chúng tôi không muốn xóa bất kỳ người ngoài hành tinh nào, chúng tôi sẽ thay đổi thủ công chỉ số ngoại lệ thành giá trị trung bình của Cấp độ năng lượng

F xác định một vấn đề mới không phải là một nhiệm vụ dễ dàng nhưng vì chúng tôi là những người hâm mộ cuồng nhiệt của sê-ri Ben 10 nên chúng tôi có thể dễ dàng xây dựng một bộ dữ liệu mới.

Do thiếu thông tin (tính năng), trước tiên chúng tôi sẽ chia Power_Level đã sửa đổi theo một yếu tố. Để nhiệm vụ ngắn gọn, chúng tôi sẽ chia số nguyên thành ba cột nữa

1. điện cát. Sức mạnh của nhân vật trên cạn

2. Sức mạnh không quân. Sức mạnh của nhân vật trong Air

3. điện nước. Sức mạnh của nhân vật trong nước

def split_powerlevel(df, factor=3):
    """
        Split the power level by the specified factor
        Arguments:
            df:DataFrame
            factor: int
        Returns:
            data: dict[str] = list[str]
            
    """
    data = {'air_power1':[], 'sand_power1':[], 'water_power1':[], "air_power2":[], "sand_power2":[], "water_power2":[]}
    for i in df['power_level1']:
        t = i/factor # float
        data['air_power1'].append(t)
        data['sand_power1'].append(t)
        data['water_power1'].append(t)
    for i in df['power_level2']:
        t = i/factor # float
        data['air_power2'].append(t)
        data['sand_power2'].append(t)
        data['water_power2'].append(t)
    return datadef return_individual_data(th = .5, winner='c1'):
        """
            Returns a row in our dataset.
            
            Arguments:
                th: threshold
                winner: The winning character
                
            Returns:
                (str,str, float, float, str)
        """
        characters = np.array(list(mapping_character.keys()))
        mapping_ch_to_pl, mapping_pl_to_ch = get_power_level_mapping(df)
        random_character1 = np.random.choice(characters)
        random_character2 = np.random.choice(characters)
        p1 = mapping_ch_to_pl[random_character1]
        p2 = mapping_ch_to_pl[random_character2]
        power_diff = np.abs(mapping_ch_to_pl[random_character1] - mapping_ch_to_pl[random_character2])
        if winner == 'c1':
            return random_character1, random_character2,p1, p2, random_character1
        else:
            return random_character1, random_character2,p1, p2, random_character2

Đối với mỗi ký tự, chúng tôi có thêm 3 cột được thêm vào Khung dữ liệu cuối cùng của chúng tôi

Đối với mỗi hàng trong tập dữ liệu của chúng tôi, chúng tôi chọn ngẫu nhiên các ký tự và gán nó cho tập hợp theo tỷ lệ 50. 50 (Nhân vật 1 thắng 50% số trận đấu tay đôi và Nhân vật 2 thắng 50% số trận đấu tay đôi)

Với mẩu thông tin này, mức năng lượng được chia theo hệ số 3 để tạo ra một bộ gồm 10 tính năng

Để kết thúc mọi thứ, chúng tôi kết hợp từng hàng và gọi nó n lần, mỗi lần chia mức năng lượng thành 3 cột nữa

def create_data(df, split_size=0.2, size=1000):
    """
        Create Data for Multiclass classification problem
        Arguments:
            df: Pandas DataFrame
        Returns:
            data: Pandas DataFrame
    """
    def return_individual_data(th = .5, winner='c1'):
        """
            Returns a row in our dataset.
            
            Arguments:
                th: threshold
                winner: The winning character
                
            Returns:
                (str,str, float, float, str)
        """
        characters = np.array(list(mapping_character.keys()))
        mapping_ch_to_pl, mapping_pl_to_ch = get_power_level_mapping(df)
        random_character1 = np.random.choice(characters)
        random_character2 = np.random.choice(characters)
        p1 = mapping_ch_to_pl[random_character1]
        p2 = mapping_ch_to_pl[random_character2]
        power_diff = np.abs(mapping_ch_to_pl[random_character1] - mapping_ch_to_pl[random_character2])
        if winner == 'c1':
            return random_character1, random_character2,p1, p2, random_character1
        else:
            return random_character1, random_character2,p1, p2, random_character2# win is by character1 (by default)
    data = {'character1':[], 'character2':[], 'power_level1':[],'power_level1':[],'power_level2':[], 'win':[]}
    
    # first half
    for i in range(0, size//2):
        c1, c2, p1, p2, c1 = return_individual_data(winner='c1')
        data['character1'].append(c1)
        data['character2'].append(c2)
        data['power_level1'].append(p1)
        data['power_level2'].append(p2)
        data['win'].append(c1)
    
    # second half
    for i in range(0, size//2):
        c1, c2, p1, p2, c2 = return_individual_data(winner='c2')
        data['character1'].append(c1)
        data['character2'].append(c2)
        data['power_level1'].append(p1)
        data['power_level2'].append(p2)
        data['win'].append(c2)
    
    data_df = pd.DataFrame(data=data, columns=['character1', 'character2', 'power_level1', 'power_level2', 'win'])
    data_df = shuffle(data_df)
    
    toadd = split_powerlevel(data_df)
    for k,v in enumerate(toadd):
        data_df[v] = toadd[v]
    
    features, labels = data_df.drop(columns=['win']).values, data_df.win.values
    
    x_train, x_test, y_train, y_test = train_test_split(features, labels, test_size=0.2, random_state=42)
    x_train, x_val, y_train, y_val = train_test_split(x_train, y_train, test_size=0.25, random_state=42)
    
    
    print ("Generated data of size:{}".format(size))return features, labels,x_train, x_test, y_train, y_test,x_val, y_val, data_df

Chúng tôi đếm số trận thắng để kiểm tra sự mất cân bằng của lớp

def count_wins(df=None):
    """        Count number of character wins. # to check for class imbalance
        Returns: 
            c1_wins: Character 1 wins
            c2_wins: Character 2 wins
    """
    for i in range(0, len(df)):
        if df.loc[i].character1 == df.loc[i].win:
            c1_wins.append(i)
        else:
            c2_wins.append(i)
    print("Character 1 wins: {}, Character 2 wins: {}".format(len(c1_wins), len(c2_wins)))       
    
features, labels,x_train, x_test, y_train, y_test,x_val, y_val,data = create_data(df, size=5000)

O mạng nơ-ron của bạn là một mạng chuyển tiếp đơn giản với một loạt các lớp ẩn, theo sau là một loạt các lớp Bỏ học (cách tốt nhất để giảm trang bị thừa vì tập dữ liệu này rất dễ bị .

Dữ liệu của chúng tôi đã được chia trong phương thức create_data() thành x_train, x_test, y_train, y_test, x_val, y_val

Chúng tôi đào tạo mô hình với Trình tối ưu hóa Adam (tỷ lệ học tập = 3e-4, loss=cross_entropy trong 300 kỷ nguyên)

300 là một con số thử nghiệm vì sau 300 kỷ nguyên, mô hình có xu hướng khớp quá mức

model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=3e-4), loss=tf.keras.losses.sparse_categorical_crossentropy, metrics=['acc'])history = model.fit(x_train, y_train, epochs=300, validation_data=(x_val, y_val), callbacks=[tensorboard])

A sau khi đào tạo khoảng 300 kỷ nguyên, chúng tôi đã có thể giảm được 2. 6692 và mất xác thực là 2. 6995 và độ chính xác 26% trên dữ liệu xác thực. Kết quả này thu được với 5000 hàng dữ liệu được tạo giả.

Mô hình có độ chính xác thấp là một lựa chọn tốt hơn nhiều so với mô hình được trang bị quá mức

Nếu chúng tôi tăng dữ liệu của mình và sau đó đào tạo mô hình của mình, chúng tôi chắc chắn sẽ nhận được kết quả tốt hơn

Để kiểm tra mô hình của mình, chúng tôi đã chạy một đánh giá mang lại độ chính xác là 26%. Để rõ ràng, chúng tôi đã phát triển một chức năng thử nghiệm tạo ra xác suất cho từng ký tự trong số 90 ký tự

def test():
    for i, j in enumerate(model.predict(x_test[0].reshape(1,-1))[0]):
        print ("{} -> {}".format(mapping_character[i], j))test()

Để kết thúc, chúng tôi đã phát triển một mạng có khả năng dự đoán xác suất chiến thắng cho từng ký tự trong số 90 ký tự. Chúng tôi đã xử lý trước tập dữ liệu ban đầu từ Kaggle và tạo một tập dữ liệu mới có khả năng phân loại nhiều lớp. Mô hình của chúng tôi không đạt được độ chính xác cao nhưng nó cũng không quá phù hợp. Sau khi thử mọi kỹ thuật trong cuốn sách để chống lại việc trang bị quá nhiều, chúng tôi đã đi đến kết luận là tạo thêm dữ liệu để huấn luyện mô hình của mình.

Cuối cùng, chúng tôi đã có thể phát triển OmniNet, điều này đã khiến Azmuth, người sáng tạo trao cho chúng tôi hợp đồng trọn đời để phát triển phần mềm Omnitrix

Tôi có thể sử dụng Python để vẽ không?

Mã để vẽ hình vuông trong Python là gì?

Làm thế nào để tạo shinchan bằng Python?