from pulp import LpMaximize, LpProblem, LpStatus, lpSum, LpVariable

# 問題の定義
model = LpProblem(name="small-shop-problem", sense=LpMaximize)

# 変数の定義
x = {i: LpVariable(name=f"x{i}", lowBound=0, upBound=10, cat="Integer") for i in range(1, 4)}

# 利益の定義
profit = {1: 100, 2: 200, 3: 300}

# 目的関数
model += lpSum(profit[i] * x[i] for i in range(1, 4))

# 制約条件
model += (lpSum(x[i] for i in range(1, 4)) <= 2000, "budget_constraint")

# 問題の解
status = model.solve()

for var in x.values():
    print(f"{var.name}: {var.value()}")

print(f"Optimal profit: {model.objective.value()}")

import matplotlib.pyplot as plt

# 商品名
items = ['Item A', 'Item B', 'Item C']

# 最適な在庫数
optimal_values = [x[i].value() for i in range(1, 4)]

plt.bar(items, optimal_values)
plt.xlabel('Items')
plt.ylabel('Optimal Stock')
plt.title('Optimal Stock Level for Each Item')
plt.show()

from pulp import *
import numpy as np
import matplotlib.pyplot as plt

# 各投資商品のリターンとリスク
returns = {'A': 0.1, 'B': 0.12, 'C': 0.10, 'D': 0.07}
risks = {'A': 0.05, 'B': 0.07, 'C': 0.06, 'D': 0.03}

# 投資商品のリスト
assets = list(returns.keys())

# リスクの上限
risk_limit = 0.05

# 問題の定義
prob = LpProblem("Efficient Frontier", LpMaximize)

# 変数の定義
x = LpVariable.dicts("x", assets, 0)

# 目的関数
prob += lpSum([returns[i]*x[i] for i in assets])

# 制約条件
prob += lpSum([risks[i]*x[i] for i in assets]) <= risk_limit
prob += lpSum([x[i] for i in assets]) == 1

# 問題の解
prob.solve()

# 結果の表示
for i in assets:
    print(f"Investment in asset {i}: {x[i].varValue}")

# リスクとリターンのリスト
risks_list = np.linspace(0.01, 0.1, 100)
returns_list = []

for risk_limit in risks_list:
    prob = LpProblem("Efficient Frontier", LpMaximize)
    x = LpVariable.dicts("x", assets, 0)
    prob += lpSum([returns[i]*x[i] for i in assets])
    prob += lpSum([risks[i]*x[i] for i in assets]) <= risk_limit
    prob += lpSum([x[i] for i in assets]) == 1
    prob.solve()
    returns_list.append(value(prob.objective))

# グラフの描画
plt.plot(risks_list, returns_list)
plt.xlabel('Risk')
plt.ylabel('Return')
plt.title('Efficient Frontier')
plt.show()

from pulp import LpProblem, LpMinimize, LpVariable, lpSum
import pandas as pd
import matplotlib.pyplot as plt

# データの設定
# 供給地点と供給量
supply_points = {'Factory1': 500, 'Factory2': 600}
# 需要地点と需要量
demand_points = {'Shop1': 300, 'Shop2': 400, 'Shop3': 400}
# 供給地点から需要地点への輸送コスト
costs = {
    'Factory1': {'Shop1': 2, 'Shop2': 4, 'Shop3': 5},
    'Factory2': {'Shop1': 3, 'Shop2': 1, 'Shop3': 3}
}

# 問題の定義
prob = LpProblem('Transportation', LpMinimize)

# 変数の定義
vars = {
    i: {
        j: LpVariable(f"x({i},{j})", lowBound=0)
        for j in demand_points
    }
    for i in supply_points
}

# 目的関数の定義
prob += lpSum(costs[i][j] * vars[i][j] for i in supply_points for j in demand_points)

# 制約条件の定義
for i in supply_points:
    prob += lpSum(vars[i][j] for j in demand_points) <= supply_points[i]
for j in demand_points:
    prob += lpSum(vars[i][j] for i in supply_points) >= demand_points[j]

# 問題の解法
prob.solve()

# 結果の表示
for v in prob.variables():
    print(v.name, "=", v.varValue)

# 結果のグラフ化
df = pd.DataFrame([(v.name, v.varValue) for v in prob.variables()], columns=['Variable', 'Value'])
df.plot(kind='bar', x='Variable', y='Value')
plt.show()

import matplotlib.pyplot as plt
import numpy as np

# メニュー項目の人気度と利益率
popularity = [5, 8, 3, 6, 9, 2]
profit = [7, 12, 4, 8, 15, 3]

# メニュー項目の最大数
max_items = 3

# メニュー項目の数
n = len(profit)

# メニュー最適化問題を解くための動的計画法
dp = np.zeros((n+1, max_items+1))

for i in range(n+1):
    for j in range(max_items+1):
        if i == 0 or j == 0:
            dp[i][j] = 0
        elif popularity[i-1] <= j:
            dp[i][j] = max(profit[i-1] + dp[i-1][j-popularity[i-1]], dp[i-1][j])
        else:
            dp[i][j] = dp[i-1][j]

# 最適なメニュー構成の利益
optimal_profit = dp[n][max_items]

print("最適なメニュー構成の利益: ", optimal_profit)

# グラフ化
plt.bar(range(1, n+1), profit)
plt.xlabel('menu')
plt.ylabel('profit')
plt.title('profit of menu')
plt.show()

import numpy as np
from scipy.optimize import minimize
import matplotlib.pyplot as plt

# 都市の位置
cities = np.array([2, 5, 11, 16, 20, 23, 27, 30])

# 目的関数（全ての都市から施設までの距離の合計）
def objective(x):
    return np.sum(np.abs(cities - x))

# 初期値
x0 = np.array([15])

# 最適化
result = minimize(objective, x0, method='Nelder-Mead')

# 結果の表示
print("Optimal location: ", result.x)

# グラフの描画
plt.figure(figsize=(8, 4))
plt.plot(cities, [1]*len(cities), 'ro')
plt.plot(result.x, [1], 'bo')
plt.yticks([])
plt.grid(True)
plt.show()

import numpy as np
from scipy.optimize import minimize
import matplotlib.pyplot as plt

# 都市の位置
cities = np.array([[2, 3], [5, 1], [1, 6], [8, 6], [7, 4], [4, 7], [6, 2], [3, 4]])

# 目的関数（全ての都市から施設までの距離の合計）
def objective(x):
    return np.sum(np.sqrt(np.sum((cities - x)**2, axis=1)))

# 初期値
x0 = np.array([5, 5])

# 最適化
result = minimize(objective, x0, method='Nelder-Mead')

# 結果の表示
print("Optimal location: ", result.x)

# グラフの描画
plt.figure(figsize=(8, 8))
plt.plot(cities[:, 0], cities[:, 1], 'ro')
plt.plot(result.x[0], result.x[1], 'bo')
plt.grid(True)
plt.show()

import numpy as np
from scipy.optimize import minimize
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt

# 都市の位置
cities = np.array([[2, 3, 1], [5, 1, 6], [1, 6, 4], [8, 6, 2], [7, 4, 5], [4, 7, 3], [6, 2, 7], [3, 4, 2]])

# 目的関数（全ての都市から施設までの距離の合計）
def objective(x):
    return np.sum(np.sqrt(np.sum((cities - x)**2, axis=1)))

# 初期値
x0 = np.array([5, 5, 5])

# 最適化
result = minimize(objective, x0, method='Nelder-Mead')

# 結果の表示
print("Optimal location: ", result.x)

# グラフの描画
fig = plt.figure(figsize=(8, 8))
ax = fig.add_subplot(111, projection='3d')
ax.scatter(cities[:, 0], cities[:, 1], cities[:, 2], c='r', marker='o')
ax.scatter(result.x[0], result.x[1], result.x[2], c='b', marker='x')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
plt.show()

from scipy.optimize import minimize
import numpy as np

# 各地域の最大人口
max_populations = np.array([1000, 2000, 1500, 500, 1200])

# 各地域の満足度関数（ここでは単純化のためにランダムな値を使用）
satisfaction = np.random.rand(5)

# 目的関数（最小化するために-1を掛ける）
def objective(populations):
    return -np.sum(satisfaction * populations)

# 制約（各地域の人口はその地域の最大人口を超えない）
constraints = [{'type': 'ineq', 'fun': lambda x: max_populations - x}]

# 初期値
x0 = np.array([500, 500, 500, 500, 500])

# 最適化
res = minimize(objective, x0, method='SLSQP', constraints=constraints)

print("Optimal population distribution:", res.x)

from scipy.optimize import minimize

# 目的関数
def objective(x):
    return x[0]**2 + x[1]**2  # 最小化したい関数（例: x^2 + y^2）

# 制約条件
def constraint(x):
    return x[0] + x[1] - 1  # 制約条件（例: x + y <= 1）

# 初期値
x0 = [0, 0]  # 初期値の設定

# 制約付き最小化問題を解く
result = minimize(objective, x0, constraints={'type': 'ineq', 'fun': constraint})

# 結果を表示
print("最適解:", result.x)
print("最適な目的関数値:", result.fun)

import numpy as np
import pandas as pd
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

diabetes = datasets.load_diabetes()

X = diabetes.data
y = diabetes.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)

model = LinearRegression()
model.fit(X_train, y_train)

y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
print("Mean squared error: ", mse)

import matplotlib.pyplot as plt

plt.scatter(y_test, y_pred)
plt.xlabel("Actual Progression")
plt.ylabel("Predicted Progression")
plt.title("Actual vs Predicted Progression")

# 対角線を描画
diagonal_line = np.linspace(min(y_test), max(y_test), 100)
plt.plot(diagonal_line, diagonal_line, color='red', linestyle='--')

plt.show()

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.neighbors import NearestNeighbors

# データの読み込み（ここでは仮のデータを使用）
data = pd.DataFrame({
    'user_id': [1, 1, 2, 2, 3, 3, 4, 4, 5, 5],
    'item_id': [1, 2, 1, 3, 2, 3, 1, 4, 4, 5],
    'rating': [5, 4, 4, 5, 3, 4, 5, 4, 5, 4]
})

# 訓練データとテストデータに分割
train_data, test_data = train_test_split(data, test_size=0.2, random_state=42)

# ユーザー-アイテム行列の作成
user_item_matrix = train_data.pivot_table(index='user_id', columns='item_id', values='rating').fillna(0)

# k近傍法モデルの作成と訓練
model = NearestNeighbors(metric='cosine', algorithm='brute')
model.fit(user_item_matrix)

# ユーザーに対するアイテムのレコメンデーション
user_id = 1
n_recommendations = 3

# 類似ユーザーの検索
distances, indices = model.kneighbors(user_item_matrix.loc[user_id].values.reshape(1, -1), n_neighbors=n_recommendations+1)

# 類似ユーザーの評価データを取得
similar_users_ratings = user_item_matrix.iloc[indices.flatten()[1:]]

# 類似ユーザーの評価の平均を計算
mean_ratings = similar_users_ratings.mean(axis=0)

# すでに評価済みのアイテムを除外
recommended_items = mean_ratings[user_item_matrix.loc[user_id] == 0].sort_values(ascending=False).index.tolist()

print(f"ユーザー {user_id} におすすめのアイテム: {recommended_items[:n_recommendations]}")

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.neighbors import NearestNeighbors

# データの読み込み（ここでは仮のデータを使用）
data = pd.DataFrame({
    'user_id': [1, 1, 2, 2, 3, 3, 4, 4, 5, 5],
    'item_id': [1, 2, 1, 3, 2, 3, 1, 4, 4, 5],
    'rating': [5, 4, 4, 5, 3, 4, 5, 4, 5, 4]
})

# ユーザー-アイテム行列の作成
user_item_matrix = data.pivot_table(index='user_id', columns='item_id', values='rating').fillna(0)

# グラフの作成
fig, ax = plt.subplots()
cax = ax.matshow(user_item_matrix, cmap='viridis')
fig.colorbar(cax)

# 軸の設定
ax.set_xticks(np.arange(len(user_item_matrix.columns)))
ax.set_yticks(np.arange(len(user_item_matrix.index)))
ax.set_xticklabels(user_item_matrix.columns)
ax.set_yticklabels(user_item_matrix.index)

# グラフの表示
plt.xlabel('Item ID')
plt.ylabel('User ID')
plt.title('User-Item Matrix')
plt.show()

import numpy as np
from scipy.optimize import linprog

# 目的関数の係数 (最大化のためにマイナスにする)
c = np.array([-100, -150])

# 制約条件の係数
A = np.array([[1, 2], [3, 1]])
b = np.array([4, 6])

# 変数の範囲 (0以上)
x_bounds = (0, None)
y_bounds = (0, None)

# 最適化問題を解く
res = linprog(c, A_ub=A, b_ub=b, bounds=[x_bounds, y_bounds], method='highs')

print(res)

import numpy as np
import matplotlib.pyplot as plt

# 制約条件の直線を描画する関数
def plot_constraints(x):
    y1 = (4 - x) / 2
    y2 = 6 - 3 * x
    return y1, y2

# xの範囲を設定
x = np.linspace(0, 4, 100)

# 制約条件の直線を計算
y1, y2 = plot_constraints(x)

# 最適な生産計画を計算
optimal_x = res.x[0]
optimal_y = res.x[1]

# グラフを描画
plt.plot(x, y1, label="1x + 2y <= 4")
plt.plot(x, y2, label="3x + 1y <= 6")
plt.xlim(0, 4)
plt.ylim(0, 4)
plt.xlabel("Product A")
plt.ylabel("Product B")
plt.legend()

# 最適な生産計画を示す点を描画
plt.plot(optimal_x, optimal_y, 'ro', label="Optimal Production Plan")
plt.annotate(f"({optimal_x:.2f}, {optimal_y:.2f})", (optimal_x + 0.1, optimal_y - 0.2))

plt.show()